libcxx changes not tested yet. Testing them.

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_add(&obj, 0);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_add(&fun, 0);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_add(&fun, 0);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_add_explicit(&obj, 0, std::memory_order_relaxed);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_add_explicit(&fun, 0, std::memory_order_relaxed);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_add_explicit(&fun, 0, std::memory_order_relaxed);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_sub(&obj, 0);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_sub(&fun, 0);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_sub(&fun, 0);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_sub_explicit(&obj, 0, std::memory_order_relaxed);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_sub_explicit(&fun, 0, std::memory_order_relaxed);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
     std::atomic_fetch_sub_explicit(&fun, 0, std::memory_order_relaxed);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp

 //
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_filebuf<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@streambuf:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp

 
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_fstream<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@ios:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@ios:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@streambuf:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
 // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp

 #include <cassert>
 
 struct test_istream
     : public std::basic_istream<char, std::char_traits<wchar_t> > {};
 
 
 int main(int, char**)
 {
-//  expected-error-re@ios:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@ios:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp

 #include <cassert>
 
 struct test_ostream
     : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
 
 
 int main(int, char**)
 {
-//  expected-error-re@ios:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@ios:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp

 
 // UNSUPPORTED: no-wide-characters
 
 #include <sstream>
 
 int main(int, char**)
 {
   std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error-re@string:* {{static_assert failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@streambuf:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@string:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp

 // reverse_iterator
 
 #include <iterator>
 
 #include "test_iterators.h"
 
 int main(int, char**) {
   using BadIter = std::reverse_iterator<forward_iterator<int*>>;
-  BadIter i; //expected-error-re@*:* {{static_assert failed{{.*}}reverse_iterator<It> requires It to be a bidirectional iterator.}}
+  BadIter i; //expected-error-re@*:* {{static assertion failed{{.*}}reverse_iterator<It> requires It to be a bidirectional iterator.}}
 
   return 0;
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::bernoulli_distribution dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::binomial_distribution<int> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::geometric_distribution<int> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 7 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 7 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::negative_binomial_distribution<int> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 7 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 7 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::cauchy_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::chi_squared_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 3 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 3 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::fisher_f_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 4 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 4 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::lognormal_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::normal_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::student_t_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 5 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 5 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::exponential_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::extreme_value_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::gamma_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 3 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 3 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::poisson_distribution<int> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 4 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 4 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::weibull_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::discrete_distribution<int> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::piecewise_constant_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::piecewise_linear_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::uniform_int_distribution<int> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/bad_engine.verify.cpp

struct G {
   static constexpr result_type max() { return 255; }
 };
 
 void test(std::uniform_real_distribution<double> dist)
 {
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
   dist(okg);
 }

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

 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 failed{{.*}}default_delete cannot be instantiated for function types}}
+  // expected-error-re@*:* {{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/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp

 
 #include <utility>
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, double> P;
     std::tuple_element<2, P>::type foo; // expected-note {{requested here}}
-        // expected-error-re@*:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < 2')?}}{{.*}}Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
+        // expected-error-re@*:* {{static assertion failed{{( due to requirement '2U[L]{0,2} < 2')?}}{{.*}}Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
     }
 
   return 0;
 }

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

 #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 failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}}{{.*}}Index out of bounds in std::variant_alternative<>}}
+        // expected-error-re@variant:* {{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.fail.cpp

template <class PopulationIterator, class SampleIterator> void test() {
   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 failed{{( due to requirement '.*')?}}{{.*}}SampleIterator must meet the requirements of RandomAccessIterator}}
+  // expected-error-re@*:* {{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/containers/associative/map/map.cons/deduct.fail.cpp

int main(int, char**)
         // 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 failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}}
+            // expected-error-re@map:* {{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

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

int main(int, char**)
         // 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 failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}}
+            // expected-error-re@map:* {{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

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

 #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 failed{{.*}}cannot fill zero-sized array of type 'const T'}}
+    // expected-error-re@array:* {{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.fail.cpp

 #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 failed{{.*}}cannot swap zero-sized array of type 'const T'}}
+    // expected-error-re@array:* {{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/array/array.tuple/get.fail.cpp

 
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         std::get<3>(c) = 5.5; // expected-note {{requested here}}
-        // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::get<> (std::array)}}
+        // expected-error-re@array:* {{static assertion failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::get<> (std::array)}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp

 #include <cassert>
 
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         std::tuple_element<3, C> foo; // expected-note {{requested here}}
-        // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::tuple_element<> (std::array)}}
+        // expected-error-re@array:* {{static assertion failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::tuple_element<> (std::array)}}
     }
 
   return 0;
 }

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp

int main(int, char**)
     using H = coro::coroutine_handle<>;
     // expected-error@experimental/coroutine:* 3 {{coroutine_handle<void>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
     H::from_address((const void*)nullptr); // expected-note {{requested here}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
   }
   {
     using H = coro::coroutine_handle<int>;
-    // expected-error-re@experimental/coroutine:* 1 {{static_assert failed{{.*}}coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead}}
+    // expected-error-re@experimental/coroutine:* 1 {{static assertion failed{{.*}}coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
     // expected-error@experimental/coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
   }
 
   return 0;
 }

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

 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 failed{{.*}}can't launder cv-void}}
+    (void) std::launder((const volatile void *) nullptr);  // expected-error-re@new:* 4 {{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 failed{{.*}}can't launder functions}}
+    (void) std::launder(foo);                              // expected-error-re@new:* 1 {{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.fail.cpp

 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 {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<unsigned short>(),     ""); // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<unsigned>(),           ""); // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<unsigned long>(),      ""); // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<unsigned long long>(), ""); // expected-error {{static_assert expression is not an integral constant expression}}
-
-  static_assert(toobig<uint8_t>(), "");   // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<uint16_t>(), "");   // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<uint32_t>(), "");   // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<uint64_t>(), "");   // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<size_t>(), "");   // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<uintmax_t>(), "");  // expected-error {{static_assert expression is not an integral constant expression}}
-  static_assert(toobig<uintptr_t>(), "");  // expected-error {{static_assert expression is not an integral constant expression}}
+  static_assert(toobig<unsigned char>(),      ""); // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<unsigned short>(),     ""); // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<unsigned>(),           ""); // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<unsigned long>(),      ""); // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<unsigned long long>(), ""); // expected-error {{static assertion expression is not an integral constant expression}}
+
+  static_assert(toobig<uint8_t>(), "");   // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<uint16_t>(), "");   // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<uint32_t>(), "");   // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<uint64_t>(), "");   // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<size_t>(), "");   // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<uintmax_t>(), "");  // expected-error {{static assertion expression is not an integral constant expression}}
+  static_assert(toobig<uintptr_t>(), "");  // expected-error {{static assertion expression is not an integral constant expression}}
 
   return 0;
 }

libcxx/test/std/numerics/numbers/illformed.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
 
 #include <numbers>
 
 // Initializing the primary template is ill-formed.
 int log2e{std::numbers::log2e_v<
-    int>}; // expected-error-re@numbers:* {{static_assert failed{{.*}}A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}}
+    int>}; // expected-error-re@numbers:* {{static assertion failed{{.*}}A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}}
 int log10e{std::numbers::log10e_v<int>};
 int pi{std::numbers::pi_v<int>};
 int inv_pi{std::numbers::inv_pi_v<int>};
 int inv_sqrtpi{std::numbers::inv_sqrtpi_v<int>};
 int ln2{std::numbers::ln2_v<int>};
 int ln10{std::numbers::ln10_v<int>};
 int sqrt2{std::numbers::sqrt2_v<int>};
 int sqrt3{std::numbers::sqrt3_v<int>};
 int inv_sqrt3{std::numbers::inv_sqrt3_v<int>};
 int egamma{std::numbers::egamma_v<int>};
 int phi{std::numbers::phi_v<int>};
 
 int main(int, char**) { return 0; }

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

 // requirements on parameters
 
 #include <random>
 
 int main(int, char**)
 {
     typedef unsigned long long T;
 
-    // expected-error-re@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}}
+    // expected-error-re@*:* {{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 failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}}
+    // expected-error-re@*:* {{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 failed due to requirement 'is_unsigned<int>::value'{{.*}}_UIntType must be unsigned type}}
+    // expected-error-re@*:* {{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/strings/basic.string/char.bad.verify.cpp

 };
 
 void f() {
     {
         // array
         typedef char C[3];
         static_assert(std::is_array<C>::value, "");
         std::basic_string<C, test_traits<C> > s;
-        // expected-error-re@string:* {{static_assert failed{{.*}}Character type of basic_string must not be an array}}
+        // expected-error-re@string:* {{static assertion failed{{.*}}Character type of basic_string must not be an array}}
     }
 
     {
         // not trivial
         static_assert(!std::is_trivial<NotTrivial>::value, "");
         std::basic_string<NotTrivial, test_traits<NotTrivial> > s;
-        // expected-error-re@string:* {{static_assert failed{{.*}}Character type of basic_string must be trivial}}
+        // expected-error-re@string:* {{static assertion failed{{.*}}Character type of basic_string must be trivial}}
     }
 
     {
         // not standard layout
         static_assert(!std::is_standard_layout<NotStandardLayout>::value, "");
         std::basic_string<NotStandardLayout, test_traits<NotStandardLayout> > s;
-        // expected-error-re@string:* {{static_assert failed{{.*}}Character type of basic_string must be standard-layout}}
+        // expected-error-re@string:* {{static assertion failed{{.*}}Character type of basic_string must be standard-layout}}
     }
 }

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

 
 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 failed{{.*}}Character type of basic_string_view must not be an array}}
+//  expected-error-re@string_view:* {{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 failed{{.*}}Character type of basic_string_view must be trivial}}
+//  expected-error-re@string_view:* {{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 failed{{.*}}Character type of basic_string_view must be standard-layout}}
+//  expected-error-re@string_view:* {{static assertion failed{{.*}}Character type of basic_string_view must be standard-layout}}
     }
 
   return 0;
 }

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

 #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 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 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 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 failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
+    std::chrono::hh_mm_ss<void> h0;        // expected-error-re@*:* {{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 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 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 assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
 
     return 0;
 }

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

 
 #include <any>
 
 struct TestType {};
 
 void test_const_lvalue_cast_request_non_const_lvalue()
 {
     const std::any a;
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{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 failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{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 failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{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 failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{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 failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{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 failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{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/const_correctness.verify.cpp

 
 struct TestType {};
 struct TestType2 {};
 
 int main(int, char**)
 {
     std::any a;
 
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &&>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType2 &>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType2 &&>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
   return 0;
 }

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

 struct no_move {
   no_move() {}
   no_move(no_move&&) = delete;
   no_move(no_move const&) {}
 };
 
 int main(int, char**) {
     std::any a;
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<no_copy>(static_cast<std::any&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<no_copy>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     std::any_cast<no_copy>(static_cast<std::any &&>(a)); // OK
 
-    // expected-error-re@any:* {{static_assert failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
+    // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
     std::any_cast<no_move>(static_cast<std::any &&>(a));
 
   return 0;
 }

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

 // ValueType * any_cast(any *) noexcept;
 
 #include <any>
 
 int main(int, char**)
 {
     std::any a = 1;
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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 failed{{.*}}_ValueType may not be a reference.}}
+    // expected-error-re@any:* 1 {{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/format/format.formatter/format.parse.ctx/check_arg_id.verify.cpp

constexpr bool test() {
   // core constant expressions ([expr.const]).
   std::format_parse_context context("", 0);
   context.check_arg_id(1);
 
   return true;
 }
 
 int main(int, char**) {
-  // expected-error@+1 {{static_assert expression is not an integral constant expression}}
+  // expected-error@+1 {{static assertion expression is not an integral constant expression}}
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.cpp

 void testNotMoveConst(NotMoveConst) { }
 
 int main(int, char**)
 {
     int n = 1;
     const int c = 1;
 
     auto p = std::bind_front(pass, c);
-    static_assert(p() == 1); // expected-error {{static_assert expression is not an integral constant expression}}
+    static_assert(p() == 1); // expected-error {{static assertion expression is not an integral constant expression}}
 
     auto d = std::bind_front(do_nothing, n); // expected-error {{no matching function for call to 'bind_front'}}
 
     auto t = std::bind_front(testNotMoveConst, NotMoveConst(0)); // expected-error {{no matching function for call to 'bind_front'}}
 
     return 0;
 }

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

 {
   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}}
 #else
-  MakeSeqT i; // expected-error@*:* {{static_assert failed{{.*}}std::make_integer_sequence must have a non-negative sequence length}}
+  MakeSeqT i; // expected-error@*:* {{static assertion failed{{.*}}std::make_integer_sequence must have a non-negative sequence length}}
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.constexpr.size.verify.cpp

constexpr bool test()
     TEST_IGNORE_NODISCARD a.allocate(((size_t) -1) / sizeof(T) + 1); // multiply will overflow
     TEST_IGNORE_NODISCARD a.allocate((size_t) -1);                   // way too large
 
     return true;
 }
 
 int main(int, char**)
 {
-    static_assert(test<double>()); // expected-error {{static_assert expression is not an integral constant expression}}
-    LIBCPP_STATIC_ASSERT(test<const double>()); // expected-error {{static_assert expression is not an integral constant expression}}
+    static_assert(test<double>()); // expected-error {{static assertion expression is not an integral constant expression}}
+    LIBCPP_STATIC_ASSERT(test<const double>()); // expected-error {{static assertion expression is not an integral constant expression}}
     return 0;
 }

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

 #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@+1 {{static_assert failed}}
+  // expected-error@+1 {{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/optional/optional.object/optional.object.ctor/ctor.fail.cpp

 
 #include "test_macros.h"
 
 struct NonDestructible { ~NonDestructible() = delete; };
 
 int main(int, char**)
 {
   {
-  std::optional<char &> o1;          // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with a reference type is ill-formed}}
-  std::optional<NonDestructible> o2;  // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
-  std::optional<char[20]> o3;          // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with an array type is ill-formed}}
+  std::optional<char &> o1;          // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+  std::optional<NonDestructible> o2;  // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+  std::optional<char[20]> o3;          // expected-error-re@optional:* {{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 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 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 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 failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+  std::optional<               std::in_place_t> o1;  // expected-error-re@optional:* {{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 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 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 assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
   }
 
   {
-  std::optional<               std::nullopt_t> o1;  // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  std::optional<const          std::nullopt_t> o2;  // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  std::optional<      volatile std::nullopt_t> o3;  // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-  std::optional<const volatile std::nullopt_t> o4;  // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+  std::optional<               std::nullopt_t> o1;  // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+  std::optional<const          std::nullopt_t> o2;  // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+  std::optional<      volatile std::nullopt_t> o3;  // expected-error-re@optional:* {{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 assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
   }
 
   return 0;
 }

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

 //  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 failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
     }
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp

constexpr bool test() // expected-error {{constexpr function never produces a constant expression}}
     std::optional<S> o2 = std::move(o1);
     return o2.has_value();  // return -something-
 }
 
 
 int main(int, char**)
 {
     static_assert (!std::is_trivially_move_constructible_v<S>, "" );
-    static_assert (test(), "");  // expected-error {{static_assert expression is not an integral constant expression}}
+    static_assert (test(), "");  // expected-error {{static assertion expression is not an integral constant expression}}
     return 0;
 }

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

 private:
     ~X() {}
 };
 
 int main(int, char**)
 {
     using std::optional;
     {
-        // expected-error-re@optional:* 2 {{static_assert failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+        // expected-error-re@optional:* 2 {{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 failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
         optional<X> opt3;
     }
     {
-        // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
-        // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
+        // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
         optional<void()> opt4;
     }
     {
-        // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
-        // expected-error-re@optional:* {{static_assert failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
+        // expected-error-re@optional:* {{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/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp

 #include <type_traits>
 
 int main(int, char**)
 {
     using T =  std::tuple<int, long, void*>;
     using E1 = typename std::tuple_element<1, T &>::type; // expected-error{{undefined template}}
     using E2 = typename std::tuple_element<3, T>::type;
     using E3 = typename std::tuple_element<4, T const>::type;
-        // expected-error@__tuple:* 2 {{static_assert failed}}
+        // expected-error@__tuple:* 2 {{static assertion failed}}
 
 
   return 0;
 }

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

 
 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 failed{{.*}}cannot forward an rvalue as an lvalue}}
+        // expected-error-re@*:* 1 {{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'}}
     }

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

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 failed{{.*}}the relational operator does not return a type which is implicitly convertible to bool}}
+  // expected-error-re@variant:* 6 {{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_array.fail.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 #include "test_convertible.h"
 
 int main(int, char**)
 {
-    // expected-error@variant:* 3 {{static_assert failed}}
+    // expected-error@variant:* 3 {{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.fail.cpp

 
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 
 int main(int, char**)
 {
-    // expected-error@variant:* 1 {{static_assert failed}}
+    // expected-error@variant:* 1 {{static assertion failed}}
     std::variant<> v; // expected-note {{requested here}}
 
   return 0;
 }

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

 
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 
 int main(int, char**)
 {
-    // expected-error@variant:* 3 {{static_assert failed}}
+    // expected-error@variant:* 3 {{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.fail.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "variant_test_helpers.h"
 #include "test_convertible.h"
 
 int main(int, char**)
 {
-    // expected-error@variant:* 3 {{static_assert failed}}
+    // expected-error@variant:* 3 {{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;
 }