From 78ed0f80c38b9084794ae4a02e5a5648cbd255ae Mon Sep 17 00:00:00 2001
From: Jonathan Wakely <jwakely@redhat.com>
Date: Fri, 19 Oct 2018 22:49:40 +0100
Subject: [PATCH] Fix tests that use allocators with incorrect value types

As a GNU extension we allow containers to be instantiated with
allocators that use a different value type from the container, and
automatically rebind the allocator to the correct type. This extension
is disabled in strict modes (when __STRICT_ANSI__ is defined, i.e.
-std=c++NN dialects). These testcases unintentionally rely on the
extension and so fail for strict modes.

Tests which intentionally make use of the extension will still fail in
strict dialects, but will be addressed in a later change.

	* testsuite/20_util/scoped_allocator/1.cc: Use allocator with correct
	value type for the container.
	* testsuite/23_containers/forward_list/cons/14.cc: Likewise.
	* testsuite/23_containers/map/56613.cc: Likewise.
	* testsuite/23_containers/unordered_map/55043.cc: Likewise.
	* testsuite/23_containers/unordered_map/allocator/copy.cc: Likewise.
	* testsuite/23_containers/unordered_map/allocator/copy_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_map/allocator/minimal.cc:
	Likewise.
	* testsuite/23_containers/unordered_map/allocator/move.cc: Likewise.
	* testsuite/23_containers/unordered_map/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_map/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/unordered_map/cons/81891.cc: Likewise.
	* testsuite/23_containers/unordered_map/requirements/exception/
	basic.cc: Likewise.
	* testsuite/23_containers/unordered_map/requirements/exception/
	generation_prohibited.cc: Likewise.
	* testsuite/23_containers/unordered_map/requirements/exception/
	propagation_consistent.cc: Likewise.
	* testsuite/23_containers/unordered_multimap/55043.cc: Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/copy.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/copy_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/minimal.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/move.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/requirements/exception/
	basic.cc: Likewise.
	* testsuite/23_containers/unordered_multimap/requirements/exception/
	generation_prohibited.cc: Likewise.
	* testsuite/23_containers/unordered_multimap/requirements/exception/
	propagation_consistent.cc: Likewise.
	* testsuite/23_containers/unordered_multimap/requirements/
	explicit_instantiation/5.cc: Likewise.
	* testsuite/ext/malloc_allocator/sanity.cc: Likewise.

From-SVN: r265331
---
 libstdc++-v3/ChangeLog                        | 45 +++++++++++++++++++
 .../testsuite/20_util/scoped_allocator/1.cc   | 10 ++---
 .../23_containers/forward_list/cons/14.cc     |  4 +-
 .../testsuite/23_containers/map/56613.cc      |  2 +-
 .../23_containers/unordered_map/55043.cc      |  8 +---
 .../unordered_map/allocator/copy.cc           |  6 +--
 .../unordered_map/allocator/copy_assign.cc    |  4 +-
 .../unordered_map/allocator/minimal.cc        |  5 +--
 .../unordered_map/allocator/move.cc           |  4 +-
 .../unordered_map/allocator/move_assign.cc    |  6 ++-
 .../unordered_map/allocator/noexcept.cc       | 10 ++---
 .../23_containers/unordered_map/cons/81891.cc |  2 +-
 .../requirements/exception/basic.cc           |  3 +-
 .../exception/generation_prohibited.cc        |  3 +-
 .../exception/propagation_consistent.cc       |  3 +-
 .../23_containers/unordered_multimap/55043.cc |  8 +---
 .../unordered_multimap/allocator/copy.cc      |  6 +--
 .../allocator/copy_assign.cc                  |  4 +-
 .../unordered_multimap/allocator/minimal.cc   |  4 +-
 .../unordered_multimap/allocator/move.cc      |  4 +-
 .../allocator/move_assign.cc                  |  6 ++-
 .../unordered_multimap/allocator/noexcept.cc  | 10 ++---
 .../requirements/exception/basic.cc           |  3 +-
 .../exception/generation_prohibited.cc        |  3 +-
 .../exception/propagation_consistent.cc       |  3 +-
 .../requirements/explicit_instantiation/5.cc  | 11 ++---
 .../testsuite/ext/malloc_allocator/sanity.cc  |  2 +-
 27 files changed, 111 insertions(+), 68 deletions(-)

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index a3a961161bc2..c7cdc0055023 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,5 +1,50 @@
 2018-10-19  Jonathan Wakely  <jwakely@redhat.com>
 
+	* testsuite/20_util/scoped_allocator/1.cc: Use allocator with correct
+	value type for the container.
+	* testsuite/23_containers/forward_list/cons/14.cc: Likewise.
+	* testsuite/23_containers/map/56613.cc: Likewise.
+	* testsuite/23_containers/unordered_map/55043.cc: Likewise.
+	* testsuite/23_containers/unordered_map/allocator/copy.cc: Likewise.
+	* testsuite/23_containers/unordered_map/allocator/copy_assign.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_map/allocator/minimal.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_map/allocator/move.cc: Likewise.
+	* testsuite/23_containers/unordered_map/allocator/move_assign.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_map/allocator/noexcept.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_map/cons/81891.cc: Likewise.
+	* testsuite/23_containers/unordered_map/requirements/exception/
+	basic.cc: Likewise.
+	* testsuite/23_containers/unordered_map/requirements/exception/
+	generation_prohibited.cc: Likewise.
+	* testsuite/23_containers/unordered_map/requirements/exception/
+	propagation_consistent.cc: Likewise.
+	* testsuite/23_containers/unordered_multimap/55043.cc: Likewise.
+	* testsuite/23_containers/unordered_multimap/allocator/copy.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_multimap/allocator/copy_assign.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_multimap/allocator/minimal.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_multimap/allocator/move.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_multimap/allocator/move_assign.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_multimap/allocator/noexcept.cc:
+	Likewise.
+	* testsuite/23_containers/unordered_multimap/requirements/exception/
+	basic.cc: Likewise.
+	* testsuite/23_containers/unordered_multimap/requirements/exception/
+	generation_prohibited.cc: Likewise.
+	* testsuite/23_containers/unordered_multimap/requirements/exception/
+	propagation_consistent.cc: Likewise.
+	* testsuite/23_containers/unordered_multimap/requirements/
+	explicit_instantiation/5.cc: Likewise.
+	* testsuite/ext/malloc_allocator/sanity.cc: Likewise.
+
 	* ext/special_functions/airy_ai/check_nan.cc: Skip test for
 	non-standard extension when a strict -std=c++NN dialect is used.
 	* ext/special_functions/airy_ai/check_value.cc: Likewise.
diff --git a/libstdc++-v3/testsuite/20_util/scoped_allocator/1.cc b/libstdc++-v3/testsuite/20_util/scoped_allocator/1.cc
index 3a1eb2cfad73..b546b495d958 100644
--- a/libstdc++-v3/testsuite/20_util/scoped_allocator/1.cc
+++ b/libstdc++-v3/testsuite/20_util/scoped_allocator/1.cc
@@ -57,12 +57,14 @@ void test01()
 
 void test02()
 {
-  typedef std::scoped_allocator_adaptor<Element::allocator_type> inner_alloc_type;
+  typedef std::scoped_allocator_adaptor<Element::allocator_type> alloc1_type;
 
-  typedef std::vector<Element, inner_alloc_type> EltVec;
+  typedef std::vector<Element, alloc1_type> EltVec;
 
   typedef std::scoped_allocator_adaptor<Element::allocator_type,
-                                        Element::allocator_type> alloc_type;
+                                        Element::allocator_type> alloc2_type;
+
+  typedef std::allocator_traits<alloc2_type>::rebind_alloc<EltVec> alloc_type;
 
   typedef std::vector<EltVec, alloc_type> EltVecVec;
 
@@ -88,10 +90,8 @@ void test02()
   VERIFY( evv3.get_allocator().get_personality() == 3 );
   VERIFY( evv3[0].get_allocator().get_personality() == 4 );
   VERIFY( evv3[0][0].get_allocator().get_personality() == 4 );
-
 }
 
-
 int main()
 {
   test01();
diff --git a/libstdc++-v3/testsuite/23_containers/forward_list/cons/14.cc b/libstdc++-v3/testsuite/23_containers/forward_list/cons/14.cc
index a27201e2f492..9ee497b2e1fa 100644
--- a/libstdc++-v3/testsuite/23_containers/forward_list/cons/14.cc
+++ b/libstdc++-v3/testsuite/23_containers/forward_list/cons/14.cc
@@ -26,9 +26,9 @@ void test01()
 {
   using namespace std;
   using list = forward_list<int>;
-  forward_list<list, scoped_allocator_adaptor<list::allocator_type>> l;
+  using alloc_type = allocator<list>;
+  forward_list<list, scoped_allocator_adaptor<alloc_type>> l;
 
   // Check for forward_list(size_type, const allocator_type&)
   l.emplace_front(1u);
 }
-
diff --git a/libstdc++-v3/testsuite/23_containers/map/56613.cc b/libstdc++-v3/testsuite/23_containers/map/56613.cc
index 65aebe56d510..e639b81a730e 100644
--- a/libstdc++-v3/testsuite/23_containers/map/56613.cc
+++ b/libstdc++-v3/testsuite/23_containers/map/56613.cc
@@ -67,6 +67,6 @@ bool operator!=(alloc<T>, alloc<U>) { return false; }
 
 int main()
 {
-  std::map<int, int, std::less<int>, alloc<int> > m;
+  std::map<int, int, std::less<int>, alloc<std::pair<const int, int>>> m;
   m[1];
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/55043.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/55043.cc
index 1f6c55608ad5..a4c7c3bb3c57 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/55043.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/55043.cc
@@ -28,15 +28,9 @@ struct MoveOnly
   MoveOnly(MoveOnly&&) = default;
 };
 
-using hash = std::hash<int>;
-using equal = std::equal_to<int>;
-
-template<typename Alloc>
-  using test_type = std::unordered_map<int, MoveOnly, hash, equal, Alloc>;
-
 void test01()
 {
-  typedef test_type<std::allocator<MoveOnly>> uim;
+  typedef std::unordered_map<int, MoveOnly> uim;
   std::vector<uim> v;
   v.emplace_back(uim());
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy.cc
index 4efc67a193a4..6e2bcef6674a 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy.cc
@@ -39,7 +39,7 @@ using __gnu_test::propagating_allocator;
 
 void test01()
 {
-  typedef propagating_allocator<T, false> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -51,7 +51,7 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -63,7 +63,7 @@ void test02()
 
 void test03()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy_assign.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy_assign.cc
index f6eec6731c1e..6393bf56d2b6 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy_assign.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/copy_assign.cc
@@ -39,7 +39,7 @@ using __gnu_test::propagating_allocator;
 
 void test01()
 {
-  typedef propagating_allocator<T, false> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -54,7 +54,7 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/minimal.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/minimal.cc
index 23efffa8bf09..4fc096765e22 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/minimal.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/minimal.cc
@@ -40,13 +40,12 @@ struct equal_to
 bool operator==(const T& l, const T& r) { return l.i == r.i; }
 bool operator<(const T& l, const T& r) { return l.i < r.i; }
 
-using __gnu_test::SimpleAllocator;
+typedef __gnu_test::SimpleAllocator<std::pair<const T, T>> alloc_type;
 
-template class std::unordered_map<T, T, hash, equal_to, SimpleAllocator<T>>;
+template class std::unordered_map<T, T, hash, equal_to, alloc_type>;
 
 void test01()
 {
-  typedef SimpleAllocator<T> alloc_type;
   typedef std::allocator_traits<alloc_type> traits_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v(alloc_type{});
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move.cc
index dc33587666bf..c79dbeb80c94 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move.cc
@@ -39,7 +39,7 @@ using __gnu_test::uneq_allocator;
 
 void test01()
 {
-  typedef uneq_allocator<T> alloc_type;
+  typedef uneq_allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -53,7 +53,7 @@ void test01()
 
 void test02()
 {
-  typedef uneq_allocator<T> alloc_type;
+  typedef uneq_allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move_assign.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move_assign.cc
index 173287e4df05..b27269e607a2 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move_assign.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move_assign.cc
@@ -27,7 +27,8 @@ using __gnu_test::counter_type;
 
 void test01()
 {
-  typedef propagating_allocator<counter_type, false> alloc_type;
+  typedef std::pair<const counter_type, counter_type> value_type;
+  typedef propagating_allocator<value_type, false> alloc_type;
   typedef __gnu_test::counter_type_hasher hash;
   typedef std::unordered_map<counter_type, counter_type, hash,
 			     std::equal_to<counter_type>,
@@ -54,7 +55,8 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<counter_type, true> alloc_type;
+  typedef std::pair<const counter_type, counter_type> value_type;
+  typedef propagating_allocator<value_type, true> alloc_type;
   typedef __gnu_test::counter_type_hasher hash;
   typedef std::unordered_map<counter_type, counter_type, hash,
 			     std::equal_to<counter_type>,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
index f9fd434dfd7a..29fbc7bcd8d8 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
@@ -44,7 +44,7 @@ using __gnu_test::propagating_allocator;
 
 void test01()
 {
-  typedef std::allocator<T> alloc_type;
+  typedef std::allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1;
   test_type v2;
@@ -55,7 +55,7 @@ void test01()
 
 void test02()
 {
-  typedef std::allocator<T> alloc_type;
+  typedef std::allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_map<T, T, hash_t, equal_to, alloc_type> test_type;
   test_type v1;
   test_type v2;
@@ -65,7 +65,7 @@ void test02()
 
 void test03()
 {
-  typedef std::allocator<T> alloc_type;
+  typedef std::allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to_t, alloc_type> test_type;
   test_type v1;
   test_type v2;
@@ -75,7 +75,7 @@ void test03()
 
 void test04()
 {
-  typedef propagating_allocator<T, false> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
@@ -85,7 +85,7 @@ void test04()
 
 void test05()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/81891.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/81891.cc
index e1debbb429d1..f0f8b75e7e56 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/81891.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/81891.cc
@@ -26,7 +26,7 @@ struct fails_on_copy {
   fails_on_copy(const fails_on_copy&) { throw 0; };
 };
 
-using value_type = std::pair<int, fails_on_copy>;
+using value_type = std::pair<const int, fails_on_copy>;
 
 void
 test01()
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/basic.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/basic.cc
index a8f973fd175d..bbc4cded2427 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/basic.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/basic.cc
@@ -27,7 +27,8 @@ void
 value()
 {
   typedef __gnu_cxx::throw_value_limit value_type;
-  typedef __gnu_cxx::throw_allocator_limit<value_type> allocator_type;
+  typedef std::pair<const value_type, value_type> pair_type;
+  typedef __gnu_cxx::throw_allocator_limit<pair_type> allocator_type;
   typedef std::hash<value_type> hash_type;
   typedef std::equal_to<value_type> pred_type;
   typedef std::unordered_map<value_type, value_type, hash_type, pred_type, allocator_type> test_type;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/generation_prohibited.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/generation_prohibited.cc
index 11e0a3d68886..e04f326e1c29 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/generation_prohibited.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/generation_prohibited.cc
@@ -27,7 +27,8 @@
 int main()
 {
   typedef __gnu_cxx::throw_value_random value_type;
-  typedef __gnu_cxx::throw_allocator_random<value_type> allocator_type;
+  typedef std::pair<const value_type, value_type> pair_type;
+  typedef __gnu_cxx::throw_allocator_random<pair_type> allocator_type;
   typedef std::hash<value_type> hash_type;
   typedef std::equal_to<value_type> pred_type;
   typedef std::unordered_map<value_type, value_type, hash_type, pred_type, allocator_type> test_type;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/propagation_consistent.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/propagation_consistent.cc
index 1980cc8e8400..eb5c0f1b88ac 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/propagation_consistent.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/requirements/exception/propagation_consistent.cc
@@ -27,7 +27,8 @@
 int main()
 {
   typedef __gnu_cxx::throw_value_limit value_type;
-  typedef __gnu_cxx::throw_allocator_limit<value_type> allocator_type;
+  typedef std::pair<const value_type, value_type> pair_type;
+  typedef __gnu_cxx::throw_allocator_limit<pair_type> allocator_type;
   typedef std::hash<value_type> hash_type;
   typedef std::equal_to<value_type> pred_type;
   typedef std::unordered_map<value_type, value_type, hash_type, pred_type, allocator_type> test_type;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/55043.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/55043.cc
index 6b95a0a667bf..919cea33341d 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/55043.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/55043.cc
@@ -28,15 +28,9 @@ struct MoveOnly
   MoveOnly(MoveOnly&&) = default;
 };
 
-using hash = std::hash<int>;
-using equal = std::equal_to<int>;
-
-template<typename Alloc>
-  using test_type = std::unordered_multimap<int, MoveOnly, hash, equal, Alloc>;
-
 void test01()
 {
-  typedef test_type<std::allocator<MoveOnly>> uim;
+  typedef std::unordered_multimap<int, MoveOnly> uim;
   std::vector<uim> v;
   v.emplace_back(uim());
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy.cc
index 13b99ed8260b..38322316406a 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy.cc
@@ -39,7 +39,7 @@ using __gnu_test::propagating_allocator;
 
 void test01()
 {
-  typedef propagating_allocator<T, false> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -51,7 +51,7 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -63,7 +63,7 @@ void test02()
 
 void test03()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy_assign.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy_assign.cc
index 281f7eafc1cd..15059be65276 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy_assign.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/copy_assign.cc
@@ -39,7 +39,7 @@ using __gnu_test::propagating_allocator;
 
 void test01()
 {
-  typedef propagating_allocator<T, false> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -54,7 +54,7 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/minimal.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/minimal.cc
index b563b97f812c..8488eba37f1c 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/minimal.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/minimal.cc
@@ -43,11 +43,11 @@ bool operator<(const T& l, const T& r) { return l.i < r.i; }
 using __gnu_test::SimpleAllocator;
 
 template class std::unordered_multimap<T, T, hash, equal_to,
-				       SimpleAllocator<T>>;
+				       SimpleAllocator<std::pair<const T, T>>>;
 
 void test01()
 {
-  typedef SimpleAllocator<T> alloc_type;
+  typedef SimpleAllocator<std::pair<const T, T>> alloc_type;
   typedef std::allocator_traits<alloc_type> traits_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v(alloc_type{});
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move.cc
index 2ac6d374b42a..33e987ac45b4 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move.cc
@@ -39,7 +39,7 @@ using __gnu_test::uneq_allocator;
 
 void test01()
 {
-  typedef uneq_allocator<T> alloc_type;
+  typedef uneq_allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
@@ -53,7 +53,7 @@ void test01()
 
 void test02()
 {
-  typedef uneq_allocator<T> alloc_type;
+  typedef uneq_allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.emplace(std::piecewise_construct,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move_assign.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move_assign.cc
index f64848b015db..35c4c289f109 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move_assign.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move_assign.cc
@@ -25,9 +25,11 @@
 using __gnu_test::propagating_allocator;
 using __gnu_test::counter_type;
 
+typedef std::pair<const counter_type, counter_type> value_type;
+
 void test01()
 {
-  typedef propagating_allocator<counter_type, false> alloc_type;
+  typedef propagating_allocator<value_type, false> alloc_type;
   typedef __gnu_test::counter_type_hasher hash;
   typedef std::unordered_multimap<counter_type, counter_type, hash,
 				  std::equal_to<counter_type>,
@@ -54,7 +56,7 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<counter_type, true> alloc_type;
+  typedef propagating_allocator<value_type, true> alloc_type;
   typedef __gnu_test::counter_type_hasher hash;
   typedef std::unordered_multimap<counter_type, counter_type, hash,
 				  std::equal_to<counter_type>,
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
index b47a76d35359..78fc37038c3e 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
@@ -44,7 +44,7 @@ using __gnu_test::propagating_allocator;
 
 void test01()
 {
-  typedef std::allocator<T> alloc_type;
+  typedef std::allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1;
   test_type v2;
@@ -55,7 +55,7 @@ void test01()
 
 void test02()
 {
-  typedef std::allocator<T> alloc_type;
+  typedef std::allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_multimap<T, T, hash_t, equal_to, alloc_type> test_type;
   test_type v1;
   test_type v2;
@@ -65,7 +65,7 @@ void test02()
 
 void test03()
 {
-  typedef std::allocator<T> alloc_type;
+  typedef std::allocator<std::pair<const T, T>> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to_t, alloc_type>
     test_type;
   test_type v1;
@@ -76,7 +76,7 @@ void test03()
 
 void test04()
 {
-  typedef propagating_allocator<T, false> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
@@ -86,7 +86,7 @@ void test04()
 
 void test05()
 {
-  typedef propagating_allocator<T, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/basic.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/basic.cc
index 895152e04acf..81dc0bbe8dfd 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/basic.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/basic.cc
@@ -27,7 +27,8 @@ void
 value()
 {
   typedef __gnu_cxx::throw_value_limit value_type;
-  typedef __gnu_cxx::throw_allocator_limit<value_type> allocator_type;
+  typedef std::pair<const value_type, value_type> pair_type;
+  typedef __gnu_cxx::throw_allocator_limit<pair_type> allocator_type;
   typedef std::hash<value_type> hash_type;
   typedef std::equal_to<value_type> pred_type;
   typedef std::unordered_multimap<value_type, value_type, hash_type, pred_type, allocator_type> test_type;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/generation_prohibited.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/generation_prohibited.cc
index 92b0ab870dcf..a05d8867dff2 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/generation_prohibited.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/generation_prohibited.cc
@@ -27,7 +27,8 @@
 int main()
 {
   typedef __gnu_cxx::throw_value_random value_type;
-  typedef __gnu_cxx::throw_allocator_random<value_type> allocator_type;
+  typedef std::pair<const value_type, value_type> pair_type;
+  typedef __gnu_cxx::throw_allocator_random<pair_type> allocator_type;
   typedef std::hash<value_type> hash_type;
   typedef std::equal_to<value_type> pred_type;
   typedef std::unordered_multimap<value_type, value_type, hash_type, pred_type, allocator_type> test_type;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/propagation_consistent.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/propagation_consistent.cc
index db5642883321..58312c991463 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/propagation_consistent.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/exception/propagation_consistent.cc
@@ -27,7 +27,8 @@
 int main()
 {
   typedef __gnu_cxx::throw_value_limit value_type;
-  typedef __gnu_cxx::throw_allocator_random<value_type> allocator_type;
+  typedef std::pair<const value_type, value_type> pair_type;
+  typedef __gnu_cxx::throw_allocator_random<pair_type> allocator_type;
   typedef std::hash<value_type> hash_type;
   typedef std::equal_to<value_type> pred_type;
   typedef std::unordered_multimap<value_type, value_type, hash_type, pred_type, allocator_type> test_type;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/explicit_instantiation/5.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/explicit_instantiation/5.cc
index 4c29a6f049c1..6cdf0f3f3ca7 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/explicit_instantiation/5.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/explicit_instantiation/5.cc
@@ -1,4 +1,3 @@
-
 // Copyright (C) 2011-2018 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -23,10 +22,12 @@
 
 // { dg-do compile { target c++11 } }
 
+using __gnu_test::ExplicitConsAlloc;
+
 // libstdc++/50118
+template class
+  std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
+			  ExplicitConsAlloc<std::pair<const int, int>>>;
 template class std::unordered_multimap<int, int, std::hash<int>,
 				       std::equal_to<int>,
-				       __gnu_test::ExplicitConsAlloc<int>>;
-template class std::unordered_multimap<int, int, std::hash<int>,
-				       std::equal_to<int>,
-				       __gnu_test::ExplicitConsAlloc<char>>;
+				       ExplicitConsAlloc<char>>;
diff --git a/libstdc++-v3/testsuite/ext/malloc_allocator/sanity.cc b/libstdc++-v3/testsuite/ext/malloc_allocator/sanity.cc
index 30e978a896d8..ef9df0379f91 100644
--- a/libstdc++-v3/testsuite/ext/malloc_allocator/sanity.cc
+++ b/libstdc++-v3/testsuite/ext/malloc_allocator/sanity.cc
@@ -24,7 +24,7 @@
 int main()
 {
   std::map<int, int, std::less<int>,
-	   __gnu_cxx::malloc_allocator<std::pair<int, int> > > allocs;
+	   __gnu_cxx::malloc_allocator<std::pair<const int, int> > > allocs;
   allocs[9] = 3;
   std::vector<int, __gnu_cxx::malloc_allocator<int>> vec(10);
   vec[5] = 42;
-- 
2.47.2