Refactor container CTAD tests

libcxx/test/std/containers/associative/map/map.cons/deduct.verify.cpp

@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <map>
+
+// Test CTAD on cases where deduction should fail.
+
+#include <map>
+#include <functional>
+#include <memory>
+
+struct NotAnAllocator {
+  friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
+};
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+void test() {
+  {
+    // cannot deduce Key and T from nothing
+    std::map m;
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce Key and T from just (Compare)
+    std::map m(std::less<int>{});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce Key and T from just (Compare, Allocator)
+    std::map m(std::less<int>{}, std::allocator<PC>{});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce Key and T from just (Allocator)
+    std::map m(std::allocator<PC>{});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // refuse to rebind the allocator if Allocator::value_type is not exactly what we expect
+    const P arr[] = { {1,1L}, {2,2L}, {3,3L} };
+    std::map m(arr, arr + 3, std::allocator<P>());
+        // expected-error-re@map:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}}
+  }
+  {
+    // cannot convert from some arbitrary unrelated type
+    NotAnAllocator a;
+    std::map m(a); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::map m{ {1,1L}, {2,2L}, {3,3L} };
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::map m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>());
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::map m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>(), std::allocator<PC>());
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::map m({ {1,1L}, {2,2L}, {3,3L} }, std::allocator<PC>());
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // since we have parens, not braces, this deliberately does not find the initializer_list constructor
+    std::map m(P{1,1L});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+  {
+    // since we have parens, not braces, this deliberately does not find the initializer_list constructor
+    std::map m(PC{1,1L});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
+  }
+}

libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.verify.cpp

@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <map>
+
+// Test CTAD on cases where deduction should fail.
+
+#include <map>
+#include <functional>
+#include <memory>
+
+struct NotAnAllocator {
+  friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
+};
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+void test()
+{
+  {
+    // cannot deduce Key and T from nothing
+    std::multimap m;
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce Key and T from just (Compare)
+    std::multimap m(std::less<int>{});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce Key and T from just (Compare, Allocator)
+    std::multimap m(std::less<int>{}, std::allocator<PC>{});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce Key and T from just (Allocator)
+    std::multimap m(std::allocator<PC>{});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // refuse to rebind the allocator if Allocator::value_type is not exactly what we expect
+    const P arr[] = { {1,1L}, {2,2L}, {3,3L} };
+    std::multimap m(arr, arr + 3, std::allocator<P>());
+        // expected-error-re@map:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}}
+  }
+  {
+    // cannot convert from some arbitrary unrelated type
+    NotAnAllocator a;
+    std::multimap m(a);
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::multimap m{ {1,1L}, {2,2L}, {3,3L} };
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::multimap m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>());
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::multimap m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>(), std::allocator<PC>());
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // cannot deduce that the inner braced things should be std::pair and not something else
+    std::multimap m({ {1,1L}, {2,2L}, {3,3L} }, std::allocator<PC>());
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // since we have parens, not braces, this deliberately does not find the initializer_list constructor
+    std::multimap m(P{1,1L});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+  {
+    // since we have parens, not braces, this deliberately does not find the initializer_list constructor
+    std::multimap m(PC{1,1L});
+        // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
+  }
+}