diff --git a/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -24,7 +24,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     const std::map<int, double, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
@@ -32,7 +32,7 @@
     }
 #if TEST_STD_VER >= 11
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     const std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
diff --git a/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
@@ -23,7 +23,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<std::pair<const int, double> > A;
     std::map<int, double, C, A> m(C(4), A(5));
     assert(m.empty());
@@ -33,7 +33,7 @@
     }
 #if TEST_STD_VER >= 11
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
     std::map<int, double, C, A> m(C(4), A());
     assert(m.empty());
@@ -42,7 +42,7 @@
     assert(m.get_allocator() == A());
     }
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef explicit_allocator<std::pair<const int, double> > A;
     std::map<int, double, C, A> m(C(4), A{});
     assert(m.empty());
diff --git a/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp
@@ -36,7 +36,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::map<int, double, C, A> m = mo;
@@ -71,7 +71,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::map<int, double, C, A> m = mo;
@@ -105,7 +105,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m = mo;
diff --git a/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
@@ -36,7 +36,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::map<int, double, C, A> m(mo, A(3));
@@ -71,7 +71,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     std::map<int, double, C, A> m(mo, A());
@@ -105,7 +105,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef explicit_allocator<V> A;
     std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
     std::map<int, double, C, A> m(mo, A{});
diff --git a/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
@@ -130,7 +130,7 @@
             V(3, 1.5),
             V(3, 2)
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
@@ -180,7 +180,7 @@
             V(3, 1.5),
             V(3, 2)
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
@@ -216,7 +216,7 @@
             V(3, 1.5),
             V(3, 2)
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
@@ -251,7 +251,7 @@
             V(3, 1.5),
             V(3, 2)
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
@@ -288,7 +288,7 @@
             V(3, 1.5),
             V(3, 2)
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef counting_allocatorT<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(1));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(2));
@@ -322,7 +322,7 @@
             V(3, 1.5),
             V(3, 2)
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef counting_allocatorF<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(100));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(200));
diff --git a/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
@@ -24,7 +24,7 @@
 {
     {
     typedef std::pair<const int, double> V;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     std::map<int, double, C> m({
                                 {1, 1},
                                 {1, 1.5},
@@ -45,7 +45,7 @@
     }
     {
     typedef std::pair<const int, double> V;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     std::map<int, double, C, min_allocator<std::pair<const int, double>>> m({
                                 {1, 1},
                                 {1, 1.5},
diff --git a/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
@@ -25,7 +25,7 @@
 {
     {
     typedef std::pair<const int, double> V;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<std::pair<const int, double> > A;
     std::map<int, double, C, A> m({
                                    {1, 1},
@@ -48,7 +48,7 @@
     }
     {
     typedef std::pair<const int, double> V;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
     std::map<int, double, C, A> m({
                                    {1, 1},
@@ -72,7 +72,7 @@
     {
     typedef std::pair<const int, double> V;
     typedef min_allocator<V> A;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef std::map<int, double, C, A> M;
     A a;
     M m ({ {1, 1},
@@ -96,7 +96,7 @@
     {
     typedef std::pair<const int, double> V;
     typedef explicit_allocator<V> A;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     A a;
     std::map<int, double, C, A> m({
                                    {1, 1},
diff --git a/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
@@ -36,7 +36,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     std::map<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
@@ -60,7 +60,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
diff --git a/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
@@ -38,7 +38,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     assert(m.get_allocator() == A(7));
@@ -64,7 +64,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     assert(m.get_allocator() == A());
@@ -92,7 +92,7 @@
     };
     {
     typedef min_allocator<V> A;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     A a;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
 
@@ -105,7 +105,7 @@
     }
     {
     typedef explicit_allocator<V> A;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     A a;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
 
diff --git a/libcxx/test/std/containers/associative/map/map.cons/move.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/move.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/move.pass.cpp
@@ -26,7 +26,7 @@
 {
     typedef std::pair<const int, double> V;
     {
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(C(5), A(7));
         std::map<int, double, C, A> m = std::move(mo);
@@ -53,7 +53,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::map<int, double, C, A> m = std::move(mo);
@@ -71,7 +71,7 @@
         assert(distance(mo.begin(), mo.end()) == 0);
     }
     {
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(C(5), A());
         std::map<int, double, C, A> m = std::move(mo);
@@ -98,7 +98,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m = std::move(mo);
diff --git a/libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -29,7 +29,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -68,7 +68,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -107,7 +107,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -196,7 +196,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef min_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -235,7 +235,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef explicit_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/map/map.cons/move_assign.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
@@ -28,7 +28,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -68,7 +68,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -108,7 +108,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -148,7 +148,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef min_allocator<VC> A;
         typedef std::map<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp b/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
@@ -101,7 +101,7 @@
     }
     {
         typedef test_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::map<int, double, C, A> M;
         V ar1[] =
         {
@@ -135,7 +135,7 @@
     }
     {
         typedef other_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::map<int, double, C, A> M;
         V ar1[] =
         {
@@ -245,7 +245,7 @@
     }
     {
         typedef min_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::map<int, double, C, A> M;
         V ar1[] =
         {
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -24,7 +24,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     const std::multimap<int, double, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
@@ -32,7 +32,7 @@
     }
 #if TEST_STD_VER >= 11
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     const std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
@@ -23,7 +23,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<std::pair<const int, double> > A;
     std::multimap<int, double, C, A> m(C(4), A(5));
     assert(m.empty());
@@ -33,7 +33,7 @@
     }
 #if TEST_STD_VER >= 11
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
     std::multimap<int, double, C, A> m(C(4), A());
     assert(m.empty());
@@ -42,7 +42,7 @@
     assert(m.get_allocator() == A());
     }
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef explicit_allocator<std::pair<const int, double> > A;
     std::multimap<int, double, C, A> m(C(4), A{});
     assert(m.empty());
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
@@ -36,7 +36,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multimap<int, double, C, A> m = mo;
@@ -62,7 +62,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multimap<int, double, C, A> m = mo;
@@ -87,7 +87,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::multimap<int, double, C, A> m = mo;
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
@@ -36,7 +36,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::multimap<int, double, C, A> m(mo, A(3));
@@ -62,7 +62,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     std::multimap<int, double, C, A> m(mo, A());
@@ -87,7 +87,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef explicit_allocator<V> A;
     std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
     std::multimap<int, double, C, A> m(mo, A{});
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
@@ -36,7 +36,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
@@ -82,7 +82,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
@@ -109,7 +109,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
@@ -23,7 +23,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef std::multimap<int, double, Cmp> C;
     typedef C::value_type V;
     C m(
@@ -55,7 +55,7 @@
     assert(m.key_comp() == Cmp(4));
     }
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef std::multimap<int, double, Cmp, min_allocator<std::pair<const int, double>>> C;
     typedef C::value_type V;
     C m(
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
@@ -24,7 +24,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef test_allocator<std::pair<const int, double> > A;
     typedef std::multimap<int, double, Cmp, A> C;
     typedef C::value_type V;
@@ -58,7 +58,7 @@
     assert(m.get_allocator() == A(5));
     }
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef min_allocator<std::pair<const int, double> > A;
     typedef std::multimap<int, double, Cmp, A> C;
     typedef C::value_type V;
@@ -92,7 +92,7 @@
     assert(m.get_allocator() == A());
     }
     {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef std::pair<const int, double> V;
     typedef min_allocator<V> A;
     typedef std::multimap<int, double, C, A> M;
@@ -123,7 +123,7 @@
     assert(m.get_allocator() == a);
     }
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef explicit_allocator<std::pair<const int, double> > A;
     typedef std::multimap<int, double, Cmp, A> C;
     typedef C::value_type V;
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
@@ -37,7 +37,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     std::multimap<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
@@ -67,7 +67,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     std::multimap<int, double, C, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
@@ -38,7 +38,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     assert(m.get_allocator() == A(7));
@@ -70,7 +70,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     assert(m.get_allocator() == A());
@@ -101,7 +101,7 @@
         V(3, 1.5),
         V(3, 2),
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef explicit_allocator<V> A;
     std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
     assert(m.get_allocator() == A{});
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
@@ -26,7 +26,7 @@
 {
     typedef std::pair<const int, double> V;
     {
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multimap<int, double, C, A> mo(C(5), A(7));
         std::multimap<int, double, C, A> m = std::move(mo);
@@ -53,7 +53,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multimap<int, double, C, A> m = std::move(mo);
@@ -77,7 +77,7 @@
         assert(distance(mo.begin(), mo.end()) == 0);
     }
     {
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multimap<int, double, C, A> mo(C(5), A());
         std::multimap<int, double, C, A> m = std::move(mo);
@@ -104,7 +104,7 @@
             V(3, 1.5),
             V(3, 2),
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::multimap<int, double, C, A> m = std::move(mo);
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -29,7 +29,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -68,7 +68,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -107,7 +107,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -196,7 +196,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef min_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -235,7 +235,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef explicit_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
@@ -28,7 +28,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -68,7 +68,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -108,7 +108,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -148,7 +148,7 @@
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef min_allocator<VC> A;
         typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
@@ -101,7 +101,7 @@
     }
     {
         typedef test_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::multimap<int, double, C, A> M;
         V ar1[] =
         {
@@ -135,7 +135,7 @@
     }
     {
         typedef other_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::multimap<int, double, C, A> M;
         V ar1[] =
         {
@@ -245,7 +245,7 @@
     }
     {
         typedef min_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::multimap<int, double, C, A> M;
         V ar1[] =
         {
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
@@ -24,7 +24,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     const std::multiset<int, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
@@ -21,7 +21,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<int> A;
     std::multiset<int, C, A> m(C(4), A(5));
     assert(m.empty());
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
@@ -35,7 +35,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multiset<int, C, A> m = mo;
@@ -82,7 +82,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multiset<int, C, A> m = mo;
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
@@ -34,7 +34,7 @@
         3,
         3
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::multiset<int, C, A> m(mo, A(3));
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
@@ -35,7 +35,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
@@ -102,7 +102,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
@@ -21,7 +21,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef std::multiset<int, Cmp> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, Cmp(10));
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
@@ -22,7 +22,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef test_allocator<int> A;
     typedef std::multiset<int, Cmp, A> C;
     typedef C::value_type V;
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
@@ -38,7 +38,7 @@
         3,
         3
     };
-    typedef test_compare<std::less<V> > C;
+    typedef test_less<V> C;
     typedef test_allocator<V> A;
     std::multiset<V, C, A> m(cpp17_input_iterator<const V*>(ar),
                         cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
@@ -73,7 +73,7 @@
         3
     };
     typedef test_allocator<V> A;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     A a;
     std::multiset<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
 
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
@@ -35,7 +35,7 @@
         3,
         3
     };
-    typedef test_compare<std::less<V> > C;
+    typedef test_less<V> C;
     std::multiset<V, C> m(cpp17_input_iterator<const V*>(ar),
                      cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
     assert(m.value_comp() == C(5));
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
@@ -26,7 +26,7 @@
 {
     {
         typedef int V;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(C(5), A(7));
         std::multiset<int, C, A> m = std::move(mo);
@@ -54,7 +54,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multiset<int, C, A> m = std::move(mo);
@@ -91,7 +91,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::multiset<int, C, A> m = std::move(mo);
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -27,7 +27,7 @@
 {
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -65,7 +65,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -103,7 +103,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
@@ -27,7 +27,7 @@
 {
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -66,7 +66,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -105,7 +105,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -144,7 +144,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef min_allocator<V> A;
         typedef std::multiset<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
@@ -98,7 +98,7 @@
     }
     {
         typedef test_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::set<int, C, A> M;
         V ar1[] =
         {
@@ -132,7 +132,7 @@
     }
     {
         typedef other_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::set<int, C, A> M;
         V ar1[] =
         {
diff --git a/libcxx/test/std/containers/associative/set/set.cons/compare.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/compare.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/compare.pass.cpp
@@ -24,7 +24,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     const std::set<int, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
diff --git a/libcxx/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
@@ -21,7 +21,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<int> A;
     std::set<int, C, A> m(C(4), A(5));
     assert(m.empty());
diff --git a/libcxx/test/std/containers/associative/set/set.cons/copy.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/copy.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/copy.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/copy.pass.cpp
@@ -35,7 +35,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::set<int, C, A> m = mo;
@@ -70,7 +70,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::set<int, C, A> m = mo;
diff --git a/libcxx/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
@@ -34,7 +34,7 @@
         3,
         3
     };
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::set<int, C, A> m(mo, A(3));
diff --git a/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
@@ -35,7 +35,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
@@ -85,7 +85,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
diff --git a/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
@@ -21,7 +21,7 @@
 
 int main(int, char**)
 {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef std::set<int, Cmp> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, Cmp(10));
diff --git a/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
@@ -24,7 +24,7 @@
 int main(int, char**)
 {
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef test_allocator<int> A;
     typedef std::set<int, Cmp, A> C;
     typedef C::value_type V;
@@ -42,7 +42,7 @@
     assert(m.get_allocator() == A(4));
     }
     {
-    typedef test_compare<std::less<int> > Cmp;
+    typedef test_less<int> Cmp;
     typedef test_allocator<int> A;
     typedef std::set<int, Cmp, A> C;
     typedef C::value_type V;
diff --git a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
@@ -42,7 +42,7 @@
         3,
         3
     };
-    typedef test_compare<std::less<V> > C;
+    typedef test_less<V> C;
     typedef test_allocator<V> A;
     std::set<V, C, A> m(cpp17_input_iterator<const V*>(ar),
                         cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
@@ -71,7 +71,7 @@
         3
     };
     typedef test_allocator<V> A;
-    typedef test_compare<std::less<int> > C;
+    typedef test_less<int> C;
     A a(7);
     std::set<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
 
diff --git a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
@@ -35,7 +35,7 @@
         3,
         3
     };
-    typedef test_compare<std::less<V> > C;
+    typedef test_less<V> C;
     std::set<V, C> m(cpp17_input_iterator<const V*>(ar),
                      cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
     assert(m.value_comp() == C(5));
diff --git a/libcxx/test/std/containers/associative/set/set.cons/move.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/move.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/move.pass.cpp
@@ -26,7 +26,7 @@
 {
     {
         typedef int V;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(C(5), A(7));
         std::set<int, C, A> m = std::move(mo);
@@ -54,7 +54,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::set<int, C, A> m = std::move(mo);
@@ -85,7 +85,7 @@
             3,
             3
         };
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::set<int, C, A> m = std::move(mo);
diff --git a/libcxx/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -27,7 +27,7 @@
 {
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -65,7 +65,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -103,7 +103,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/set/set.cons/move_assign.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
@@ -27,7 +27,7 @@
 {
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -66,7 +66,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef test_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -105,7 +105,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef other_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
@@ -144,7 +144,7 @@
     }
     {
         typedef MoveOnly V;
-        typedef test_compare<std::less<MoveOnly> > C;
+        typedef test_less<MoveOnly> C;
         typedef min_allocator<V> A;
         typedef std::set<MoveOnly, C, A> M;
         typedef std::move_iterator<V*> I;
diff --git a/libcxx/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp b/libcxx/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
@@ -98,7 +98,7 @@
     }
     {
         typedef test_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::set<int, C, A> M;
         V ar1[] =
         {
@@ -132,7 +132,7 @@
     }
     {
         typedef other_allocator<V> A;
-        typedef test_compare<std::less<int> > C;
+        typedef test_less<int> C;
         typedef std::set<int, C, A> M;
         V ar1[] =
         {
diff --git a/libcxx/test/std/containers/test_compare.h b/libcxx/test/std/containers/test_compare.h
--- a/libcxx/test/std/containers/test_compare.h
+++ b/libcxx/test/std/containers/test_compare.h
@@ -9,36 +9,28 @@
 #ifndef TEST_COMPARE_H
 #define TEST_COMPARE_H
 
-#include <cstddef>
-#include <type_traits>
-#include <cstdlib>
-#include <new>
-#include <climits>
-
-template <class C>
-class test_compare
-    : private C
+template <class T>
+struct test_equal_to
 {
     int data_;
-public:
-    explicit test_compare(int data = 0) : data_(data) {}
-
-    typename C::result_type
-    operator()(typename std::add_lvalue_reference<const typename C::first_argument_type>::type x,
-               typename std::add_lvalue_reference<const typename C::second_argument_type>::type y) const
-        {return C::operator()(x, y);}
-
-    bool operator==(const test_compare& c) const
-        {return data_ == c.data_;}
+    explicit test_equal_to() : data_(0) {}
+    explicit test_equal_to(int data) : data_(data) {}
+    bool operator()(const T& a, const T& b) const
+        { return a == b; }
+    friend bool operator==(const test_equal_to& a, const test_equal_to& b)
+        { return a.data_ == b.data_; }
 };
 
-
-template <class C>
-class non_const_compare
+template <class T>
+struct test_less
 {
-// operator() deliberately not marked as 'const'
-    bool operator()(const C& x, const C& y) { return x < y; }
+    int data_;
+    explicit test_less() : data_(0) {}
+    explicit test_less(int data) : data_(data) {}
+    bool operator()(const T& a, const T& b) const
+        { return a < b; }
+    friend bool operator==(const test_less& a, const test_less& b)
+        { return a.data_ == b.data_; }
 };
 
-
 #endif // TEST_COMPARE_H
diff --git a/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
@@ -29,7 +29,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -57,7 +57,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -105,7 +105,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -147,7 +147,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -209,7 +209,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -237,7 +237,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -285,7 +285,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -327,7 +327,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -389,7 +389,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -417,7 +417,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -465,7 +465,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -507,7 +507,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10));
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{});
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -69,13 +69,13 @@
         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         C c(A{});
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == A{});
         assert(c.size() == 0);
         assert(c.empty());
@@ -88,7 +88,7 @@
         typedef NotConstructible T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef std::unordered_map<T, T, HF, Comp, A> C;
 
         A a(10);
@@ -107,7 +107,7 @@
         typedef NotConstructible T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef std::unordered_map<T, T, HF, Comp, A> C;
 
         A a(10);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -34,7 +34,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -50,13 +50,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -67,7 +67,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -97,7 +97,7 @@
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -113,13 +113,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -130,7 +130,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -143,7 +143,7 @@
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -159,13 +159,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         c = c0;
@@ -176,7 +176,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
@@ -34,7 +34,7 @@
         typedef std::allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -66,7 +66,7 @@
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
@@ -35,7 +35,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -51,13 +51,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = std::move(c0);
@@ -68,7 +68,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -80,7 +80,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -96,13 +96,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(10)
            );
         C::iterator it0 = c0.begin();
@@ -114,7 +114,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -128,7 +128,7 @@
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -144,13 +144,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         C::iterator it0 = c0.begin();
@@ -162,7 +162,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -176,7 +176,7 @@
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -192,13 +192,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         C::iterator it0 = c0.begin();
@@ -210,7 +210,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -32,7 +32,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -48,7 +48,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C c = c0;
@@ -59,7 +59,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
@@ -72,7 +72,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    other_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -88,7 +88,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             other_allocator<std::pair<const int, std::string> >(10)
            );
         C c = c0;
@@ -99,7 +99,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (other_allocator<std::pair<const int, std::string> >(-2)));
         assert(!c.empty());
@@ -111,7 +111,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -127,7 +127,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C c = c0;
@@ -138,7 +138,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -32,7 +32,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -48,7 +48,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C c(c0, test_allocator<std::pair<const int, std::string> >(5));
@@ -59,7 +59,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(5)));
         assert(!c.empty());
@@ -72,7 +72,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -88,7 +88,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C c(c0, min_allocator<std::pair<const int, std::string> >());
@@ -99,7 +99,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -112,7 +112,7 @@
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -128,7 +128,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         C c(c0, A{});
@@ -139,7 +139,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -69,14 +69,14 @@
         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         {
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == A());
         assert(c.size() == 0);
         assert(c.empty());
@@ -89,7 +89,7 @@
         C c(a);
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == a);
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -53,7 +53,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -65,7 +65,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -84,7 +84,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -98,7 +98,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_map<int, std::string, HF, Comp, A> C;
 
         A a(42);
@@ -117,7 +117,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == a);
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -129,7 +129,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_map<int, std::string, HF, Comp, A> C;
 
         HF hf(42);
@@ -150,7 +150,7 @@
         assert(c.at(4) == "four");
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == test_hash<std::hash<int> >()));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == a);
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -55,7 +55,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -67,7 +67,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -88,7 +88,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -56,7 +56,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -68,7 +68,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -90,7 +90,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
@@ -35,7 +35,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -49,7 +49,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -58,7 +58,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -70,7 +70,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -84,7 +84,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -93,7 +93,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -35,7 +35,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -49,7 +49,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -59,7 +59,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
@@ -71,7 +71,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -85,7 +85,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -95,7 +95,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -108,7 +108,7 @@
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -122,7 +122,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -132,7 +132,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
@@ -34,12 +34,12 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C::iterator it0 = c0.begin();
@@ -47,7 +47,7 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(c.empty());
@@ -62,7 +62,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -78,7 +78,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C::iterator it0 = c0.begin();
@@ -90,7 +90,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
@@ -105,12 +105,12 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C::iterator it0 = c0.begin();
@@ -118,7 +118,7 @@
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(c.empty());
@@ -133,7 +133,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -149,7 +149,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C::iterator it0 = c0.begin();
@@ -161,7 +161,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
@@ -36,7 +36,7 @@
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -51,7 +51,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(12));
@@ -62,7 +62,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(12));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -77,7 +77,7 @@
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -92,7 +92,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(10));
@@ -103,7 +103,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -118,7 +118,7 @@
         typedef min_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -133,7 +133,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(std::move(c0), A());
@@ -144,7 +144,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -159,7 +159,7 @@
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -174,7 +174,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         C c(std::move(c0), A{});
@@ -185,7 +185,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -35,7 +35,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -56,7 +56,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -69,7 +69,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -90,7 +90,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -104,7 +104,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_map<int, std::string, HF, Comp, A> C;
 
         P arr[] =
@@ -136,7 +136,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_map<int, std::string, HF, Comp, A> C;
 
         P arr[] =
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -35,7 +35,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -58,7 +58,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -71,7 +71,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -94,7 +94,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -36,7 +36,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -60,7 +60,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -73,7 +73,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -97,7 +97,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -36,7 +36,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -52,7 +52,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -61,7 +61,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -74,7 +74,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -90,7 +90,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -99,7 +99,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -37,7 +37,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -53,7 +53,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -63,7 +63,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
@@ -76,7 +76,7 @@
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -92,7 +92,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -102,7 +102,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -115,7 +115,7 @@
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -131,7 +131,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -141,7 +141,7 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.compile.fail.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.compile.fail.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.compile.fail.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.compile.fail.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -29,7 +29,7 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
@@ -38,7 +38,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -51,7 +51,7 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
@@ -60,7 +60,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -29,17 +29,17 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -52,17 +52,17 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -29,18 +29,18 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
         assert(c.size() == 0);
@@ -53,18 +53,18 @@
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             min_allocator<std::pair<const NotConstructible, NotConstructible> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -77,17 +77,17 @@
         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A;
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == A{});
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
@@ -29,7 +29,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -57,7 +57,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -107,7 +107,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -151,7 +151,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -217,7 +217,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -245,7 +245,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -293,7 +293,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -335,7 +335,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -397,7 +397,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -425,7 +425,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -473,7 +473,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -515,7 +515,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
diff --git a/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -31,7 +31,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -59,7 +59,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -107,7 +107,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -163,7 +163,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -239,7 +239,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -267,7 +267,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -315,7 +315,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -371,7 +371,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -447,7 +447,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -475,7 +475,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -523,7 +523,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -579,7 +579,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10));
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{});
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -69,13 +69,13 @@
         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         C c(A{});
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == A{});
         assert(c.size() == 0);
         assert(c.empty());
@@ -88,7 +88,7 @@
         typedef NotConstructible T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef std::unordered_multimap<T, T, HF, Comp, A> C;
 
         A a(10);
@@ -107,7 +107,7 @@
         typedef NotConstructible T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef std::unordered_multimap<T, T, HF, Comp, A> C;
 
         A a(10);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -36,7 +36,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -52,13 +52,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -76,7 +76,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -106,7 +106,7 @@
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -122,13 +122,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -146,7 +146,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -159,7 +159,7 @@
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -175,13 +175,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         c = c0;
@@ -199,7 +199,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -37,7 +37,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -88,7 +88,7 @@
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -37,7 +37,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -53,13 +53,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = std::move(c0);
@@ -97,7 +97,7 @@
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -113,13 +113,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(10)
            );
         C::iterator it0 = c0.begin();
@@ -159,7 +159,7 @@
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -175,13 +175,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         C::iterator it0 = c0.begin();
@@ -221,7 +221,7 @@
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -237,13 +237,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         C::iterator it0 = c0.begin();
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -50,7 +50,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C c = c0;
@@ -68,7 +68,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
@@ -81,7 +81,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    other_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -97,7 +97,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             other_allocator<std::pair<const int, std::string> >(10)
            );
         C c = c0;
@@ -115,7 +115,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (other_allocator<std::pair<const int, std::string> >(-2)));
         assert(!c.empty());
@@ -127,7 +127,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -143,7 +143,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C c = c0;
@@ -161,7 +161,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -50,7 +50,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C c(c0, test_allocator<std::pair<const int, std::string> >(5));
@@ -68,7 +68,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(5)));
         assert(!c.empty());
@@ -81,7 +81,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -97,7 +97,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C c(c0, min_allocator<std::pair<const int, std::string> >());
@@ -115,7 +115,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
@@ -128,7 +128,7 @@
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -144,7 +144,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         C c(c0, A{});
@@ -162,7 +162,7 @@
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -69,14 +69,14 @@
         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         {
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == A());
         assert(c.size() == 0);
         assert(c.empty());
@@ -89,7 +89,7 @@
         C c(a);
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == a);
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -36,7 +36,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -78,13 +78,13 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -126,7 +126,7 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER > 11
@@ -134,7 +134,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
 
         A a(42);
@@ -184,7 +184,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
 
         HF hf(42);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -36,7 +36,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -80,13 +80,13 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -130,7 +130,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -36,7 +36,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -81,13 +81,13 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -132,7 +132,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -37,7 +37,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -51,7 +51,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -83,13 +83,13 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -103,7 +103,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -135,7 +135,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -37,7 +37,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -51,7 +51,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -84,13 +84,13 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -104,7 +104,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -137,14 +137,14 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -158,7 +158,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -191,7 +191,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
     }
 
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -36,20 +36,20 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
 
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(c.empty());
@@ -63,7 +63,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -79,7 +79,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         C::iterator it0 = c0.begin();
@@ -115,7 +115,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
 
         assert(c0.empty());
@@ -123,19 +123,19 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(c.empty());
@@ -149,7 +149,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -165,7 +165,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C::iterator it0 = c0.begin();
@@ -201,7 +201,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
 
         assert(c0.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -38,7 +38,7 @@
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -53,7 +53,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(12));
@@ -87,7 +87,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12)));
 
         assert(c0.empty());
@@ -97,7 +97,7 @@
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -112,7 +112,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(10));
@@ -146,7 +146,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
 
         assert(c0.empty());
@@ -156,7 +156,7 @@
         typedef min_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -171,7 +171,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(std::move(c0), A());
@@ -205,7 +205,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
 
         assert(c0.empty());
@@ -215,7 +215,7 @@
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -230,7 +230,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         C c(std::move(c0), A());
@@ -264,7 +264,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
 
         assert(c0.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -37,7 +37,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -81,14 +81,14 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -132,7 +132,7 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER > 11
@@ -140,7 +140,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
 
         P arr[] =
@@ -192,7 +192,7 @@
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
-        typedef test_compare<std::equal_to<int>> Comp;
+        typedef test_equal_to<int> Comp;
         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
 
         P arr[] =
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -37,7 +37,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -83,14 +83,14 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -136,7 +136,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -38,7 +38,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -85,14 +85,14 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -139,7 +139,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -38,7 +38,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -54,7 +54,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -86,14 +86,14 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -109,7 +109,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -141,7 +141,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -39,7 +39,7 @@
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -55,7 +55,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -88,14 +88,14 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -111,7 +111,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -144,14 +144,14 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef std::pair<int, std::string> P;
@@ -167,7 +167,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -200,7 +200,7 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.compile.fail.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.compile.fail.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.compile.fail.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.compile.fail.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -29,14 +29,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -49,14 +49,14 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -29,7 +29,7 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
@@ -38,7 +38,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -51,7 +51,7 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
@@ -60,7 +60,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -29,17 +29,17 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -52,17 +52,17 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -29,18 +29,18 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<std::pair<const NotConstructible,
                                                                   NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
         assert(c.size() == 0);
@@ -53,18 +53,18 @@
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<std::pair<const NotConstructible,
                                                                  NotConstructible> >
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             min_allocator<std::pair<const NotConstructible, NotConstructible> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
         assert(c.size() == 0);
@@ -77,17 +77,17 @@
         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A;
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == A{});
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -31,7 +31,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -59,7 +59,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -109,7 +109,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -158,7 +158,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -229,7 +229,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -257,7 +257,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -305,7 +305,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -352,7 +352,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -419,7 +419,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -447,7 +447,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -495,7 +495,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
@@ -542,7 +542,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
diff --git a/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -28,7 +28,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -56,7 +56,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -104,7 +104,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -146,7 +146,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -208,7 +208,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -236,7 +236,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -284,7 +284,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -326,7 +326,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -388,7 +388,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -416,7 +416,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -464,7 +464,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -506,7 +506,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(test_allocator<NotConstructible>(10));
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == test_allocator<NotConstructible>(10));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(min_allocator<NotConstructible>{});
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == min_allocator<NotConstructible>());
         assert(c.size() == 0);
         assert(c.empty());
@@ -65,7 +65,7 @@
     {
         typedef NotConstructible T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_multiset<T, HF, Comp, A> C;
 
@@ -85,7 +85,7 @@
     {
         typedef NotConstructible T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_multiset<T, HF, Comp, A> C;
 
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -34,7 +34,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -50,13 +50,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -67,7 +67,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -98,7 +98,7 @@
         typedef other_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -114,13 +114,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -131,7 +131,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -144,7 +144,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -160,13 +160,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         c = c0;
@@ -177,7 +177,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
@@ -34,7 +34,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -66,7 +66,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -35,7 +35,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -51,13 +51,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = std::move(c0);
@@ -68,7 +68,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -80,7 +80,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -96,13 +96,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(10)
            );
         C::iterator it0 = c0.begin();
@@ -114,7 +114,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -127,7 +127,7 @@
         typedef other_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -143,13 +143,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         C::iterator it0 = c0.begin();
@@ -161,7 +161,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -174,7 +174,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -190,13 +190,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         C::iterator it0 = c0.begin();
@@ -208,7 +208,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -221,7 +221,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -237,13 +237,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         C::iterator it0 = c0.begin();
@@ -255,7 +255,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -32,7 +32,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -48,7 +48,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C c = c0;
@@ -59,7 +59,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -71,7 +71,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    other_allocator<int>
                                    > C;
         typedef int P;
@@ -87,7 +87,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             other_allocator<int>(10)
            );
         C c = c0;
@@ -98,7 +98,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -109,7 +109,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -125,7 +125,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C c = c0;
@@ -136,7 +136,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -32,7 +32,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -48,7 +48,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C c(c0, test_allocator<int>(5));
@@ -59,7 +59,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(5));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -71,7 +71,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -87,7 +87,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C c(c0, min_allocator<int>());
@@ -98,7 +98,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -65,14 +65,14 @@
         typedef explicit_allocator<NotConstructible> A;
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         {
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == A());
         assert(c.size() == 0);
         assert(c.empty());
@@ -85,7 +85,7 @@
         C c(a);
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == a);
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -52,7 +52,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -63,7 +63,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -82,7 +82,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -94,7 +94,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_multiset<T, HF, Comp, A> C;
 
@@ -127,7 +127,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_multiset<T, HF, Comp, A> C;
 
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -54,7 +54,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -65,7 +65,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -86,7 +86,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -56,7 +56,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -67,7 +67,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -89,7 +89,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -48,7 +48,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -57,7 +57,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -68,7 +68,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -82,7 +82,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -91,7 +91,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -48,7 +48,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -58,7 +58,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -69,7 +69,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -83,7 +83,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -93,7 +93,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
@@ -33,19 +33,19 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -58,7 +58,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -74,7 +74,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C::iterator it0 = c0.begin();
@@ -87,7 +87,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -100,19 +100,19 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -125,7 +125,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -141,7 +141,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C::iterator it0 = c0.begin();
@@ -154,7 +154,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -36,7 +36,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -51,7 +51,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(12));
@@ -62,7 +62,7 @@
         CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
         CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(12));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -77,7 +77,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -92,7 +92,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(10));
@@ -103,7 +103,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -118,7 +118,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -133,7 +133,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(std::move(c0), A());
@@ -144,7 +144,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -159,7 +159,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -174,7 +174,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(std::move(c0), A());
@@ -185,7 +185,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -54,7 +54,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -66,7 +66,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -87,7 +87,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -99,7 +99,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_multiset<T, HF, Comp, A> C;
         T arr[] =
@@ -132,7 +132,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_multiset<T, HF, Comp, A> C;
         T arr[] =
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -56,7 +56,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -68,7 +68,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -91,7 +91,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -58,7 +58,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -70,7 +70,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -94,7 +94,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -50,7 +50,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -59,7 +59,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -71,7 +71,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -87,7 +87,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
@@ -96,7 +96,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -35,7 +35,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -51,7 +51,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -61,7 +61,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -73,7 +73,7 @@
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -89,7 +89,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -99,7 +99,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.compile.fail.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.compile.fail.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.compile.fail.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.compile.fail.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -29,7 +29,7 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7,
@@ -37,7 +37,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -49,7 +49,7 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7,
@@ -57,7 +57,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -29,16 +29,16 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -50,16 +50,16 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -29,17 +29,17 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (test_allocator<NotConstructible>(10)));
         assert(c.size() == 0);
         assert(c.empty());
@@ -51,17 +51,17 @@
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             min_allocator<std::pair<const NotConstructible, NotConstructible> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -28,7 +28,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -56,7 +56,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -106,7 +106,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -150,7 +150,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -216,7 +216,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -244,7 +244,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -292,7 +292,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -334,7 +334,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -396,7 +396,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -424,7 +424,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -472,7 +472,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -514,7 +514,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
diff --git a/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -28,7 +28,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -56,7 +56,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -104,7 +104,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -146,7 +146,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -208,7 +208,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -236,7 +236,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -284,7 +284,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -326,7 +326,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -388,7 +388,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -416,7 +416,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -464,7 +464,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -506,7 +506,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(test_allocator<NotConstructible>(10));
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == test_allocator<NotConstructible>(10));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(min_allocator<NotConstructible>{});
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == min_allocator<NotConstructible>());
         assert(c.size() == 0);
         assert(c.empty());
@@ -65,7 +65,7 @@
     {
         typedef NotConstructible T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_set<T, HF, Comp, A> C;
 
@@ -85,7 +85,7 @@
     {
         typedef NotConstructible T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_set<T, HF, Comp, A> C;
 
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -33,7 +33,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -49,13 +49,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -66,7 +66,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -96,7 +96,7 @@
         typedef other_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -112,13 +112,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = c0;
@@ -129,7 +129,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -142,7 +142,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -158,13 +158,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         c = c0;
@@ -175,7 +175,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
@@ -34,7 +34,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -66,7 +66,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
@@ -34,7 +34,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -50,13 +50,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         c = std::move(c0);
@@ -67,7 +67,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -79,7 +79,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -95,13 +95,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(10)
            );
         C::iterator it0 = c0.begin();
@@ -113,7 +113,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -126,7 +126,7 @@
         typedef other_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -142,13 +142,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A(4)
            );
         C::iterator it0 = c0.begin();
@@ -160,7 +160,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -173,7 +173,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         typedef int P;
@@ -189,13 +189,13 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(a, a + 2,
             7,
             test_hash<std::hash<int> >(2),
-            test_compare<std::equal_to<int> >(3),
+            test_equal_to<int>(3),
             A()
            );
         C::iterator it0 = c0.begin();
@@ -207,7 +207,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -31,7 +31,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -47,7 +47,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C c = c0;
@@ -58,7 +58,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -70,7 +70,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    other_allocator<int>
                                    > C;
         typedef int P;
@@ -86,7 +86,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             other_allocator<int>(10)
            );
         C c = c0;
@@ -97,7 +97,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -108,7 +108,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -124,7 +124,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C c = c0;
@@ -135,7 +135,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -31,7 +31,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -47,7 +47,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C c(c0, test_allocator<int>(5));
@@ -58,7 +58,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(5));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -70,7 +70,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -86,7 +86,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C c(c0, min_allocator<int>());
@@ -97,7 +97,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -65,14 +65,14 @@
         typedef explicit_allocator<NotConstructible> A;
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    A
                                    > C;
         {
         C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == A());
         assert(c.size() == 0);
         assert(c.empty());
@@ -85,7 +85,7 @@
         C c(a);
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == a);
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
@@ -33,7 +33,7 @@
   {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -52,7 +52,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -63,7 +63,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -82,7 +82,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -94,7 +94,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_set<T, HF, Comp, A> C;
 
@@ -127,7 +127,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_set<T, HF, Comp, A> C;
 
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -54,7 +54,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -65,7 +65,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -86,7 +86,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -56,7 +56,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -67,7 +67,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -89,7 +89,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -48,7 +48,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -57,7 +57,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -68,7 +68,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -82,7 +82,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -91,7 +91,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -48,7 +48,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -58,7 +58,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -69,7 +69,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -83,7 +83,7 @@
             },
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -93,7 +93,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
@@ -33,19 +33,19 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -58,7 +58,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -74,7 +74,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         C::iterator it0 = c0.begin();
@@ -87,7 +87,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -100,19 +100,19 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -125,7 +125,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -141,7 +141,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         C::iterator it0 = c0.begin();
@@ -154,7 +154,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
@@ -35,7 +35,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -50,7 +50,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(12));
@@ -61,7 +61,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(12));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -76,7 +76,7 @@
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -91,7 +91,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A(10)
            );
         C c(std::move(c0), A(10));
@@ -102,7 +102,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -117,7 +117,7 @@
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    A
                                    > C;
         P a[] =
@@ -132,7 +132,7 @@
         C c0(a, a + sizeof(a)/sizeof(a[0]),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             A()
            );
         C c(std::move(c0), A());
@@ -143,7 +143,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -54,7 +54,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -66,7 +66,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -87,7 +87,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -99,7 +99,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_set<T, HF, Comp, A> C;
         T arr[] =
@@ -132,7 +132,7 @@
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
-        typedef test_compare<std::equal_to<T>> Comp;
+        typedef test_equal_to<T> Comp;
         typedef test_allocator<T> A;
         typedef std::unordered_set<T, HF, Comp, A> C;
         T arr[] =
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -33,7 +33,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -56,7 +56,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -68,7 +68,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -91,7 +91,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -58,7 +58,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -70,7 +70,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -94,7 +94,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >());
+        assert(c.key_eq() == test_equal_to<int>());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -34,7 +34,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -50,7 +50,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -59,7 +59,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -71,7 +71,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -87,7 +87,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9)
+            test_equal_to<int>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
@@ -96,7 +96,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -35,7 +35,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    test_allocator<int>
                                    > C;
         typedef int P;
@@ -51,7 +51,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             test_allocator<int>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -61,7 +61,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
@@ -73,7 +73,7 @@
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
-                                   test_compare<std::equal_to<int> >,
+                                   test_equal_to<int>,
                                    min_allocator<int>
                                    > C;
         typedef int P;
@@ -89,7 +89,7 @@
         C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
-            test_compare<std::equal_to<int> >(9),
+            test_equal_to<int>(9),
             min_allocator<int>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -99,7 +99,7 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
+        assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.compile.fail.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.compile.fail.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.compile.fail.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.compile.fail.cpp
@@ -28,13 +28,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c = 7;
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -29,13 +29,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -47,13 +47,13 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -29,7 +29,7 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7,
@@ -37,7 +37,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -49,7 +49,7 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7,
@@ -57,7 +57,7 @@
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.key_eq() == test_equal_to<NotConstructible>());
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -29,16 +29,16 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (test_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
@@ -50,16 +50,16 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_equal_to<NotConstructible>(9)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -29,17 +29,17 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    test_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             test_allocator<NotConstructible>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (test_allocator<NotConstructible>(10)));
         assert(c.size() == 0);
         assert(c.empty());
@@ -51,17 +51,17 @@
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
+                                   test_equal_to<NotConstructible>,
                                    min_allocator<NotConstructible>
                                    > C;
         C c(7,
             test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
+            test_equal_to<NotConstructible>(9),
             min_allocator<NotConstructible>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.key_eq() == test_equal_to<NotConstructible>(9));
         assert(c.get_allocator() == (min_allocator<NotConstructible>()));
         assert(c.size() == 0);
         assert(c.empty());
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -28,7 +28,7 @@
 {
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
@@ -56,7 +56,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -106,7 +106,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -150,7 +150,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -216,7 +216,7 @@
 
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
@@ -244,7 +244,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -292,7 +292,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -334,7 +334,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -396,7 +396,7 @@
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
@@ -424,7 +424,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -472,7 +472,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
@@ -514,7 +514,7 @@
     }
     {
         typedef test_hash<std::hash<int> > Hash;
-        typedef test_compare<std::equal_to<int> > Compare;
+        typedef test_equal_to<int> Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
--- a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
@@ -45,16 +45,13 @@
   test_hash_disabled_for_type<pointer>();
 }
 
-namespace std {
-
 template <class T>
-struct hash<::min_pointer<T, std::integral_constant<size_t, 1>>> {
-  size_t operator()(::min_pointer<T, std::integral_constant<size_t, 1>> p) const TEST_NOEXCEPT_FALSE {
+struct std::hash<min_pointer<T, std::integral_constant<size_t, 1>>> {
+  size_t operator()(min_pointer<T, std::integral_constant<size_t, 1>> p) const TEST_NOEXCEPT_FALSE {
     if (!p) return 0;
     return std::hash<T*>{}(std::addressof(*p));
   }
 };
-}
 
 struct A {};
 
diff --git a/libcxx/test/support/min_allocator.h b/libcxx/test/support/min_allocator.h
--- a/libcxx/test/support/min_allocator.h
+++ b/libcxx/test/support/min_allocator.h
@@ -372,42 +372,14 @@
     static TEST_CONSTEXPR_CXX14 min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));}
 
     friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
-    friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
+    friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, min_pointer y) {return x.ptr_ != y.ptr_;}
+    friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, std::nullptr_t) {return x.ptr_ == nullptr;}
+    friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, std::nullptr_t) {return x.ptr_ != nullptr;}
+    friend TEST_CONSTEXPR_CXX14 bool operator==(std::nullptr_t, min_pointer x) {return x.ptr_ == nullptr;}
+    friend TEST_CONSTEXPR_CXX14 bool operator!=(std::nullptr_t, min_pointer x) {return x.ptr_ != nullptr;}
     template <class U, class XID> friend class min_pointer;
 };
 
-template <class T, class ID>
-TEST_CONSTEXPR_CXX14 inline
-bool
-operator==(min_pointer<T, ID> x, std::nullptr_t)
-{
-    return !static_cast<bool>(x);
-}
-
-template <class T, class ID>
-TEST_CONSTEXPR_CXX14 inline
-bool
-operator==(std::nullptr_t, min_pointer<T, ID> x)
-{
-    return !static_cast<bool>(x);
-}
-
-template <class T, class ID>
-TEST_CONSTEXPR_CXX14 inline
-bool
-operator!=(min_pointer<T, ID> x, std::nullptr_t)
-{
-    return static_cast<bool>(x);
-}
-
-template <class T, class ID>
-TEST_CONSTEXPR_CXX14 inline
-bool
-operator!=(std::nullptr_t, min_pointer<T, ID> x)
-{
-    return static_cast<bool>(x);
-}
-
 template <class T>
 class min_allocator
 {