diff --git a/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
index 3880cd5e79d..f4195257e9c 100644
--- a/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
@@ -3,32 +3,58 @@
 
 #include <map>
 #include <testsuite_allocator.h>
+#include <testsuite_iterators.h>
 
 using __gnu_test::SimpleAllocator;
+using value_type = std::map<int, double>::value_type;
+
+static_assert(std::is_same_v<
+	      decltype(std::map{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}),
+	      std::map<int, double>>);
 
 static_assert(std::is_same_v<
 	      decltype(std::map{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
 	      std::map<int, double>>);
 
+static_assert(std::is_same_v<
+	      decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
+	      std::map<int, double>>);
+
 static_assert(std::is_same_v<
 	      decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
 	      std::map<int, double>>);
 
 static_assert(std::is_same_v<
-	      decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
-		    std::less<int>{}, {}}),
+	      decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				std::less<int>{}, {}}),
 	      std::map<int, double>>);
 
 static_assert(std::is_same_v<
 	      decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
-		    {}}),
+				std::less<int>{}, {}}),
+	      std::map<int, double>>);
+
+/* This is not deducible, {} could be deduced as _Compare or _Allocator.
+static_assert(std::is_same_v<
+	      decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}),
+	      std::map<int, double>>);
+*/
+
+static_assert(std::is_same_v<
+	      decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}),
 	      std::map<int, double>>);
 
 static_assert(std::is_same_v<
-	      decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
-		    {}, SimpleAllocator<std::pair<const int, double>>{}}),
+	      decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				{}, SimpleAllocator<value_type>{}}),
 	      std::map<int, double, std::less<int>,
-	      SimpleAllocator<std::pair<const int, double>>>>);
+		       SimpleAllocator<value_type>>>);
+
+static_assert(std::is_same_v<
+	      decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				{}, SimpleAllocator<value_type>{}}),
+	      std::map<int, double, std::less<int>,
+		       SimpleAllocator<value_type>>>);
 
 void f()
 {
@@ -39,13 +65,13 @@ void f()
 
   static_assert(std::is_same_v<
 		decltype(std::map{x.begin(), x.end(),
-		      std::less<int>{},
-		      std::allocator<std::pair<const int, double>>{}}),
+				  std::less<int>{},
+				  std::allocator<value_type>{}}),
 		std::map<int, double>>);
-  
+
   static_assert(std::is_same_v<
 		decltype(std::map{x.begin(), x.end(),
-		      std::less<int>{}, {}}),
+				  std::less<int>{}, {}}),
 		std::map<int, double>>);
 
   static_assert(std::is_same_v<
@@ -55,14 +81,95 @@ void f()
 
   static_assert(std::is_same_v<
 		decltype(std::map{x.begin(), x.end(),
-		      {},
-		      std::allocator<std::pair<const int, double>>{}}),
+				  {},
+				  std::allocator<value_type>{}}),
 		std::map<int, double>>);
 
   static_assert(std::is_same_v<
 		decltype(std::map{x.begin(), x.end(),
-		      {},
-		      SimpleAllocator<std::pair<const int, double>>{}}),
+				  {},
+				  SimpleAllocator<value_type>{}}),
 		std::map<int, double, std::less<int>,
-		SimpleAllocator<std::pair<const int, double>>>>);
+			 SimpleAllocator<value_type>>>);
+}
+
+using __gnu_test::test_container;
+using __gnu_test::input_iterator_wrapper;
+
+void g()
+{
+  value_type array[1];
+  test_container<value_type, input_iterator_wrapper> x(array);
+
+  static_assert(std::is_same_v<
+		decltype(std::map(x.begin(), x.end())),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  std::less<int>{},
+				  std::allocator<value_type>{}}),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  std::less<int>{}, {}}),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map(x.begin(), x.end(),
+				  {})),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  {},
+				  std::allocator<value_type>{}}),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  {},
+				  SimpleAllocator<value_type>{}}),
+		std::map<int, double, std::less<int>,
+			 SimpleAllocator<value_type>>>);
+}
+
+void h()
+{
+  std::pair<int, double> array[1];
+  test_container<std::pair<int, double>, input_iterator_wrapper> x(array);
+
+  static_assert(std::is_same_v<
+		decltype(std::map(x.begin(), x.end())),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  std::less<int>{},
+				  std::allocator<value_type>{}}),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  std::less<int>{}, {}}),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map(x.begin(), x.end(),
+				  {})),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  {},
+				  std::allocator<value_type>{}}),
+		std::map<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::map{x.begin(), x.end(),
+				  {},
+				  SimpleAllocator<value_type>{}}),
+		std::map<int, double, std::less<int>,
+			 SimpleAllocator<value_type>>>);
 }
diff --git a/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc
index ee48bfda26b..2f9373a5bef 100644
--- a/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc
@@ -3,32 +3,60 @@
 
 #include <map>
 #include <testsuite_allocator.h>
+#include <testsuite_iterators.h>
 
 using __gnu_test::SimpleAllocator;
+using value_type = std::multimap<int, double>::value_type;
+
+static_assert(std::is_same_v<
+	      decltype(std::multimap{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}),
+	      std::multimap<int, double>>);
 
 static_assert(std::is_same_v<
 	      decltype(std::multimap{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
 	      std::multimap<int, double>>);
 
+static_assert(std::is_same_v<
+	      decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
+	      std::multimap<int, double>>);
+
 static_assert(std::is_same_v<
 	      decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
 	      std::multimap<int, double>>);
 
+static_assert(std::is_same_v<
+	      decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				std::less<int>{}, {}}),
+	      std::multimap<int, double>>);
+
 static_assert(std::is_same_v<
 	      decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
 		    std::less<int>{}, {}}),
 	      std::multimap<int, double>>);
 
+/* This is not deducible, {} could be deduced as _Compare or _Allocator.
+static_assert(std::is_same_v<
+	      decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				     {}}),
+	      std::multimap<int, double>>);
+*/
+
 static_assert(std::is_same_v<
 	      decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
 		    {}}),
 	      std::multimap<int, double>>);
 
 static_assert(std::is_same_v<
-	      decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
-		    {}, SimpleAllocator<std::pair<const int, double>>{}}),
+	      decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				     {}, SimpleAllocator<value_type>{}}),
 	      std::multimap<int, double, std::less<int>,
-	      SimpleAllocator<std::pair<const int, double>>>>);
+		       SimpleAllocator<value_type>>>);
+
+static_assert(std::is_same_v<
+	      decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+				     {}, SimpleAllocator<value_type>{}}),
+	      std::multimap<int, double, std::less<int>,
+			    SimpleAllocator<value_type>>>);
 
 void f()
 {
@@ -39,30 +67,111 @@ void f()
 
   static_assert(std::is_same_v<
 		decltype(std::multimap{x.begin(), x.end(),
-		      std::less<int>{},
-		      std::allocator<std::pair<const int, double>>{}}),
+				       std::less<int>{},
+				       std::allocator<value_type>{}}),
 		std::multimap<int, double>>);
   
   static_assert(std::is_same_v<
 		decltype(std::multimap{x.begin(), x.end(),
-		      std::less<int>{}, {}}),
+				       std::less<int>{}, {}}),
 		std::multimap<int, double>>);
 
   static_assert(std::is_same_v<
 		decltype(std::multimap(x.begin(), x.end(),
-				  {})),
+				       {})),
 		std::multimap<int, double>>);
 
   static_assert(std::is_same_v<
 		decltype(std::multimap{x.begin(), x.end(),
 		      {},
-		      std::allocator<std::pair<const int, double>>{}}),
+		      std::allocator<value_type>{}}),
 		std::multimap<int, double>>);
 
   static_assert(std::is_same_v<
 		decltype(std::multimap{x.begin(), x.end(),
-		      {},
-		      SimpleAllocator<std::pair<const int, double>>{}}),
+				       {},
+				       SimpleAllocator<value_type>{}}),
 		std::multimap<int, double, std::less<int>,
-		SimpleAllocator<std::pair<const int, double>>>>);
+			      SimpleAllocator<value_type>>>);
+}
+
+using __gnu_test::test_container;
+using __gnu_test::input_iterator_wrapper;
+
+void g()
+{
+  value_type array[1];
+  test_container<value_type, input_iterator_wrapper> x(array);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap(x.begin(), x.end())),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       std::less<int>{},
+				       std::allocator<value_type>{}}),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       std::less<int>{}, {}}),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap(x.begin(), x.end(),
+				       {})),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       {},
+				       std::allocator<value_type>{}}),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       {},
+				       SimpleAllocator<value_type>{}}),
+		std::multimap<int, double, std::less<int>,
+			 SimpleAllocator<value_type>>>);
+}
+
+void h()
+{
+  std::pair<int, double> array[1];
+  test_container<std::pair<int, double>, input_iterator_wrapper> x(array);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap(x.begin(), x.end())),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       std::less<int>{},
+				       std::allocator<value_type>{}}),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       std::less<int>{}, {}}),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap(x.begin(), x.end(),
+				       {})),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       {},
+				       std::allocator<value_type>{}}),
+		std::multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+		decltype(std::multimap{x.begin(), x.end(),
+				       {},
+				       SimpleAllocator<value_type>{}}),
+		std::multimap<int, double, std::less<int>,
+			      SimpleAllocator<value_type>>>);
 }
