[libc++] Move all the remaining .fail.cpp tests to .verify.cpp

[ldionne]

Summary

I made sure they all had some expected-error output in them. Many of
these tests would be better implemented as a positive test using SFINAE,
but this is beyond the scope of this patch.

[ldionne]

Fix test that would be broken by a file renaming.

[ldionne]

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.verify.cpp

12

This is one of the only two tests I actually had to change instead of just blindly renaming.

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.verify.cpp

12

This is the second one. Everything else is just renaming.

[Mordante]

I only checked the called out tests. LGTM but I have a question.

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.verify.cpp

27

Why is it safe to remove the !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE) part?

[ldionne]

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.verify.cpp

27

We used to only define it from the other sibling test, and then we'd #include the sources for this test. Now both tests are "standalone", i.e. they don't include each other so this test (which doesn't test the fallback) doesn't need to check for _LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE.

[ldionne]

Fix modular CI issue by using ADDITIONAL_COMPILE_FLAGS instead of #define in TU.

libcxx/test/libcxx/containers/unord/unord.set/missing_hash_specialization.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: diagnose-if-support
 // UNSUPPORTED: c++03
 
 // Libc++ only provides a defined primary template for std::hash in C++14 and
 // newer.
 // UNSUPPORTED: c++11
 
 // <unordered_set>
 
 // Test that we generate a reasonable diagnostic when the specified hash is
 // not enabled.
 
 #include <unordered_set>
 #include <utility>
 
 using VT = std::pair<int, int>;
 
 struct BadHashNoCopy {
   BadHashNoCopy() = default;
   BadHashNoCopy(BadHashNoCopy const&) = delete;
 
   template <class T>
   std::size_t operator()(T const&) const { return 0; }
 };
 
 struct BadHashNoCall {
 
 };
 
 
 struct GoodHashNoDefault {
   explicit GoodHashNoDefault(void*) {}
   template <class T>
   std::size_t operator()(T const&) const { return 0; }
 };
 
 int main(int, char**) {
 
   {
     using Set = std::unordered_set<VT>;
     Set s; // expected-error@__hash_table:* {{the specified hash does not meet the Hash requirements}}
 
 
   // FIXME: It would be great to suppress the below diagnostic all together.
   //        but for now it's sufficient that it appears last. However there is
   //        currently no way to test the order diagnostics are issued.
   // expected-error@*:* {{call to implicitly-deleted default constructor of 'std::}}
   }
   {
     using Set = std::unordered_set<int, BadHashNoCopy>;
     Set s; // expected-error@__hash_table:* {{the specified hash does not meet the Hash requirements}}
   }
   {
     using Set = std::unordered_set<int, BadHashNoCall>;
     Set s; // expected-error@__hash_table:* {{the specified hash does not meet the Hash requirements}}
   }
   {
     using Set = std::unordered_set<int, GoodHashNoDefault>;
     Set s(/*bucketcount*/42, GoodHashNoDefault(nullptr));
   }
 
   return 0;
 }

libcxx/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // test unexpected
 
 #include <exception>
 
 void f() {}
 
 int main(int, char**) {
   using T = std::unexpected_handler; // expected-error {{no type named 'unexpected_handler' in namespace 'std'}}
   std::unexpected(); // expected-error {{no member named 'unexpected' in namespace 'std'}}
   std::get_unexpected(); // expected-error {{no member named 'get_unexpected' in namespace 'std'}}
   std::set_unexpected(f); // expected-error {{no type named 'set_unexpected' in namespace 'std'}}
 
   return 0;
 }

libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 #include <memory>
 #include <type_traits>
 
 template <int> struct Tag {};
 
 template <int ID>
 using SPtr = std::shared_ptr<void(Tag<ID>)>;
 
 template <int ID>
 using FnType = void(Tag<ID>);
 
 template <int ID>
 void TestFn(Tag<ID>) {}
 
 template <int ID>
 FnType<ID>* getFn() {
   return &TestFn<ID>;
 }
 
 struct Deleter {
   template <class Tp>
   void operator()(Tp) const {
     using RawT = typename std::remove_pointer<Tp>::type;
     static_assert(std::is_function<RawT>::value ||
                   std::is_same<typename std::remove_cv<RawT>::type,
                                std::nullptr_t>::value,
                   "");
   }
 };
 
 int main(int, char**) {
   {
     SPtr<0> s; // OK
     SPtr<1> s1(nullptr); // OK
     SPtr<2> s2(getFn<2>(), Deleter{}); // OK
     SPtr<3> s3(nullptr, Deleter{}); // OK
   }
 
   // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}default_delete cannot be instantiated for function types}}
   std::default_delete<FnType<5>> deleter{}; // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <variant>
 // UNSUPPORTED: c++03, c++11, c++14
 
 
 // template <size_t I, class T> struct variant_alternative; // undefined
 // template <size_t I, class T> struct variant_alternative<I, const T>;
 // template <size_t I, class T> struct variant_alternative<I, volatile T>;
 // template <size_t I, class T> struct variant_alternative<I, const volatile T>;
 // template <size_t I, class T>
 //   using variant_alternative_t = typename variant_alternative<I, T>::type;
 //
 // template <size_t I, class... Types>
 //    struct variant_alternative<I, variant<Types...>>;
 
 
 #include <variant>
 #include <cassert>
 
 
 int main(int, char**)
 {
     {
         typedef std::variant<int, double> T;
         std::variant_alternative<2, T>::type foo; // expected-note {{requested here}}
         // expected-error-re@variant:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}}{{.*}}Index out of bounds in std::variant_alternative<>}}
     }
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <algorithm>
 
 // template <class PopulationIterator, class SampleIterator, class Distance,
 //           class UniformRandomNumberGenerator>
 // SampleIterator sample(PopulationIterator first, PopulationIterator last,
 //                       SampleIterator out, Distance n,
 //                       UniformRandomNumberGenerator &&g);
 
 #include <algorithm>
 #include <random>
 #include <cassert>
 
 #include "test_iterators.h"
 
 template <class PopulationIterator, class SampleIterator> void test() {
   int ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   const unsigned is = sizeof(ia) / sizeof(ia[0]);
   const unsigned os = 4;
   int oa[os];
   std::minstd_rand g;
   std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
                             SampleIterator(oa), os, g);
 }
 
 int main(int, char**) {
   // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '.*')?}}{{.*}}SampleIterator must meet the requirements of RandomAccessIterator}}
   // expected-error@*:* 2 {{does not provide a subscript operator}}
   // expected-error@*:* {{invalid operands}}
   test<cpp17_input_iterator<int *>, cpp17_output_iterator<int *> >();
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // template<ForwardIterator Iter>
 //   max_element(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
 #include "test_iterators.h"
 
 int main(int, char**) {
   int arr[] = {1, 2, 3};
   const int *b = std::begin(arr), *e = std::end(arr);
   typedef cpp17_input_iterator<const int*> Iter;
   {
     // expected-error@*:* {{std::min_element requires a ForwardIterator}}
     (void) std::min_element(Iter(b), Iter(e));
   }
   {
     // expected-error@*:* {{std::max_element requires a ForwardIterator}}
     (void) std::max_element(Iter(b), Iter(e));
   }
   {
     // expected-error@*:* {{std::minmax_element requires a ForwardIterator}}
     (void) std::minmax_element(Iter(b), Iter(e));
   }
 
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <map>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // map(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> map<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
 // map(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
 //   -> map<Key, Compare, Allocator>;
 // template<class InputIterator, class Allocator>
 // map(InputIterator, InputIterator, Allocator)
 //   -> map<iter-value-type<InputIterator>, less<iter-value-type<InputIterator>>, Allocator>;
 // template<class Key, class Allocator>
 // map(initializer_list<Key>, Allocator)
 //   -> map<Key, less<Key>, Allocator>;
 
 #include <climits> // INT_MAX
 #include <functional>
 #include <map>
 #include <type_traits>
 
 struct NotAnAllocator {
     friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
 };
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;
 
 int main(int, char**)
 {
     {
         // cannot deduce Key and T from nothing
         std::map m; // expected-error{{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'}}
     }
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <map>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // multimap(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> multimap<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
 // multimap(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
 //   -> multimap<Key, Compare, Allocator>;
 // template<class InputIterator, class Allocator>
 // multimap(InputIterator, InputIterator, Allocator)
 //   -> multimap<iter-value-type<InputIterator>, less<iter-value-type<InputIterator>>, Allocator>;
 // template<class Key, class Allocator>
 // multimap(initializer_list<Key>, Allocator)
 //   -> multimap<Key, less<Key>, Allocator>;
 
 #include <climits> // INT_MAX
 #include <functional>
 #include <map>
 #include <type_traits>
 
 struct NotAnAllocator {
     friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
 };
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;
 
 int main(int, char**)
 {
     {
         // cannot deduce Key and T from nothing
         std::multimap m; // expected-error{{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{{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'}}
     }
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <set>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // multiset(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> multiset<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>,
 //          class Allocator = allocator<Key>>
 // multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
 //   -> multiset<Key, Compare, Allocator>;
 // template<class InputIterator, class Allocator>
 // multiset(InputIterator, InputIterator, Allocator)
 //   -> multiset<iter-value-type<InputIterator>,
 //               less<iter-value-type<InputIterator>>, Allocator>;
 // template<class Key, class Allocator>
 // multiset(initializer_list<Key>, Allocator)
 //   -> multiset<Key, less<Key>, Allocator>;
 
 #include <functional>
 #include <set>
 #include <type_traits>
 
 struct NotAnAllocator {
   friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
 };
 
 int main(int, char **) {
   {
     // cannot deduce Key from nothing
     std::multiset s;
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}}
   }
   {
     // cannot deduce Key from just (Compare)
     std::multiset s(std::less<int>{});
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}}
   }
   {
     // cannot deduce Key from just (Compare, Allocator)
     std::multiset s(std::less<int>{}, std::allocator<int>{});
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}}
   }
   {
     // cannot deduce Key from multiset(Allocator)
     std::multiset s(std::allocator<int>{});
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}}
   }
   {
     // since we have parens, not braces, this deliberately does not find the
     // initializer_list constructor
     NotAnAllocator a;
     std::multiset s(a);
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}}
   }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <set>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // set(InputIterator, InputIterator,
 //     Compare = Compare(), Allocator = Allocator())
 //   -> set<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>,
 //          class Allocator = allocator<Key>>
 // set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
 //   -> set<Key, Compare, Allocator>;
 // template<class InputIterator, class Allocator>
 // set(InputIterator, InputIterator, Allocator)
 //   -> set<iter-value-type<InputIterator>,
 //          less<iter-value-type<InputIterator>>, Allocator>;
 // template<class Key, class Allocator>
 // set(initializer_list<Key>, Allocator)
 //   -> set<Key, less<Key>, Allocator>;
 
 #include <functional>
 #include <set>
 #include <type_traits>
 
 struct NotAnAllocator {
   friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
 };
 
 int main(int, char **) {
   {
     // cannot deduce Key from nothing
     std::set s;
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}}
   }
   {
     // cannot deduce Key from just (Compare)
     std::set s(std::less<int>{});
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}}
   }
   {
     // cannot deduce Key from just (Compare, Allocator)
     std::set s(std::less<int>{}, std::allocator<int>{});
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}}
   }
   {
     // cannot deduce Key from just (Allocator)
     std::set s(std::allocator<int>{});
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}}
   }
   {
     // since we have parens, not braces, this deliberately does not find the
     // initializer_list constructor
     NotAnAllocator a;
     std::set s(a);
     // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}}
   }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 // UNSUPPORTED: c++03, c++11, c++14
 
 #include <queue>
 #include <deque>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
 //  queue(Compare, Container, const Alloc);
 //  The '45' is not an allocator
     std::priority_queue pri(std::greater<int>(), std::deque<int>({1,2,3}), 45);  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'priority_queue'}}
     }
 
     {
 //  queue(const queue&, const Alloc&);
 //  The '45' is not an allocator
     std::priority_queue<int> source;
     std::priority_queue pri(source, 45);  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'priority_queue'}}
     }
 
     {
 //  priority_queue(Iter, Iter, Comp)
 //  int is not an iterator
     std::priority_queue pri(15, 17, std::greater<double>());  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'priority_queue'}}
     }
 
     {
 //  priority_queue(Iter, Iter, Comp, Container)
 //  float is not an iterator
     std::priority_queue pri(23.f, 2.f, std::greater<float>(), std::deque<float>());   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'priority_queue'}}
     }
 
 //  Test the implicit deduction guides
     {
 //  priority_queue (allocator &)
     std::priority_queue pri((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'priority_queue'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 // UNSUPPORTED: c++03, c++11, c++14
 
 #include <queue>
 #include <list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
 //  queue(const Container&, const Alloc&);
 //  The '45' is not an allocator
     std::queue que(std::list<int>{1,2,3}, 45);  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'queue'}}
     }
 
     {
 //  queue(const queue&, const Alloc&);
 //  The '45' is not an allocator
     std::queue<int> source;
     std::queue que(source, 45);  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'queue'}}
     }
 
 //  Test the implicit deduction guides
     {
 //  queue (allocator &)
     std::queue que((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'queue'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <stack>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    vector(InputIterator, InputIterator, Allocator = Allocator())
 //    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
 
 #include <stack>
 #include <list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
 //  stack(const Container&, const Alloc&);
 //  The '45' is not an allocator
     std::stack stk(std::list<int>({1,2,3}), 45);  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'stack'}}
     }
 
     {
 //  stack(const stack&, const Alloc&);
 //  The '45' is not an allocator
     std::stack<int> source;
     std::stack stk(source, 45);  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'stack'}}
     }
 
 //  Test the implicit deduction guides
     {
 //  stack (allocator &)
     std::stack stk((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'stack'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class T, class... U>
 //   array(T, U...) -> array<T, 1 + sizeof...(U)>;
 //
 //  Requires: (is_same_v<T, U> && ...) is true. Otherwise the program is ill-formed.
 
 
 #include <array>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     std::array arr{1,2,3L}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'array'}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.creation/to_array.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <array>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 
 // expected-warning@array:* 0-1 {{suggest braces around initialization of subobject}}
 
 int main(int, char**) {
   {
     char source[3][6] = {"hi", "world"};
     // expected-error@array:* {{to_array does not accept multidimensional arrays}}
     // expected-error@array:* {{to_array requires copy constructible elements}}
     // expected-error@array:* 3 {{cannot initialize}}
     std::to_array(source); // expected-note {{requested here}}
   }
 
   {
     MoveOnly mo[] = {MoveOnly{3}};
     // expected-error@array:* {{to_array requires copy constructible elements}}
     // expected-error-re@array:* {{{{(call to implicitly-deleted copy constructor of 'MoveOnly')|(call to deleted constructor of 'MoveOnly')}}}}
     std::to_array(mo); // expected-note {{requested here}}
   }
 
   {
     const MoveOnly cmo[] = {MoveOnly{3}};
     // expected-error@array:* {{to_array requires move constructible elements}}
     // expected-error-re@array:* {{{{(call to implicitly-deleted copy constructor of 'MoveOnly')|(call to deleted constructor of 'MoveOnly')}}}}
     std::to_array(std::move(cmo)); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.fill/fill.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // void fill(const T& u);
 
 #include <array>
 #include <cassert>
 
 int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
     // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{.*}}cannot fill zero-sized array of type 'const T'}}
     c.fill(5.5); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.swap/swap.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // void swap(array& a);
 
 #include <array>
 #include <cassert>
 
 int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
     C c2 = {};
     // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{.*}}cannot swap zero-sized array of type 'const T'}}
     c.swap(c2); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    deque(InputIterator, InputIterator, Allocator = Allocator())
 //    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
 #include <deque>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 #include <climits> // INT_MAX
 
 struct A {};
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
 
 //  Test the implicit deduction guides
     {
 //  deque (allocator &)
     std::deque deq((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'deque'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    forward_list(InputIterator, InputIterator, Allocator = Allocator())
 //    -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
 #include <forward_list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 #include <climits> // INT_MAX
 
 struct A {};
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
 
 //  Test the implicit deduction guides
     {
 //  forward_list (allocator &)
     std::forward_list fwl((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'forward_list'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      forward_list<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    list(InputIterator, InputIterator, Allocator = Allocator())
 //    -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
 #include <list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 #include <climits> // INT_MAX
 
 struct A {};
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
 
 //  Test the implicit deduction guides
     {
 //  list (allocator &)
     std::list lst((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'list'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    vector(InputIterator, InputIterator, Allocator = Allocator())
 //    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
 #include <deque>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
 
 //  Test the implicit deduction guides
     {
 //  vector (allocator &)
     std::vector vec((std::allocator<int>()));  // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'vector'}}
 //  Note: The extra parens are necessary, since otherwise clang decides it is a function declaration.
 //  Also, we can't use {} instead of parens, because that constructs a
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/resize_not_move_insertable.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03 && !stdlib=libc++
 
 // <vector>
 
 // Test that vector produces a decent diagnostic for user types that explicitly
 // delete their move constructor. Such types don't meet the Cpp17CopyInsertable
 // requirements.
 
 #include <vector>
 
 template <int>
 class BadUserNoCookie {
 public:
   BadUserNoCookie() { }
 
   BadUserNoCookie(BadUserNoCookie&&) = delete;
   BadUserNoCookie& operator=(BadUserNoCookie&&) = delete;
 
   BadUserNoCookie(const BadUserNoCookie&) = default;
   BadUserNoCookie& operator=(const BadUserNoCookie&) = default;
 };
 
 int main(int, char**) {
   // expected-error@* 2 {{The specified type does not meet the requirements of Cpp17MoveInsertable}}
 
   // Other diagnostics that might be seen as Clang tries to continue compiling:
   // expected-error@* 0-2 {{call to deleted constructor}}
   // expected-error@* 0-2 {{no matching function for call to 'construct_at'}}
   {
 
     std::vector<BadUserNoCookie<1> > x;
     x.emplace_back();
   }
   {
     std::vector<BadUserNoCookie<2> > x;
     BadUserNoCookie<2> c;
     x.push_back(c);
   }
   return 0;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <unordered_map>
 
 // template<class InputIterator,
 //          class Hash = hash<iter-key-type<InputIterator>>,
 //          class Pred = equal_to<iter-key-type<InputIterator>>,
 //          class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
 // unordered_map(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,
 //                    Allocator>;
 //
 // template<class Key, class T, class Hash = hash<Key>,
 //          class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
 // unordered_map(initializer_list<pair<Key, T>>,
 //               typename see below::size_type = see below, Hash = Hash(),
 //               Pred = Pred(), Allocator = Allocator())
 //   -> unordered_map<Key, T, Hash, Pred, Allocator>;
 //
 // template<class InputIterator, class Allocator>
 // unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator)
 //   -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
 //                    hash<iter-key-type<InputIterator>>,
 //                    equal_to<iter-key-type<InputIterator>>, Allocator>;
 //
 // template<class InputIterator, class Allocator>
 // unordered_map(InputIterator, InputIterator, Allocator)
 //   -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
 //                    hash<iter-key-type<InputIterator>>,
 //                    equal_to<iter-key-type<InputIterator>>, Allocator>;
 //
 // template<class InputIterator, class Hash, class Allocator>
 // unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
 //   -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash,
 //                    equal_to<iter-key-type<InputIterator>>, Allocator>;
 //
 // template<class Key, class T, class Allocator>
 // unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Allocator)
 //   -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
 //
 // template<class Key, class T, class Allocator>
 // unordered_map(initializer_list<pair<Key, T>>, Allocator)
 //   -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
 //
 // template<class Key, class T, class Hash, class Allocator>
 // unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //               Allocator)
 //   -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
 
 #include <functional>
 #include <unordered_map>
 
 int main(int, char**)
 {
     using P = std::pair<const int, int>;
     {
         // cannot deduce Key from nothing
         std::unordered_map m; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Size)
         std::unordered_map m(42); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Size, Hash)
         std::unordered_map m(42, std::hash<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred)
         std::unordered_map m(42, std::hash<int>(), std::equal_to<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred, Allocator)
         std::unordered_map m(42, std::hash<int>(), std::equal_to<int>(), std::allocator<P>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Allocator)
         std::unordered_map m(std::allocator<P>{});
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Size, Allocator)
         std::unordered_map m(42, std::allocator<P>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Allocator)
         std::unordered_map m(42, std::hash<int>(), std::allocator<P>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
     }
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <unordered_map>
 
 // template<class InputIterator,
 //          class Hash = hash<iter-key-type<InputIterator>>,
 //          class Pred = equal_to<iter-key-type<InputIterator>>,
 //          class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
 // unordered_multimap(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,
 //                    Allocator>;
 //
 // template<class Key, class T, class Hash = hash<Key>,
 //          class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
 // unordered_multimap(initializer_list<pair<Key, T>>,
 //               typename see below::size_type = see below, Hash = Hash(),
 //               Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multimap<Key, T, Hash, Pred, Allocator>;
 //
 // template<class InputIterator, class Allocator>
 // unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
 //   -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
 //                    hash<iter-key-type<InputIterator>>,
 //                    equal_to<iter-key-type<InputIterator>>, Allocator>;
 //
 // template<class InputIterator, class Allocator>
 // unordered_multimap(InputIterator, InputIterator, Allocator)
 //   -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
 //                    hash<iter-key-type<InputIterator>>,
 //                    equal_to<iter-key-type<InputIterator>>, Allocator>;
 //
 // template<class InputIterator, class Hash, class Allocator>
 // unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
 //   -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash,
 //                    equal_to<iter-key-type<InputIterator>>, Allocator>;
 //
 // template<class Key, class T, class Allocator>
 // unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Allocator)
 //   -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
 //
 // template<class Key, class T, class Allocator>
 // unordered_multimap(initializer_list<pair<Key, T>>, Allocator)
 //   -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
 //
 // template<class Key, class T, class Hash, class Allocator>
 // unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //               Allocator)
 //   -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;
 
 #include <functional>
 #include <unordered_map>
 
 int main(int, char**)
 {
     using P = std::pair<const int, int>;
     {
         // cannot deduce Key from nothing
         std::unordered_multimap m; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Size)
         std::unordered_multimap m(42); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Size, Hash)
         std::unordered_multimap m(42, std::hash<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred)
         std::unordered_multimap m(42, std::hash<int>(), std::equal_to<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred, Allocator)
         std::unordered_multimap m(42, std::hash<int>(), std::equal_to<int>(), std::allocator<P>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Allocator)
         std::unordered_multimap m(std::allocator<P>{});
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Size, Allocator)
         std::unordered_multimap m(42, std::allocator<P>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Allocator)
         std::unordered_multimap m(42, std::hash<int>(), std::allocator<P>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
     }
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <unordered_set>
 
 // template<class InputIterator,
 //        class Hash = hash<iter-value-type<InputIterator>>,
 //        class Pred = equal_to<iter-value-type<InputIterator>>,
 //        class Allocator = allocator<iter-value-type<InputIterator>>>
 // unordered_multiset(InputIterator, InputIterator, typename see below::size_type = see below,
 //                    Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multiset<iter-value-type<InputIterator>,
 //                         Hash, Pred, Allocator>;
 //
 // template<class T, class Hash = hash<T>,
 //        class Pred = equal_to<T>, class Allocator = allocator<T>>
 // unordered_multiset(initializer_list<T>, typename see below::size_type = see below,
 //                    Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multiset<T, Hash, Pred, Allocator>;
 //
 // template<class InputIterator, class Allocator>
 // unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
 //   -> unordered_multiset<iter-value-type<InputIterator>,
 //                         hash<iter-value-type<InputIterator>>,
 //                         equal_to<iter-value-type<InputIterator>>,
 //                         Allocator>;
 //
 // template<class InputIterator, class Hash, class Allocator>
 // unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
 //                    Hash, Allocator)
 //   -> unordered_multiset<iter-value-type<InputIterator>, Hash,
 //                         equal_to<iter-value-type<InputIterator>>,
 //                         Allocator>;
 //
 // template<class T, class Allocator>
 // unordered_multiset(initializer_list<T>, typename see below::size_type, Allocator)
 //   -> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>;
 //
 // template<class T, class Hash, class Allocator>
 // unordered_multiset(initializer_list<T>, typename see below::size_type, Hash, Allocator)
 //   -> unordered_multiset<T, Hash, equal_to<T>, Allocator>;
 
 #include <functional>
 #include <unordered_set>
 
 int main(int, char**)
 {
     {
         // cannot deduce Key from nothing
         std::unordered_multiset s;
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Size)
         std::unordered_multiset s(42);
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Size, Hash)
         std::unordered_multiset s(42, std::hash<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred)
         std::unordered_multiset s(42, std::hash<int>(), std::equal_to<>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred, Allocator)
         std::unordered_multiset s(42, std::hash<int>(), std::equal_to<>(), std::allocator<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Allocator)
         std::unordered_multiset s(std::allocator<int>{});
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Size, Allocator)
         std::unordered_multiset s(42, std::allocator<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Allocator)
         std::unordered_multiset s(42, std::hash<short>(), std::allocator<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multiset'}}
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <unordered_set>
 
 // template<class InputIterator,
 //        class Hash = hash<iter-value-type<InputIterator>>,
 //        class Pred = equal_to<iter-value-type<InputIterator>>,
 //        class Allocator = allocator<iter-value-type<InputIterator>>>
 // unordered_set(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_set<iter-value-type<InputIterator>,
 //                    Hash, Pred, Allocator>;
 //
 // template<class T, class Hash = hash<T>,
 //        class Pred = equal_to<T>, class Allocator = allocator<T>>
 // unordered_set(initializer_list<T>, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_set<T, Hash, Pred, Allocator>;
 //
 // template<class InputIterator, class Allocator>
 // unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
 //   -> unordered_set<iter-value-type<InputIterator>,
 //                    hash<iter-value-type<InputIterator>>,
 //                    equal_to<iter-value-type<InputIterator>>,
 //                    Allocator>;
 //
 // template<class InputIterator, class Hash, class Allocator>
 // unordered_set(InputIterator, InputIterator, typename see below::size_type,
 //               Hash, Allocator)
 //   -> unordered_set<iter-value-type<InputIterator>, Hash,
 //                    equal_to<iter-value-type<InputIterator>>,
 //                    Allocator>;
 //
 // template<class T, class Allocator>
 // unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
 //   -> unordered_set<T, hash<T>, equal_to<T>, Allocator>;
 //
 // template<class T, class Hash, class Allocator>
 // unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
 //   -> unordered_set<T, Hash, equal_to<T>, Allocator>;
 
 #include <functional>
 #include <unordered_set>
 
 int main(int, char**)
 {
     {
         // cannot deduce Key from nothing
         std::unordered_set s;
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Size)
         std::unordered_set s(42);
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Size, Hash)
         std::unordered_set s(42, std::hash<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred)
         std::unordered_set s(42, std::hash<int>(), std::equal_to<>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Pred, Allocator)
         std::unordered_set s(42, std::hash<int>(), std::equal_to<>(), std::allocator<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Allocator)
         std::unordered_set s(std::allocator<int>{});
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Size, Allocator)
         std::unordered_set s(42, std::allocator<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
     {
         // cannot deduce Key from just (Size, Hash, Allocator)
         std::unordered_set s(42, std::hash<short>(), std::allocator<int>());
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_set'}}
     }
 
     return 0;
 }

libcxx/test/std/containers/views/views.span/span.cons/span.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <span>
 
 // template<class OtherElementType, size_t OtherExtent>
 //    constexpr span(const span<OtherElementType, OtherExtent>& s) noexcept;
 //
 //  Remarks: This constructor shall not participate in overload resolution unless:
 //      Extent == dynamic_extent || Extent == OtherExtent is true, and
 //      OtherElementType(*)[] is convertible to ElementType(*)[].
 
 
 #include <span>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 
 template<class T, std::size_t extent, size_t otherExtent>
 std::span<T, extent> createImplicitSpan(std::span<T, otherExtent> s) {
     return {s}; // expected-error {{chosen constructor is explicit in copy-initialization}}
 }
 
 void checkCV ()
 {
 //  std::span<               int>   sp;
     std::span<const          int>  csp;
     std::span<      volatile int>  vsp;
     std::span<const volatile int> cvsp;
 
 //  std::span<               int, 0>   sp0;
     std::span<const          int, 0>  csp0;
     std::span<      volatile int, 0>  vsp0;
     std::span<const volatile int, 0> cvsp0;
 
 //  Try to remove const and/or volatile (dynamic -> dynamic)
     {
     std::span<               int> s1{ csp}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
     std::span<               int> s2{ vsp}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
     std::span<               int> s3{cvsp}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
 
     std::span<const          int> s4{ vsp}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
     std::span<const          int> s5{cvsp}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
 
     std::span<      volatile int> s6{ csp}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
     std::span<      volatile int> s7{cvsp}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
     }
 
 //  Try to remove const and/or volatile (static -> static)
     {
     std::span<               int, 0> s1{ csp0}; // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
     std::span<               int, 0> s2{ vsp0}; // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
     std::span<               int, 0> s3{cvsp0}; // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
 
     std::span<const          int, 0> s4{ vsp0}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     std::span<const          int, 0> s5{cvsp0}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
 
     std::span<      volatile int, 0> s6{ csp0}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 0>'}}
     std::span<      volatile int, 0> s7{cvsp0}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 0>'}}
     }
 
 //  Try to remove const and/or volatile (static -> dynamic)
     {
     std::span<               int> s1{ csp0}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
     std::span<               int> s2{ vsp0}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
     std::span<               int> s3{cvsp0}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
 
     std::span<const          int> s4{ vsp0}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
     std::span<const          int> s5{cvsp0}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
 
     std::span<      volatile int> s6{ csp0}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
     std::span<      volatile int> s7{cvsp0}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
     }
 
 //  Try to remove const and/or volatile (static -> static)
     {
     std::span<               int, 0> s1{ csp}; // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
     std::span<               int, 0> s2{ vsp}; // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
     std::span<               int, 0> s3{cvsp}; // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
 
     std::span<const          int, 0> s4{ vsp}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     std::span<const          int, 0> s5{cvsp}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
 
     std::span<      volatile int, 0> s6{ csp}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 0>'}}
     std::span<      volatile int, 0> s7{cvsp}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 0>'}}
     }
 }
 
 int main(int, char**)
 {
     std::span<int>      sp;
     std::span<int, 0>   sp0;
 
     std::span<float> s1{sp};    // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
     std::span<float> s2{sp0};   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
     std::span<float, 0> s3{sp}; // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
     std::span<float, 0> s4{sp0};    // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
 
     checkCV();
 
     // explicit constructor necessary
     {
     createImplicitSpan<int, 1>(sp);
     }
 
   return 0;
 }

libcxx/test/std/experimental/memory/memory.resource/construct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <experimental/memory_resource>
 
 // Check that memory_resource is not constructible
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 namespace ex = std::experimental::pmr;
 
 int main(int, char**)
 {
     ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
 
   return 0;
 }

libcxx/test/std/experimental/memory/memory.resource/memory.resource.priv/private_members.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <experimental/memory_resource>
 
 // memory_resource::do_allocate(size_t, size_t);          /* private */
 // memory_resource::do_deallocate(void*, size_t, size_t); /* private */
 // memory_resource::do_is_equal(memory_resource const&);  /* private */
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <experimental/memory_resource>
 
 namespace ex = std::experimental::pmr;
 
 int main(int, char**) {
     ex::memory_resource *m = ex::new_delete_resource();
     m->do_allocate(0, 0); // expected-error{{'do_allocate' is a private member}}
     m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a private member}}
     m->do_is_equal(*m); // expected-error{{'do_is_equal' is a private member}}
 
   return 0;
 }

libcxx/test/std/experimental/utilities/meta/meta.detect/nonesuch.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // <experimental/type_traits>
 //
 //  struct nonesuch;
 //    nonesuch has no default constructor (C++17 section 15.1)
 //    or initializer-list constructor (C++17 section 11.6.4),
 //    and is not an aggregate (C++17 section 11.6.1).
 
 
 #include <experimental/type_traits>
 #include <string>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental;
 
 void doSomething (const ex::nonesuch &) {}
 
 int main(int, char**) {
     ex::nonesuch *e0 = new ex::nonesuch; // expected-error {{no matching constructor for initialization of 'ex::nonesuch'}}
     doSomething({}); // expected-error{{no matching function for call to 'doSomething'}}
 
     return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/append_op.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 #include "filesystem_include.h"
 
 using namespace fs;
 
 struct ConvToPath {
   operator fs::path() const {
     return "";
   }
 };
 
 int main(int, char**) {
   ConvToPath LHS, RHS;
   (void)(LHS / RHS); // expected-error {{invalid operands to binary expression}}
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 #include "filesystem_include.h"
 
 using namespace fs;
 
 struct ConvToPath {
   operator fs::path() const {
     return "";
   }
 };
 
 int main(int, char**) {
   ConvToPath LHS, RHS;
   (void)(LHS == RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS != RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS < RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS <= RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS > RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS >= RHS); // expected-error {{invalid operands to binary expression}}
 
   return 0;
 }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_istream;
 
 // basic_istream(basic_istream const& rhs) = delete;
 // basic_istream& operator=(basic_istream const&) = delete;
 
 #include <istream>
 #include <type_traits>
 #include <cassert>
 
 struct test_istream
     : public std::basic_istream<char>
 {
     typedef std::basic_istream<char> base;
 
     test_istream(test_istream&& s)
         : base(std::move(s)) // OK
     {
     }
 
     test_istream& operator=(test_istream&& s) {
       base::operator=(std::move(s)); // OK
       return *this;
     }
 
     test_istream(test_istream const& s)
         : base(s) // expected-error {{call to deleted constructor of 'std::basic_istream<char>'}}
     {
     }
 
     test_istream& operator=(test_istream const& s) {
       base::operator=(s); // expected-error {{call to deleted member function 'operator='}}
       return *this;
     }
 
 };
 
 int main(int, char**)
 {
   return 0;
 }

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <streambuf>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_streambuf;
 
 // basic_streambuf(const basic_streambuf& rhs);  // protected
 
 #include <streambuf>
 #include <cassert>
 
 std::streambuf &get();
 
 int main(int, char**)
 {
     std::streambuf sb = get(); // expected-error {{calling a protected constructor}}
 
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // struct iterator_traits
 // {
 // };
 
 #include <iterator>
 #include "test_macros.h"
 
 struct A {};
 struct NotAnIteratorEmpty {};
 
 struct NotAnIteratorNoDifference
 {
 //     typedef int                       difference_type;
     typedef A                         value_type;
     typedef A*                        pointer;
     typedef A&                        reference;
     typedef std::forward_iterator_tag iterator_category;
 };
 
 struct NotAnIteratorNoValue
 {
     typedef int                       difference_type;
 //     typedef A                         value_type;
     typedef A*                        pointer;
     typedef A&                        reference;
     typedef std::forward_iterator_tag iterator_category;
 };
 
 struct NotAnIteratorNoPointer
 {
     typedef int                       difference_type;
     typedef A                         value_type;
 //     typedef A*                        pointer;
     typedef A&                        reference;
     typedef std::forward_iterator_tag iterator_category;
 };
 
 struct NotAnIteratorNoReference
 {
     typedef int                       difference_type;
     typedef A                         value_type;
     typedef A*                        pointer;
 //    typedef A&                        reference;
     typedef std::forward_iterator_tag iterator_category;
 };
 
 struct NotAnIteratorNoCategory
 {
     typedef int                       difference_type;
     typedef A                         value_type;
     typedef A*                        pointer;
     typedef A&                        reference;
 //     typedef std::forward_iterator_tag iterator_category;
 };
 
 int main(int, char**)
 {
     {
     typedef std::iterator_traits<NotAnIteratorEmpty> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoDifference> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoValue> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
 #if TEST_STD_VER <= 17 || !defined(__cpp_lib_concepts)
     {
     typedef std::iterator_traits<NotAnIteratorNoPointer> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
 #endif // TEST_STD_VER <= 17 || !defined(__cpp_lib_concepts)
     {
     typedef std::iterator_traits<NotAnIteratorNoReference> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoCategory> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
 
   return 0;
 }

libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.types.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <new>
 
 // template <class T> constexpr T* launder(T* p) noexcept;
 // The program is ill-formed if T is a function type or cv void.
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 #include <new>
 #include <cassert>
 
 #include "test_macros.h"
 
 void foo() {}
 
 int main(int, char**)
 {
     void *p = nullptr;
     (void) std::launder((               void *) nullptr);
     (void) std::launder((const          void *) nullptr);
     (void) std::launder((      volatile void *) nullptr);
     (void) std::launder((const volatile void *) nullptr);  // expected-error-re@new:* 4 {{{{(static_assert|static assertion)}} failed{{.*}}can't launder cv-void}}
     // expected-error@new:* 0-4 {{void pointer argument to '__builtin_launder' is not allowed}}
 
     (void) std::launder(foo);                              // expected-error-re@new:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}can't launder functions}}
     // expected-error@new:* 0-1 {{function pointer argument to '__builtin_launder' is not allowed}}
 
   return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr T bit_ceil(T x) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
 //          T is an unsigned integer type
 
 #include <bit>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool toobig()
 {
     return 0 == std::bit_ceil(std::numeric_limits<T>::max());
 }
 
 int main(int, char**)
 {
     // Make sure we generate a compile-time error for UB
     static_assert(toobig<unsigned char>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned short>(),     ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned>(),           ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned long>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned long long>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
     static_assert(toobig<std::uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::uint16_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::uint32_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::uint64_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::size_t>(), "");    // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::uintmax_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::uintptr_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
     return 0;
 }

libcxx/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // Test that UDT's convertible to an integral or floating point type do not
 // participate in overload resolution.
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
 template <class IntT>
 struct UDT {
   operator IntT() const { return 1; }
 };
 
 UDT<float> ft;
 UDT<double> dt;
 UDT<long double> ldt;
 UDT<int> it;
 UDT<unsigned long> uit;
 
 int main(int, char**)
 {
     {
         std::real(ft); // expected-error {{no matching function}}
         std::real(dt); // expected-error {{no matching function}}
         std::real(ldt); // expected-error {{no matching function}}
         std::real(it); // expected-error {{no matching function}}
         std::real(uit); // expected-error {{no matching function}}
     }
     {
         std::imag(ft); // expected-error {{no matching function}}
         std::imag(dt); // expected-error {{no matching function}}
         std::imag(ldt); // expected-error {{no matching function}}
         std::imag(it); // expected-error {{no matching function}}
         std::imag(uit); // expected-error {{no matching function}}
     }
     {
         std::arg(ft); // expected-error {{no matching function}}
         std::arg(dt); // expected-error {{no matching function}}
         std::arg(ldt); // expected-error {{no matching function}}
         std::arg(it); // expected-error {{no matching function}}
         std::arg(uit); // expected-error {{no matching function}}
     }
     {
         std::norm(ft); // expected-error {{no matching function}}
         std::norm(dt); // expected-error {{no matching function}}
         std::norm(ldt); // expected-error {{no matching function}}
         std::norm(it); // expected-error {{no matching function}}
         std::norm(uit); // expected-error {{no matching function}}
     }
     {
         std::conj(ft); // expected-error {{no matching function}}
         std::conj(dt); // expected-error {{no matching function}}
         std::conj(ldt); // expected-error {{no matching function}}
         std::conj(it); // expected-error {{no matching function}}
         std::conj(uit); // expected-error {{no matching function}}
     }
     {
         std::proj(ft); // expected-error {{no matching function}}
         std::proj(dt); // expected-error {{no matching function}}
         std::proj(ldt); // expected-error {{no matching function}}
         std::proj(it); // expected-error {{no matching function}}
         std::proj(uit); // expected-error {{no matching function}}
     }
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // <numeric>
 
 // template <class _Tp>
 // _Tp midpoint(_Tp __a, _Tp __b) noexcept
 
 // An overload exists for each of char and all arithmetic types except bool.
 
 #include <numeric>
 
 #include "test_macros.h"
 
 int func1 () { return 1; }
 int func2 () { return 2; }
 
 struct Incomplete;
 Incomplete *ip = nullptr;
 void       *vp = nullptr;
 
 int main(int, char**)
 {
     (void) std::midpoint(false, true);  // expected-error {{no matching function for call to 'midpoint'}}
 
 //  A couple of odd pointer types that should fail
     (void) std::midpoint(nullptr, nullptr);  // expected-error {{no matching function for call to 'midpoint'}}
     (void) std::midpoint(func1, func2);      // expected-error {{no matching function for call to 'midpoint'}}
     (void) std::midpoint(ip, ip);            // expected-error {{no matching function for call to 'midpoint'}}
     (void) std::midpoint(vp, vp);            // expected-error {{no matching function for call to 'midpoint'}}
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
 // requirements on parameters
 
 #include <random>
 
 int main(int, char**)
 {
     typedef unsigned long long T;
 
     // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}}
     std::linear_congruential_engine<T, 0, 0, 0> e2;
     // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}}
     std::linear_congruential_engine<T, 0, 1, 1> e3;
     std::linear_congruential_engine<T, 1, 0, 1> e4;
     // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement 'is_unsigned<int>::value'{{.*}}_UIntType must be unsigned type}}
     std::linear_congruential_engine<int, 0, 0, 0> e5;
 
     return 0;
 }

libcxx/test/std/re/re.regex/re.regex.construct/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template<class ForwardIterator>
 // basic_regex(ForwardIterator, ForwardIterator,
 //             regex_constants::syntax_option_type = regex_constants::ECMAScript)
 // -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
 
 #include <regex>
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 
 int main(int, char**)
 {
     // Test the explicit deduction guides
     {
     // basic_regex(ForwardIterator, ForwardIterator)
     // <int> is not an iterator
     std::basic_regex re(23, 34);   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_regex'}}
     }
 
     {
     // basic_regex(ForwardIterator, ForwardIterator, flag_type)
     // <double> is not an iterator
     std::basic_regex re(23.0, 34.0, std::regex_constants::basic);   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_regex'}}
     }
 
     return 0;
 }

libcxx/test/std/strings/basic.string.hash/char_type_hash.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 
 // UNSUPPORTED: c++03
 
 // <string>
 
 // Test that hash specializations for <string> require "char_traits<_CharT>" not just any "_Trait".
 
 #include <functional>
 #include <string>
 
 #include "test_macros.h"
 
 template <class _CharT>
 struct trait // copied from <__string>
 {
     typedef _CharT         char_type;
     typedef int            int_type;
     typedef std::streamoff off_type;
     typedef std::streampos pos_type;
     typedef std::mbstate_t state_type;
 
     static inline void assign(char_type& __c1, const char_type& __c2) {
         __c1 = __c2;
     }
     static inline bool eq(char_type __c1, char_type __c2) { return __c1 == __c2; }
     static inline bool lt(char_type __c1, char_type __c2) { return __c1 < __c2; }
 
     static int compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
     static std::size_t length(const char_type* __s);
     static const char_type* find(const char_type* __s, std::size_t __n,
                                  const char_type& __a);
 
     static char_type* move(char_type* __s1, const char_type* __s2, std::size_t __n);
     static char_type* copy(char_type* __s1, const char_type* __s2, std::size_t __n);
     static char_type* assign(char_type* __s, std::size_t __n, char_type __a);
 
     static inline int_type not_eof(int_type __c) {
         return eq_int_type(__c, eof()) ? ~eof() : __c;
     }
     static inline char_type to_char_type(int_type __c) { return char_type(__c); }
     static inline int_type to_int_type(char_type __c) { return int_type(__c); }
     static inline bool eq_int_type(int_type __c1, int_type __c2) {
         return __c1 == __c2;
     }
     static inline int_type eof() { return int_type(EOF); }
 };
 
 template <class CharT>
 void test() {
     typedef std::basic_string<CharT, trait<CharT> > str_t;
     std::hash<str_t>
         h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     // expected-error-re@-2 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
 #endif
     (void)h;
 }
 
 int main(int, char**) {
     test<char>();
     test<wchar_t>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>();
 #endif
     test<char16_t>();
     test<char32_t>();
 
     return 0;
 }

libcxx/test/std/strings/string.view/char.bad.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
 
 // <string_view>
 //   ... manipulating sequences of any non-array trivial standard-layout types.
 
 #include <string>
 #include "../basic.string/test_traits.h"
 
 struct NotTrivial {
     NotTrivial() : value(3) {}
     int value;
 };
 
 struct NotStandardLayout {
 public:
     NotStandardLayout() : one(1), two(2) {}
     int sum() const { return one + two; } // silences "unused field 'two' warning"
     int one;
 private:
     int two;
 };
 
 int main(int, char**)
 {
     {
 //  array
     typedef char C[3];
     static_assert(std::is_array<C>::value, "");
     std::basic_string_view<C, test_traits<C> > sv;
 //  expected-error-re@string_view:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string_view must not be an array}}
     }
 
     {
 //  not trivial
     static_assert(!std::is_trivial<NotTrivial>::value, "");
     std::basic_string_view<NotTrivial, test_traits<NotTrivial> > sv;
 //  expected-error-re@string_view:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string_view must be trivial}}
     }
 
     {
 //  not standard layout
     static_assert(!std::is_standard_layout<NotStandardLayout>::value, "");
     std::basic_string_view<NotStandardLayout, test_traits<NotStandardLayout> > sv;
 //  expected-error-re@string_view:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string_view must be standard-layout}}
     }
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.hash/char_type.hash.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: !stdlib=libc++ && (c++11 || c++14)
 
 // <string_view>
 
 // Test that hash specializations for <string_view> require "char_traits<_CharT>" not just any "_Trait".
 
 #include <string_view>
 #include <string> // for 'mbstate_t'
 
 #include "test_macros.h"
 
 template <class _CharT>
 struct trait // copied from <__string>
 {
     typedef _CharT         char_type;
     typedef int            int_type;
     typedef std::streamoff off_type;
     typedef std::streampos pos_type;
     typedef std::mbstate_t state_type;
 
     static inline void assign(char_type& __c1, const char_type& __c2) {
         __c1 = __c2;
     }
     static inline bool eq(char_type __c1, char_type __c2) { return __c1 == __c2; }
     static inline bool lt(char_type __c1, char_type __c2) { return __c1 < __c2; }
 
     static int compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
     static std::size_t length(const char_type* __s);
     static const char_type* find(const char_type* __s, std::size_t __n,
                                  const char_type& __a);
 
     static char_type* move(char_type* __s1, const char_type* __s2, std::size_t __n);
     static char_type* copy(char_type* __s1, const char_type* __s2, std::size_t __n);
     static char_type* assign(char_type* __s, std::size_t __n, char_type __a);
 
     static inline int_type not_eof(int_type __c) {
         return eq_int_type(__c, eof()) ? ~eof() : __c;
     }
     static inline char_type to_char_type(int_type __c) { return char_type(__c); }
     static inline int_type to_int_type(char_type __c) { return int_type(__c); }
     static inline bool eq_int_type(int_type __c1, int_type __c2) {
         return __c1 == __c2;
     }
     static inline int_type eof() { return int_type(EOF); }
 };
 
 template <class CharT>
 void test() {
     typedef std::basic_string_view<CharT, trait<CharT> > strv_t;
     std::hash<strv_t>
         h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     // expected-error-re@-2 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
 #endif
     (void)h;
 }
 
 int main(int, char**) {
     test<char>();
     test<wchar_t>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>();
 #endif
     test<char16_t>();
     test<char32_t>();
 
     return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.members/assign_copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 
 // packaged_task& operator=(packaged_task&) = delete;
 
 #include <future>
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor1.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 // template <class F>
 //   packaged_task(F&& f);
 // These constructors shall not participate in overload resolution if
 //    decay<F>::type is the same type as std::packaged_task<R(ArgTypes...)>.
 
 #include <future>
 #include <cassert>
 
 struct A {};
 typedef std::packaged_task<A(int, char)> PT;
 typedef volatile std::packaged_task<A(int, char)> VPT;
 
 
 int main(int, char**)
 {
     VPT init{};
     auto const& c_init = init;
     PT p1{init}; // expected-error {{no matching constructor}}
     PT p2{c_init}; // expected-error {{no matching constructor}}
     PT p3{std::move(init)}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 
 // packaged_task(packaged_task&) = delete;
 
 #include <future>
 
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p(p0); // expected-error {{call to deleted constructor of 'std::packaged_task<double (int, char)>'}}
     }
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-threads
 
 // <mutex>
 
 // template <class Mutex> class lock_guard;
 
 // explicit lock_guard(mutex_type& m);
 
 #include <mutex>
 
 int main(int, char**)
 {
     std::mutex m;
     std::lock_guard<std::mutex> lg = m; // expected-error{{no viable conversion}}
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <mutex>
 
 // template <class ...Mutex> class scoped_lock;
 
 // scoped_lock& operator=(scoped_lock const&) = delete;
 
 #include <mutex>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
     M om0, om1, om2;
     {
         using LG = std::scoped_lock<>;
         LG lg1, lg2;
         lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
     }
     {
         using LG = std::scoped_lock<M>;
         LG lg1(m0);
         LG lg2(om0);
         lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
     }
     {
         using LG = std::scoped_lock<M, M>;
         LG lg1(m0, m1);
         LG lg2(om0, om1);
         lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
     }
     {
         using LG = std::scoped_lock<M, M, M>;
         LG lg1(m0, m1, m2);
         LG lg2(om0, om1, om2);
         lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
     }
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <mutex>
 
 // template <class ...Mutex> class scoped_lock;
 
 // scoped_lock(scoped_lock const&) = delete;
 
 #include <mutex>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
     {
         using LG = std::scoped_lock<>;
         const LG Orig;
         LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
     }
     {
         using LG = std::scoped_lock<M>;
         const LG Orig(m0);
         LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
     }
     {
         using LG = std::scoped_lock<M, M>;
         const LG Orig(m0, m1);
         LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
     }
     {
         using LG = std::scoped_lock<M, M, M>;
         const LG Orig(m0, m1, m2);
         LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
     }
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <mutex>
 
 // template <class ...Mutex> class scoped_lock;
 
 // explicit scoped_lock(Mutex&...);
 
 #include <mutex>
 #include "test_macros.h"
 
 template <class LG>
 void test_conversion(LG) {}
 
 int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
     M n0, n1, n2;
     {
         using LG = std::scoped_lock<>;
         LG lg = {}; // expected-error{{chosen constructor is explicit in copy-initialization}}
         test_conversion<LG>({}); // expected-error{{no matching function for call}}
         ((void)lg);
     }
     {
         using LG = std::scoped_lock<M>;
         LG lg = {m0}; // expected-error{{chosen constructor is explicit in copy-initialization}}
         test_conversion<LG>({n0}); // expected-error{{no matching function for call}}
         ((void)lg);
     }
     {
         using LG = std::scoped_lock<M, M>;
         LG lg = {m0, m1}; // expected-error{{chosen constructor is explicit in copy-initialization}}
         test_conversion<LG>({n0, n1}); // expected-error{{no matching function for call}}
         ((void)lg);
     }
     {
         using LG = std::scoped_lock<M, M, M>;
         LG lg = {m0, m1, m2}; // expected-error{{chosen constructor is explicit in copy-initialization}}
         test_conversion<LG>({n0, n1, n2}); // expected-error{{no matching function for call}}
     }
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03, c++11, c++14
 
 // UNSUPPORTED: availability-shared_mutex-missing
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // shared_mutex& operator=(const shared_mutex&) = delete;
 
 #include <shared_mutex>
 
 int main(int, char**)
 {
     std::shared_mutex m0;
     std::shared_mutex m1;
     m1 = m0; // expected-error {{overload resolution selected deleted operator '='}}
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: no-threads
 // UNSUPPORTED: c++03, c++11, c++14
 
 // UNSUPPORTED: availability-shared_mutex-missing
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // shared_mutex(const shared_mutex&) = delete;
 
 #include <shared_mutex>
 
 int main(int, char**)
 {
     std::shared_mutex m0;
     std::shared_mutex m1(m0); // expected-error {{call to deleted constructor of 'std::shared_mutex'}}
 
   return 0;
 }

libcxx/test/std/time/time.hms/hhmmss.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <chrono>
 
 // template <class Duration> class hh_mm_ss;
 //   If Duration is not an instance of duration, the program is ill-formed.
 
 #include <chrono>
 #include <string>
 #include <cassert>
 #include "test_macros.h"
 
 struct A {};
 
 int main(int, char**)
 {
     std::chrono::hh_mm_ss<void> h0;        // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
     std::chrono::hh_mm_ss<int> h1;         // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
     std::chrono::hh_mm_ss<std::string> h2; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
     std::chrono::hh_mm_ss<A> h3;           // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
 
     return 0;
 }

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <chrono>
 // class day;
 
 // constexpr day operator""d(unsigned long long d) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     using day = std::chrono::day;
     day d1 = 4d; // expected-error-re {{no matching literal operator for call to 'operator""d' {{.*}}}}
 
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <chrono>
 // class year;
 
 // constexpr year operator""y(unsigned long long y) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     using std::chrono::year;
     year d1 = 1234y; // expected-error-re {{no matching literal operator for call to 'operator""y' {{.*}}}}
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // UNSUPPORTED: availability-bad_any_cast-missing
 
 // <any>
 
 // template <class ValueType>
 // ValueType any_cast(any &&);
 
 // Try and use the rvalue any_cast to cast to an lvalue reference
 
 #include <any>
 
 struct TestType {};
 
 void test_const_lvalue_cast_request_non_const_lvalue()
 {
     const std::any a;
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     // expected-error@any:* {{drops 'const' qualifier}}
     std::any_cast<TestType &>(a); // expected-note {{requested here}}
 
     const std::any a2(42);
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     // expected-error@any:* {{drops 'const' qualifier}}
     std::any_cast<int&>(a2); // expected-note {{requested here}}
 }
 
 void test_lvalue_any_cast_request_rvalue()
 {
     std::any a;
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &&>(a); // expected-note {{requested here}}
 
     std::any a2(42);
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<int&&>(a2); // expected-note {{requested here}}
 }
 
 void test_rvalue_any_cast_request_lvalue()
 {
     std::any a;
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
     // expected-error@any:* {{non-const lvalue reference to type 'TestType' cannot bind to a temporary}}
     std::any_cast<TestType &>(std::move(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
     // expected-error@any:* {{non-const lvalue reference to type 'int' cannot bind to a temporary}}
     std::any_cast<int&>(42);
 }
 
 int main(int, char**)
 {
     test_const_lvalue_cast_request_non_const_lvalue();
     test_lvalue_any_cast_request_rvalue();
     test_rvalue_any_cast_request_lvalue();
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <any>
 
 // template <class ValueType>
 // ValueType const* any_cast(any const *) noexcept;
 //
 // template <class ValueType>
 // ValueType * any_cast(any *) noexcept;
 
 #include <any>
 
 int main(int, char**)
 {
     std::any a = 1;
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int &>(&a); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int &&>(&a); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int const &>(&a); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int const&&>(&a); // expected-note {{requested here}}
 
     const std::any& a2 = a;
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int &>(&a2); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int &&>(&a2); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int const &>(&a2); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}}
     std::any_cast<int const &&>(&a2); // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.bool.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <charconv>
 
 // In
 //
 // from_chars_result from_chars(const char* first, const char* last,
 //                              Integral& value, int base = 10)
 //
 // Integral cannot be bool.
 
 #include <charconv>
 
 int main(int, char**)
 {
     using std::from_chars;
     char buf[] = "01001";
     bool lv;
 
     from_chars(buf, buf + sizeof(buf), lv);      // expected-error {{call to deleted function}}
     from_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
 
   return 0;
 }

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.bool.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <charconv>
 
 // In
 //
 // to_chars_result to_chars(char* first, char* last, Integral value,
 //                          int base = 10)
 //
 // Integral cannot be bool.
 
 #include <charconv>
 
 int main(int, char**)
 {
     using std::to_chars;
     char buf[10];
     bool lv = true;
 
     to_chars(buf, buf + sizeof(buf), false);   // expected-error {{call to deleted function}}
     to_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
 
   return 0;
 }

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template<class T, T N>
 //   using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
 
 // UNSUPPORTED: c++03, c++11
 
 // This test hangs during recursive template instantiation with libstdc++
 // UNSUPPORTED: stdlib=libstdc++
 
 #include <utility>
-#include <type_traits>
-#include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-  typedef std::make_integer_sequence<int, -3> MakeSeqT;
 
-  // std::make_integer_sequence is implemented using a compiler builtin if available.
-  // this builtin has different diagnostic messages than the fallback implementation.
-#if TEST_HAS_BUILTIN(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
-  MakeSeqT i; // expected-error@*:* {{integer sequences must have non-negative sequence length}}
+#if TEST_HAS_BUILTIN(__make_integer_seq)
 #else
-  MakeSeqT i; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}std::make_integer_sequence must have a non-negative sequence length}}
 #endif
-
-  return 0;
-}

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template<class T, T N>
 //   using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
 
 // UNSUPPORTED: c++03, c++11
 
 // This test hangs during recursive template instantiation with libstdc++
 // UNSUPPORTED: stdlib=libstdc++
 
 #define _LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE
-#include "make_integer_seq.fail.cpp"
+#include <utility>
+
+typedef std::make_integer_sequence<int, -3> MakeSeqT;
+MakeSeqT i; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}std::make_integer_sequence must have a non-negative sequence length}}

libcxx/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Because we don't have a functioning decltype in C++03
 // UNSUPPORTED: c++03
 
 // UNSUPPORTED: no-localization
 
 // <memory>
 
 // unique_ptr
 
 // template<class CharT, class Traits, class Y, class D>
 //   basic_ostream<CharT, Traits>&
 //   operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);
 
 //   -?- Remarks: This function shall not participate in overload resolution unless os << p.get() is a valid expression.
 
 #include <memory>
 #include <sstream>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "deleter_types.h"
 
 int main(int, char**)
 {
     std::unique_ptr<int, PointerDeleter<int>> p;
     std::ostringstream os;
     os << p; // expected-error {{invalid operands to binary expression}}
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
 // template<class Y> shared_ptr(const shared_ptr<Y>& r);
 
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 struct A {
   int x = 42;
 };
 
 struct ADel : std::default_delete<A> {
   typedef A* pointer;
 };
 
 int main(int, char**) {
   static_assert(!(std::is_convertible<A, int>::value), "");
 
   {
     std::shared_ptr<A> pA;
     std::shared_ptr<int> pi(pA); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
   }
   {
     std::shared_ptr<A> pA;
     std::shared_ptr<int> pi(std::move(pA)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
   }
   {
     std::weak_ptr<A> pA;
     std::shared_ptr<int> pi(std::move(pA)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
   }
 
 #if TEST_STD_VER > 14
   {
     std::unique_ptr<int, ADel> ui;
     std::shared_ptr<int> pi(std::move(ui)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
   }
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_arrow.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // shared_ptr
 
 // element_type& operator[](ptrdiff_t i) const;
 
 #include "test_macros.h"
 
 #include <memory>
 #include <cassert>
 
 struct Foo {
   void call() {}
 };
 
 int main(int, char**) {
   // Check that we get a static assertion when we try to use the bracket
   // operator on shared_ptr<T> when T is not an array type.
   const std::shared_ptr<Foo[]> p1;
   (void)p1->call(); // expected-error@*:* {{std::shared_ptr<T>::operator-> is only valid when T is not an array type.}}
   const std::shared_ptr<Foo[4]> p2;
   (void)p2->call(); // expected-error@*:* {{std::shared_ptr<T>::operator-> is only valid when T is not an array type.}}
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bracket.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // shared_ptr
 
 // element_type& operator[](ptrdiff_t i) const;
 
 #include "test_macros.h"
 
 #include <memory>
 #include <cassert>
 
 int main(int, char**) {
   // Check that we get a static assertion when we try to use the bracket
   // operator on shared_ptr<T> when T is not an array type.
   const std::shared_ptr<int> p;
   (void)p[0]; // expected-error@*:* {{std::shared_ptr<T>::operator[] is only valid when T is an array type.}}
   return 0;
 }

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <type_traits>
 
 
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
 #ifndef __cpp_lib_is_constant_evaluated
   // expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}}
   bool b = std::is_constant_evaluated();
 #else
   // expected-error-re@+1 {{{{(static_assert|static assertion)}} failed}}
   static_assert(!std::is_constant_evaluated(), "");
   // expected-warning@-1 0-1 {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
 #endif
   return 0;
 }

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // type_traits
 
 // MSVC mode seems to use different rules regarding enum sizes, so E1
 // doesn't cause an error.
 // UNSUPPORTED: msvc
 
 // underlying_type
 // Mandates: enum must not be an incomplete enumeration type.
 
 #include <type_traits>
 #include <climits>
 
 #include "test_macros.h"
 
 enum E1 { E1Zero, E1One, E1Two = sizeof(std::underlying_type<E1>::type) }; // expected-error@*:* {{cannot determine underlying type of incomplete enumeration type 'E1'}}
 
 //  None of these are incomplete.
 //  Scoped enums have an underlying type of 'int' unless otherwise specified
 //  Unscoped enums with a specified underlying type become complete as soon as that type is specified.
 // enum E2 : char            { E2Zero, E2One, E2Two = sizeof(std::underlying_type<E2>::type) };
 // enum class E3             { E3Zero, E3One, E3Two = sizeof(std::underlying_type<E3>::type) };
 // enum struct E4 : unsigned { E4Zero, E4One, E4Two = sizeof(std::underlying_type<E4>::type) };
 // enum struct E5            { E5Zero, E5One, E5Two = sizeof(std::underlying_type<E5>::type) };
 // enum class E6 : unsigned  { E6Zero, E6One, E6Two = sizeof(std::underlying_type<E6>::type) };
 
 // These error messages will have to change if clang ever gets fixed. But at least they're being rejected.
 enum E7        : std::underlying_type_t<E7> {}; // expected-error {{use of undeclared identifier 'E7'}}
 enum class E8  : std::underlying_type_t<E8> {}; // expected-error {{use of undeclared identifier 'E8'}}
 enum struct E9 : std::underlying_type_t<E9> {}; // expected-error {{use of undeclared identifier 'E9'}}
 
 int main(int, char**)
 {
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // <optional>
 
 // T shall be an object type other than cv in_place_t or cv nullopt_t
 //   and shall satisfy the Cpp17Destructible requirements.
 // Note: array types do not satisfy the Cpp17Destructible requirements.
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct NonDestructible { ~NonDestructible() = delete; };
 
 int main(int, char**)
 {
     {
     std::optional<char &> o1;          // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a reference type is ill-formed}}
     std::optional<NonDestructible> o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
     std::optional<char[20]> o3;        // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with an array type is ill-formed}}
     }
 
     {
     std::optional<               std::in_place_t> o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
     std::optional<const          std::in_place_t> o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
     std::optional<      volatile std::in_place_t> o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
     std::optional<const volatile std::in_place_t> o4; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
     }
 
     {
     std::optional<               std::nullopt_t> o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
     std::optional<const          std::nullopt_t> o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
     std::optional<      volatile std::nullopt_t> o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
     std::optional<const volatile std::nullopt_t> o4; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
     }
 
     return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <optional>
 
 // template<class T>
 //   optional(T) -> optional<T>;
 
 #include <optional>
 #include <cassert>
 
 struct A {};
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
 
 //  Test the implicit deduction guides
     {
 //  optional()
     std::optional opt;   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'optional'}}
     }
 
     {
 //  optional(nullopt_t)
     std::optional opt(std::nullopt);   // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
     }
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // <optional>
 
 // T shall be an object type and shall satisfy the requirements of Destructible
 
 #include <optional>
 
 using std::optional;
 
 struct X
 {
 private:
     ~X() {}
 };
 
 int main(int, char**)
 {
     using std::optional;
     {
         // expected-error-re@optional:* 2 {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a reference type is ill-formed}}
         optional<int&> opt1;
         optional<int&&> opt2;
     }
     {
         // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
         optional<X> opt3;
     }
     {
         // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
         // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
         optional<void()> opt4;
     }
     {
         // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
         // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
         // expected-error@optional:* 1+ {{cannot form a reference to 'void'}}
         optional<const void> opt4;
     }
     // FIXME these are garbage diagnostics that Clang should not produce
     // expected-error@optional:* 0+ {{is not a base class}}
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // unique_ptr
 
 // unique_ptr<T, const D&>(pointer, D()) should not compile
 
 #include <memory>
 
 struct Deleter {
   void operator()(int* p) const { delete p; }
 };
 
 int main(int, char**) {
   // expected-error@+1 {{call to deleted constructor of 'std::unique_ptr<int, const Deleter &>}}
   std::unique_ptr<int, const Deleter&> s((int*)nullptr, Deleter());
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 // UNSUPPORTED: c++03
 
 // unique_ptr
 
 // test reset
 
 #include <memory>
 #include <cassert>
 
 #include "unique_ptr_test_helper.h"
 
 int main(int, char**) {
   {
     std::unique_ptr<A[]> p;
     p.reset(static_cast<B*>(nullptr)); // expected-error {{no matching member function for call to 'reset'}}
   }
   {
     std::unique_ptr<int[]> p;
     p.reset(static_cast<const int*>(nullptr)); // expected-error {{no matching member function for call to 'reset'}}
   }
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // unique_ptr
 
 // test op[](size_t)
 
 #include <memory>
 #include <cassert>
 
 int main(int, char**) {
   std::unique_ptr<int> p(new int[3]);
   std::unique_ptr<int> const& cp = p;
   p[0];  // expected-error {{type 'std::unique_ptr<int>' does not provide a subscript operator}}
   cp[1]; // expected-error {{type 'const std::unique_ptr<int>' does not provide a subscript operator}}
 
   return 0;
 }

libcxx/test/std/utilities/utility/forward/forward.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // test forward
 
 #include <utility>
 
 #include "test_macros.h"
 
 struct A
 {
 };
 
 A source() {return A();}
 const A csource() {return A();}
 
 int main(int, char**)
 {
     {
         (void)std::forward<A&>(source());  // expected-note {{requested here}}
         // expected-error-re@*:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}cannot forward an rvalue as an lvalue}}
     }
     {
         const A ca = A();
         std::forward<A&>(ca); // expected-error {{no matching function for call to 'forward'}}
     }
     {
         std::forward<A&>(csource());  // expected-error {{no matching function for call to 'forward'}}
     }
     {
         const A ca = A();
         std::forward<A>(ca); // expected-error {{no matching function for call to 'forward'}}
     }
     {
         std::forward<A>(csource()); // expected-error {{no matching function for call to 'forward'}}
     }
     {
         A a;
         std::forward(a); // expected-error {{no matching function for call to 'forward'}}
     }
 
   return 0;
 }

libcxx/test/std/utilities/utility/forward/move.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // This test should pass in C++03 with Clang extensions because Clang does
 // not implicitly delete the copy constructor when move constructors are
 // defaulted using extensions.
 
 // XFAIL: c++03
 
 // test move
 
 #include <utility>
 #include <cassert>
 
 struct move_only {
     move_only() {}
     move_only(move_only&&) = default;
     move_only& operator=(move_only&&) = default;
 };
 
 move_only source() {return move_only();}
 const move_only csource() {return move_only();}
 
 void test(move_only) {}
 
 int main(int, char**)
 {
   const move_only ca = move_only();
   // expected-error@+1 {{call to implicitly-deleted copy constructor of 'move_only'}}
   test(std::move(ca));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/construct.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // TODO: Change to XFAIL once https://github.com/llvm/llvm-project/issues/40340 is fixed
 // UNSUPPORTED: availability-pmr-missing
 
 // <memory_resource>
 
 // Check that memory_resource is not constructible
 
 #include <memory_resource>
 
 void test() {
   std::pmr::memory_resource m; // expected-error {{variable type 'std::pmr::memory_resource' is an abstract class}}
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.private/private_members.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // TODO: Change to XFAIL once https://github.com/llvm/llvm-project/issues/40340 is fixed
 // UNSUPPORTED: availability-pmr-missing
 
 // <memory_resource>
 
 // memory_resource::do_allocate(size_t, size_t);          /* private */
 // memory_resource::do_deallocate(void*, size_t, size_t); /* private */
 // memory_resource::do_is_equal(memory_resource const&);  /* private */
 
 #include <memory_resource>
 
 void test() {
   std::pmr::memory_resource* m = std::pmr::new_delete_resource();
   m->do_allocate(0, 0);            // expected-error{{'do_allocate' is a private member}}
   m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a private member}}
   m->do_is_equal(*m);              // expected-error{{'do_is_equal' is a private member}}
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.private/protected_members.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // TODO: Change to XFAIL once https://github.com/llvm/llvm-project/issues/40340 is fixed
 // UNSUPPORTED: availability-pmr-missing
 
 // <memory_resource>
 
 // monotonic_buffer_resource::do_allocate(size_t, size_t);          /* protected */
 // monotonic_buffer_resource::do_deallocate(void*, size_t, size_t); /* protected */
 // monotonic_buffer_resource::do_is_equal(memory_resource const&);  /* protected */
 
 // synchronized_pool_resource::do_allocate(size_t, size_t);          /* protected */
 // synchronized_pool_resource::do_deallocate(void*, size_t, size_t); /* protected */
 // synchronized_pool_resource::do_is_equal(memory_resource const&);  /* protected */
 
 // unsynchronized_pool_resource::do_allocate(size_t, size_t);          /* protected */
 // unsynchronized_pool_resource::do_deallocate(void*, size_t, size_t); /* protected */
 // unsynchronized_pool_resource::do_is_equal(memory_resource const&);  /* protected */
 
 #include <memory_resource>
 
 void test() {
   {
     std::pmr::monotonic_buffer_resource m;
     m.do_allocate(0, 0);            // expected-error{{'do_allocate' is a protected member}}
     m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
     m.do_is_equal(m);               // expected-error{{'do_is_equal' is a protected member}}
   }
   {
     std::pmr::synchronized_pool_resource m;
     m.do_allocate(0, 0);            // expected-error{{'do_allocate' is a protected member}}
     m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
     m.do_is_equal(m);               // expected-error{{'do_is_equal' is a protected member}}
   }
   {
     std::pmr::unsynchronized_pool_resource m;
     m.do_allocate(0, 0);            // expected-error{{'do_allocate' is a protected member}}
     m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
     m.do_is_equal(m);               // expected-error{{'do_is_equal' is a protected member}}
   }
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <utility>
 
 // template<class T, class U>
 //   constexpr bool cmp_equal(T t, U u) noexcept; // C++20
 
 // template<class T, class U>
 //   constexpr bool cmp_not_equal(T t, U u) noexcept; // C++20
 
 // template<class T, class U>
 //   constexpr bool cmp_less(T t, U u) noexcept; // C++20
 
 // template<class T, class U>
 //   constexpr bool cmp_less_equal(T t, U u) noexcept; // C++20
 
 // template<class T, class U>
 //   constexpr bool cmp_greater(T t, U u) noexcept; // C++20
 
 // template<class T, class U>
 //   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
 
 // template<class R, class T>
 //   constexpr bool in_range(T t) noexcept;      // C++20
 
 #include <utility>
 #include <cstddef>
 
 #include "test_macros.h"
 
 struct NonEmptyT {
   int val;
   NonEmptyT() : val(0) {}
   NonEmptyT(int val) : val(val) {}
   operator int&() { return val; }
   operator int() const { return val; }
 };
 
 enum ColorT { red, green, blue };
 
 struct EmptyT {};
 
 template <class T>
 constexpr void test() {
   std::cmp_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_equal'}}
   std::cmp_not_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_less(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_less'}}
   std::cmp_less_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_greater(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}}
   std::in_range<T>(int()); // expected-error 10-11 {{no matching function for call to 'in_range'}}
   std::in_range<int>(T()); // expected-error 10-11 {{no matching function for call to 'in_range'}}
 }
 #ifndef TEST_HAS_NO_CHAR8_T
 template <class T>
 constexpr void test_char8t() {
   std::cmp_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
   std::cmp_not_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_less(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_less'}}
   std::cmp_less_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_greater(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
   std::in_range<T>(int()); // expected-error 1 {{no matching function for call to 'in_range'}}
   std::in_range<int>(T()); // expected-error 1 {{no matching function for call to 'in_range'}}
 }
 #endif // TEST_HAS_NO_CHAR8_T
 
 template <class T>
 constexpr void test_uchars() {
   std::cmp_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   std::cmp_not_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_less(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_less'}}
   std::cmp_less_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_greater(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater_equal'}}
   std::in_range<T>(int()); // expected-error 2 {{no matching function for call to 'in_range'}}
   std::in_range<int>(T()); // expected-error 2 {{no matching function for call to 'in_range'}}
 }
 
 int main(int, char**) {
   test<bool>();
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
   test<float>();
   test<double>();
   test<long double>();
   test<std::byte>();
   test<NonEmptyT>();
   test<ColorT>();
   test<std::nullptr_t>();
   test<EmptyT>();
 
 #ifndef TEST_HAS_NO_CHAR8_T
   test_char8t<char8_t>();
 #endif // TEST_HAS_NO_CHAR8_T
 
   test_uchars<char16_t>();
   test_uchars<char32_t>();
 
   return 0;
 }

libcxx/test/std/utilities/variant/variant.helpers/variant_alternative.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // template <size_t I, class T> struct variant_alternative; // undefined
 // template <size_t I, class T> struct variant_alternative<I, const T>;
 // template <size_t I, class T> struct variant_alternative<I, volatile T>;
 // template <size_t I, class T> struct variant_alternative<I, const volatile T>;
 // template <size_t I, class T>
 //   using variant_alternative_t = typename variant_alternative<I, T>::type;
 //
 // template <size_t I, class... Types>
 //    struct variant_alternative<I, variant<Types...>>;
 
 #include <memory>
 #include <type_traits>
 #include <variant>
 
 int main(int, char**) {
     using V = std::variant<int, void *, const void *, long double>;
     std::variant_alternative<4, V>::type foo;  // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
 
   return 0;
 }

libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types>
 // constexpr bool
 // operator==(variant<Types...> const&, variant<Types...> const&) noexcept;
 //
 // template <class ...Types>
 // constexpr bool
 // operator!=(variant<Types...> const&, variant<Types...> const&) noexcept;
 //
 // template <class ...Types>
 // constexpr bool
 // operator<(variant<Types...> const&, variant<Types...> const&) noexcept;
 //
 // template <class ...Types>
 // constexpr bool
 // operator>(variant<Types...> const&, variant<Types...> const&) noexcept;
 //
 // template <class ...Types>
 // constexpr bool
 // operator<=(variant<Types...> const&, variant<Types...> const&) noexcept;
 //
 // template <class ...Types>
 // constexpr bool
 // operator>=(variant<Types...> const&, variant<Types...> const&) noexcept;
 
 #include <cassert>
 #include <type_traits>
 #include <utility>
 #include <variant>
 
 #include "test_macros.h"
 
 
 struct MyBoolExplicit {
   bool value;
   constexpr explicit MyBoolExplicit(bool v) : value(v) {}
   constexpr explicit operator bool() const noexcept { return value; }
 };
 
 struct ComparesToMyBoolExplicit {
   int value = 0;
 };
 inline constexpr MyBoolExplicit operator==(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value == RHS.value);
 }
 inline constexpr MyBoolExplicit operator!=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value != RHS.value);
 }
 inline constexpr MyBoolExplicit operator<(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value < RHS.value);
 }
 inline constexpr MyBoolExplicit operator<=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value <= RHS.value);
 }
 inline constexpr MyBoolExplicit operator>(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value > RHS.value);
 }
 inline constexpr MyBoolExplicit operator>=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value >= RHS.value);
 }
 
 
 int main(int, char**) {
   using V = std::variant<int, ComparesToMyBoolExplicit>;
   V v1(42);
   V v2(101);
   // expected-error-re@variant:* 6 {{{{(static_assert|static assertion)}} failed{{.*}}the relational operator does not return a type which is implicitly convertible to bool}}
   // expected-error@variant:* 6 {{no viable conversion}}
   (void)(v1 == v2); // expected-note {{here}}
   (void)(v1 != v2); // expected-note {{here}}
   (void)(v1 < v2); // expected-note {{here}}
   (void)(v1 <= v2); // expected-note {{here}}
   (void)(v1 > v2); // expected-note {{here}}
   (void)(v1 >= v2); // expected-note {{here}}
 
   return 0;
 }

libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // LWG issue 3024
 
 #include <variant>
 #include <type_traits>
 
 struct NotCopyConstructible
 {
     NotCopyConstructible() = default;
     NotCopyConstructible(NotCopyConstructible const&) = delete;
 };
 
 int main(int, char**)
 {
     static_assert(!std::is_copy_constructible_v<NotCopyConstructible>);
 
     std::variant<NotCopyConstructible> v;
     std::variant<NotCopyConstructible> v1;
     std::variant<NotCopyConstructible> v2(v); // expected-error {{call to implicitly-deleted copy constructor of 'std::variant<NotCopyConstructible>'}}
     v1 = v; // expected-error-re {{object of type 'std:{{.*}}:variant<NotCopyConstructible>' cannot be assigned because its copy assignment operator is implicitly deleted}}
 }

libcxx/test/std/utilities/variant/variant.variant/variant_array.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 
 #include <variant>
 #include <type_traits>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 #include "test_convertible.h"
 
 int main(int, char**)
 {
     // expected-error-re@variant:* 3 {{{{(static_assert|static assertion)}} failed}}
     std::variant<int, int[]> v; // expected-note {{requested here}}
     std::variant<int, int[42]> v2; // expected-note {{requested here}}
     std::variant<int, int[][42]> v3; // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/variant/variant.variant/variant_empty.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 
 int main(int, char**)
 {
     // expected-error-re@variant:* 1 {{{{(static_assert|static assertion)}} failed}}
     std::variant<> v; // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/variant/variant.variant/variant_reference.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 
 int main(int, char**)
 {
     // expected-error-re@variant:* 3 {{{{(static_assert|static assertion)}} failed}}
     std::variant<int, int&> v; // expected-note {{requested here}}
     std::variant<int, const int &> v2; // expected-note {{requested here}}
     std::variant<int, int&&> v3; // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/variant/variant.variant/variant_void.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 
 #include <variant>
 #include <type_traits>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 #include "test_convertible.h"
 
 int main(int, char**)
 {
     // expected-error-re@variant:* 3 {{{{(static_assert|static assertion)}} failed}}
     std::variant<int, void> v; // expected-note {{requested here}}
     std::variant<int, const void> v2; // expected-note {{requested here}}
     std::variant<const volatile void, int> v3; // expected-note {{requested here}}
 
   return 0;
 }