[libc++] Add warning pragma macros in the test suite

[philnik]

• Fix CI

[EricWF]

Every single warning we disable should come with a comment explaining why the warning isn't real and why we're not fixing it some other way. We shouldn't encourage suppressing warnings.

[EricWF]

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

15

What happened here?

[philnik]

• Fix CI

[philnik]

In D121552#3378148, @EricWF wrote:

Every single warning we disable should come with a comment explaining why the warning isn't real and why we're not fixing it some other way. We shouldn't encourage suppressing warnings.

I mostly agree, but I don't think this is the PR for that.

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

15

What are you asking exactly? Why I removed it? Because it doesn't seem to suppress any warnings. Why was it there in the first place? I don't know.

[EricWF]

Have @ldionnes changes to enable warnings in the test suite been submitted yet? Maybe that's why you're not seeing some of the warnings you removed.
Can you double check that (A) The headers aren't included with -isystem or -cxx-isystem and that _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER is defined
when you've tested this?

In D121552#3378178, @philnik wrote:

In D121552#3378148, @EricWF wrote:

Every single warning we disable should come with a comment explaining why the warning isn't real and why we're not fixing it some other way. We shouldn't encourage suppressing warnings.

I mostly agree, but I don't think this is the PR for that.

I disagree. Changing the code changes the git blame and makes it harder to do archology on it.
If you're modifying the code in this patch, it's the time to ensure it has a comment.

That said, almost all of the changes already do have comments.:-D

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

22

Clang respects GCC's pragmas. We don't need both here.

libcxx/test/support/unique_ptr_test_helper.h

137

I think this needs to stay.

[EricWF]

libcxx/src/filesystem/filesystem_common.h

47–49

I would much rather we annotate each function than disable this for the entire file.
It's a useful warning.

610–612

Had this always been missing a pop?

libcxx/test/libcxx/minimal_cxx11_configuration.pass.cpp

28

There was a reason this went before the type traits includes I suspect.

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp

15

I suspect this is needed, and the test just wasn't run with warnings enabled. Otherwise something is broken.
That warning is specifically what the test is trying to generate. If it's not being generated, there's something very weird going on.

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

14

Don't make this harder to compile for people who don't use LIT..

libcxx/test/std/utilities/meta/meta.rel/is_convertible_fallback.pass.cpp

22–27

No. The #define NEEDS to be the first thing that occurs. Otherwise the entire test may not test anything.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp

13

Again, I don't think this change was actually tested with warnings enabled.

[EricWF]

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

28–29

What version was -Wconstant-evaluated added to Clang?

36

Where did this go?

[philnik]

• Fix CI; Address comments

libcxx/src/filesystem/filesystem_common.h

47–49

Almost all functions here are unused, because they are all in an anonymous namespace (and some are also declared static just to be safe). Shouldn't these functions be declared inline and not in an anonymous namespace/declared static? Or what is the rationale behind doing these very weird things?

610–612

No. You removed it for some reason in e3081d5d96fa2940bbec51d978f98384781ea979.

libcxx/test/libcxx/minimal_cxx11_configuration.pass.cpp

28

Actually, I have no idea why I left that in. The warning is explicitly disabled.

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

14

There are almost 500 uses of ADDITIONAL_COMPILE_FLAGS in the libc++ test suite. Are there even people who don't use lit to run the tests? If yes, what is the problem with using lit?

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

28–29

In Clang 10.

36

All major implementations are supporting std::is_constant_evaluated() for two years now (OK, in two days for two years). GCC since version 9, libc++ since version 9 and MSVC since VS 2019 16.5. I see no reason to guard this anymore. We don't guard any other tests with feature-test macros.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

22

We decided in D119295 that the best way (we could think of) is to fully separate the GCC and Clang warnings, because there are GCC warnings that Clang doesn't recognize and the macro would be kind-of lying if it disabled warnings for clang while being called _LIBCPP_GCC_DIAGNOSTIC_IGNORED.

[ldionne]

My understanding is that this patch doesn't remove any warnings (if so, @philnik please call them out) -- it only introduces new macros to push/pop warnings consistently like we've started doing in the libc++ source code itself. It also seems to remove a few unused pragmas, which I think is fine as a fly-by.

So I'm fine with this, however I would like to wait for D120684 to land before we land this one to make sure everything still works.

libcxx/src/filesystem/filesystem_common.h

47–49

I *think* it's because this header is included elsewhere e.g. in the test suite, but I'm speculating. Eric should know for sure, since he wrote it.

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

14

@EricWF FWIW, our intent is for everyone who uses the test suite to be doing so using Lit. The Lit setup has been made more flexible to make it possible for everyone to use it with the configuration they need. I'm not saying it's perfect, but that's the intent. Otherwise, it's just too difficult to keep the test suite independent of how Lit works.

[EricWF]

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp

15

Nevermind. I tried it for myself. Don't know what's going on but this is fine to remove.

Same thing with the other warnings I complained about. Sorry about that. I'm often dumb.

libcxx/test/support/unique_ptr_test_helper.h

137

Or it doesn't ignore me.

[ldionne]

I think this can be rebased. If CI passes and there's nothing subtle to call out, this LGTM.

[EricWF]

I still don't love that this patch codifies a way to disable warnings in tests. We don't want to do that, so it's fine that it's ugly to do.
But otherwise I'm OK with this.

[philnik]

Rebased

libcxx/src/filesystem/filesystem_common.h

 #include <ratio>
 #include <system_error>
 #include <utility>
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
-#endif
-
-#if !defined(_LIBCPP_WIN32API)
+#else
 # include <dirent.h>   // for DIR & friends
 # include <fcntl.h>    /* values for fchmodat */
 # include <sys/stat.h>
 # include <sys/statvfs.h>
 # include <sys/time.h> // for ::utimes as used in __last_write_time
 # include <unistd.h>
-#endif
+#endif // defined(_LIBCPP_WIN32API)
 
 #include "../include/apple_availability.h"
 
 #if !defined(__APPLE__)
 // We can use the presence of UTIME_OMIT to detect platforms that provide
 // utimensat.
 #if defined(UTIME_OMIT)
 #define _LIBCPP_USE_UTIMENSAT
 #endif
 #endif
 
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-#endif
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wunused-function")
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-function")
 
 #if defined(_LIBCPP_WIN32API)
 #define PS(x) (L##x)
 #define PATH_CSTR_FMT "\"%ls\""
 #else
 #define PS(x) (x)
 #define PATH_CSTR_FMT "\"%s\""
 #endif

 }
 
 #endif // !_LIBCPP_WIN32API
 
 } // namespace
 } // end namespace detail
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
+_LIBCPP_DIAGNOSTIC_POP
+
 #endif // FILESYSTEM_COMMON_H

libcxx/test/libcxx/containers/associative/undef_min_max.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-W#warnings"
-#endif
-
 #define min THIS IS A NASTY MACRO!
 #define max THIS IS A NASTY MACRO!
 
 #include <map>
 
-#include "test_macros.h"
-
 int main(int, char**) {
   std::map<int, int> m;
   ((void)m);
 
   return 0;
 }

libcxx/test/libcxx/minimal_cxx11_configuration.pass.cpp

 // 4. defaulted and deleted functions.
 // 5. default values for non-type template parameters.
 //
 // Some features we don't get and can't be used in extended C++03 mode:
 //
 // 1. noexcept and constexpr
 // 2. Two closing '>' without a space.
 
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wc++11-extensions"
-#endif
-
 #include <type_traits>
 #include <cassert>
 
 // Equals delete and default are allowed in minimal C++03 mode.
 namespace test_eq_delete_and_default {
 void t1() = delete;
 struct T2 {
   T2() = default;
   T2(T2 const&) = delete;
 };
 }
 
 namespace alias_templates {
 template <class T>

libcxx/test/libcxx/numerics/c.math/undef_min_max.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-W#warnings"
-#endif
-
 #define min THIS IS A NASTY MACRO!
 #define max THIS IS A NASTY MACRO!
 
 #include <cmath>
 
-#include "test_macros.h"
-
 int main(int, char**) { return 0; }

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.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
 
 // <tuple>
 
 // See llvm.org/PR20855
 
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wdangling-field"
-#endif
-
 #include <tuple>
 #include <string>
+
 #include "test_macros.h"
 
 template <class Tp>
 struct ConvertsTo {
   using RawTp = typename std::remove_cv< typename std::remove_reference<Tp>::type>::type;
 
   operator Tp() const {
     return static_cast<Tp>(value);

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp

 #include <utility>
 #include <tuple>
 #include <array>
 #include <memory>
 #include <cassert>
 
 #include "archetypes.h"
 
-#include "test_macros.h"
-
-// Clang warns about missing braces when initializing std::array.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wmissing-braces"
-#endif
-
 int main(int, char**)
 {
     using C = TestTypes::TestType;
     {
        using P = std::pair<int, C>;
        using T = std::tuple<int, C>;
        T t(42, C{42});
        P p(101, C{101});

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.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<class Iter, IntegralLike Size, Callable Generator>
 //   requires OutputIterator<Iter, Generator::result_type>
 //         && CopyConstructible<Generator>
 //   constexpr void      // constexpr after c++17
 //   generate_n(Iter first, Size n, Generator gen);
 
-#include "test_macros.h"
-
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(disable: 4244) // conversion from 'const double' to 'int', possible loss of data
-#endif
-
 #include <algorithm>
 #include <cassert>
 
 #include "test_iterators.h"
+#include "test_macros.h"
 #include "user_defined_integral.h"
 
+TEST_MSVC_DIAGNOSTIC_IGNORED(4244) // conversion from 'const double' to 'int', possible loss of data
+
 struct gen_test
 {
     TEST_CONSTEXPR int operator()() const {return 2;}
 };
 
 
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool test_constexpr() {

libcxx/test/std/containers/sequences/array/array.tuple/get.fail.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>
 
 // template <size_t I, class T, size_t N> T& get(array<T, N>& a);
 
 // Prevent -Warray-bounds from issuing a diagnostic when testing with clang verify.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Warray-bounds"
-#endif
+// ADDITIONAL_COMPILE_FLAGS: -Wno-array-bounds
 
 #include <array>
 #include <cassert>
 
+#include "test_macros.h"
+
 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)"}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.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>
 
 // tuple_element<I, array<T, N> >::type
 
-// Prevent -Warray-bounds from issuing a diagnostic when testing with clang verify.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Warray-bounds"
-#endif
-
 #include <array>
 #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)"}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

 struct Der : B1, B2 { int z; };
 
 // Initialize a vector with a different value type.
 void test_ctor_with_different_value_type() {
   {
     // Make sure initialization is performed with each element value, not with
     // a memory blob.
     float array[3] = {0.0f, 1.0f, 2.0f};
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(push)
-    #pragma warning(disable: 4244) // conversion from 'float' to 'int', possible loss of data
-#endif // TEST_COMPILER_MSVC
+    TEST_DIAGNOSTIC_PUSH
+    TEST_MSVC_DIAGNOSTIC_IGNORED(4244) // conversion from 'float' to 'int', possible loss of data
     std::vector<int> v(array, array + 3);
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(pop)
-#endif // TEST_COMPILER_MSVC
+    TEST_DIAGNOSTIC_POP
     assert(v[0] == 0);
     assert(v[1] == 1);
     assert(v[2] == 2);
   }
   {
     Der z;
     Der *array[1] = { &z };
     // Though the types Der* and B2* are very similar, initialization still cannot

libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp

 template <class T>
 std::false_type has_abs_imp(...);
 
 template <class T>
 struct has_abs : decltype(has_abs_imp<T>(0)) {};
 
 void test_abs()
 {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wabsolute-value"
-#endif
+  TEST_DIAGNOSTIC_PUSH
+  TEST_CLANG_DIAGNOSTIC_IGNORED("-Wabsolute-value")
+
   static_assert((std::is_same<decltype(abs((float)0)), float>::value), "");
   static_assert((std::is_same<decltype(abs((double)0)), double>::value), "");
   static_assert(
       (std::is_same<decltype(abs((long double)0)), long double>::value), "");
   static_assert((std::is_same<decltype(abs((int)0)), int>::value), "");
   static_assert((std::is_same<decltype(abs((long)0)), long>::value), "");
   static_assert((std::is_same<decltype(abs((long long)0)), long long>::value),
                 "");
   static_assert((std::is_same<decltype(abs((unsigned char)0)), int>::value),
                 "");
   static_assert((std::is_same<decltype(abs((unsigned short)0)), int>::value),
                 "");
 
   static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value),
                 "");
 
   static_assert(!has_abs<unsigned>::value, "");
   static_assert(!has_abs<unsigned long>::value, "");
   static_assert(!has_abs<unsigned long long>::value, "");
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+  TEST_DIAGNOSTIC_POP
 
   assert(abs(-1.) == 1);
 }
 
 void test_acos()
 {
     static_assert((std::is_same<decltype(acos((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(acos((bool)0)), double>::value), "");

libcxx/test/std/depr/depr.c.headers/stdio_h.pass.cpp

 #endif
 
 #ifndef stdout
 #error stdout not defined
 #endif
 
 #include <cstdarg>
 
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic ignored "-Wformat-zero-length"
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // for tmpnam
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wformat-zero-length")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wformat-zero-length")
 
 int main(int, char**)
 {
     FILE* fp = 0;
     fpos_t fpos = fpos_t();
     size_t s = 0;
     char* cp = 0;
     char arr[] = {'a', 'b'};
     va_list va;
     ((void)fp); // Prevent unused warning
     ((void)fpos); // Prevent unused warning
     ((void)s); // Prevent unused warning
     ((void)cp); // Prevent unused warning
     ((void)arr); // Prevent unused warning
     ((void)va); // Prevent unused warning
     static_assert((std::is_same<decltype(remove("")), int>::value), "");
     static_assert((std::is_same<decltype(rename("","")), int>::value), "");
     static_assert((std::is_same<decltype(tmpfile()), FILE*>::value), "");
+    TEST_DIAGNOSTIC_PUSH
+    TEST_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
+    TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
     static_assert((std::is_same<decltype(tmpnam(cp)), char*>::value), "");
+    TEST_DIAGNOSTIC_POP
     static_assert((std::is_same<decltype(fclose(fp)), int>::value), "");
     static_assert((std::is_same<decltype(fflush(fp)), int>::value), "");
     static_assert((std::is_same<decltype(fopen("", "")), FILE*>::value), "");
     static_assert((std::is_same<decltype(freopen("", "", fp)), FILE*>::value), "");
     static_assert((std::is_same<decltype(setbuf(fp,cp)), void>::value), "");
     static_assert((std::is_same<decltype(vfprintf(fp,"",va)), int>::value), "");
     static_assert((std::is_same<decltype(fprintf(fp," ")), int>::value), "");
     static_assert((std::is_same<decltype(fscanf(fp,"")), int>::value), "");
int main(int, char**)
     static_assert((std::is_same<decltype(vsscanf("","",va)), int>::value), "");
     static_assert((std::is_same<decltype(fgetc(fp)), int>::value), "");
     static_assert((std::is_same<decltype(fgets(cp,0,fp)), char*>::value), "");
     static_assert((std::is_same<decltype(fputc(0,fp)), int>::value), "");
     static_assert((std::is_same<decltype(fputs("",fp)), int>::value), "");
     static_assert((std::is_same<decltype(getc(fp)), int>::value), "");
     static_assert((std::is_same<decltype(getchar()), int>::value), "");
 #if TEST_STD_VER < 14
+    TEST_DIAGNOSTIC_PUSH
+    TEST_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
+    TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
     static_assert((std::is_same<decltype(gets(cp)), char*>::value), "");
+    TEST_DIAGNOSTIC_POP
 #endif
     static_assert((std::is_same<decltype(putc(0,fp)), int>::value), "");
     static_assert((std::is_same<decltype(putchar(0)), int>::value), "");
     static_assert((std::is_same<decltype(puts("")), int>::value), "");
     static_assert((std::is_same<decltype(ungetc(0,fp)), int>::value), "");
     static_assert((std::is_same<decltype(fread((void*)0,0,0,fp)), size_t>::value), "");
     static_assert((std::is_same<decltype(fwrite((const void*)arr,1,0,fp)), size_t>::value), "");
 #ifndef TEST_HAS_NO_FGETPOS_FSETPOS

libcxx/test/std/depr/depr.c.headers/stdlib_h.pass.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 <stdlib.h>
 
 #include <stdlib.h>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-// As of 1/10/2015 clang emits a -Wnonnull warnings even if the warning occurs
-// in an unevaluated context. For this reason we manually suppress the warning.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wnonnull"
-#endif
-
 #ifdef abs
 #error abs is defined
 #endif
 
 #ifdef labs
 #error labs is defined
 #endif
 

 std::true_type has_abs_imp(int);
 template <class T>
 std::false_type has_abs_imp(...);
 
 template <class T>
 struct has_abs : decltype(has_abs_imp<T>(0)) {};
 
 void test_abs() {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wabsolute-value"
-#endif
+  TEST_DIAGNOSTIC_PUSH
+  TEST_CLANG_DIAGNOSTIC_IGNORED("-Wabsolute-value")
   static_assert((std::is_same<decltype(abs((float)0)), float>::value), "");
   static_assert((std::is_same<decltype(abs((double)0)), double>::value), "");
   static_assert(
       (std::is_same<decltype(abs((long double)0)), long double>::value), "");
   static_assert((std::is_same<decltype(abs((int)0)), int>::value), "");
   static_assert((std::is_same<decltype(abs((long)0)), long>::value), "");
   static_assert((std::is_same<decltype(abs((long long)0)), long long>::value),
                 "");
void test_abs() {
   static_assert((std::is_same<decltype(abs((char)0)), int>::value),
                 "");
 
   static_assert(!has_abs<unsigned>::value, "");
   static_assert(!has_abs<unsigned long>::value, "");
   static_assert(!has_abs<unsigned long long>::value, "");
   static_assert(!has_abs<size_t>::value, "");
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+  TEST_DIAGNOSTIC_POP
 
   assert(abs(-1.) == 1);
 }
 
 int main(int, char**)
 {
     size_t s = 0; ((void)s);
     div_t d; ((void)d);

libcxx/test/std/input.output/file.streams/c.files/cstdio.pass.cpp

 #endif
 
 #ifndef stdout
 #error stdout not defined
 #endif
 
 #include <cstdarg>
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wformat-zero-length"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wformat-zero-length")
 
 int main(int, char**)
 {
     std::FILE* fp = 0;
     std::fpos_t fpos = std::fpos_t();
     std::size_t s = 0;
     char* cp = 0;
     std::va_list va;
#endif
     static_assert((std::is_same<decltype(std::ferror(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::perror("")), void>::value), "");
 
     static_assert((std::is_same<decltype(std::fopen("", "")), std::FILE*>::value), "");
     static_assert((std::is_same<decltype(std::freopen("", "", fp)), std::FILE*>::value), "");
     static_assert((std::is_same<decltype(std::remove("")), int>::value), "");
     static_assert((std::is_same<decltype(std::rename("","")), int>::value), "");
     static_assert((std::is_same<decltype(std::tmpfile()), std::FILE*>::value), "");
+
+    // disable deprecated warnings from the C library
+    TEST_DIAGNOSTIC_PUSH
+    TEST_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
     static_assert((std::is_same<decltype(std::tmpnam(cp)), char*>::value), "");
+    TEST_DIAGNOSTIC_POP
 
     static_assert((std::is_same<decltype(std::getchar()), int>::value), "");
 #if TEST_STD_VER <= 11
-#   pragma GCC diagnostic push
-#   pragma GCC diagnostic ignored "-Wdeprecated-declarations" // disable the warning from the C library
+    TEST_DIAGNOSTIC_PUSH
+    // disable the warning from the C library
+    TEST_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
+    TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
     static_assert((std::is_same<decltype(std::gets(cp)), char*>::value), "");
-#   pragma GCC diagnostic pop
+    TEST_DIAGNOSTIC_POP
 #endif
     static_assert((std::is_same<decltype(std::scanf(" ")), int>::value), "");
     static_assert((std::is_same<decltype(std::vscanf(" ",va)), int>::value), "");
 
     static_assert((std::is_same<decltype(std::printf(" ")), int>::value), "");
     static_assert((std::is_same<decltype(std::putchar(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
     static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 // The filesystem specification explicitly allows for self-move on
 // the directory iterators. Turn off this warning so we can test it.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wself-move"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move")
 
 using namespace fs;
 
 TEST_SUITE(directory_iterator_move_assign_tests)
 
 TEST_CASE(test_assignment_signature)
 {
     using D = directory_iterator;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 // The filesystem specification explicitly allows for self-move on
 // the directory iterators. Turn off this warning so we can test it.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wself-move"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move")
 
 using namespace fs;
 
 TEST_SUITE(recursive_directory_iterator_move_assign_tests)
 
 recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

#endif
     res.access = extract_atime(st);
     res.write = extract_mtime(st);
     return res;
 }
 
 namespace {
 
 // In some configurations, the comparison is tautological and the test is valid.
-// We disable the warning so that we can actually test it regardless. Also, that
-// diagnostic is pretty new, so also don't fail if old clang does not support it
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunknown-warning-option"
-#pragma clang diagnostic ignored "-Wunknown-pragmas"
-#pragma clang diagnostic ignored "-Wtautological-constant-compare"
-#endif
+// We disable the warning so that we can actually test it regardless.
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wtautological-constant-compare")
 
 static const bool SupportsNegativeTimes = [] {
   using namespace std::chrono;
   std::error_code ec;
   TimeSpec old_write_time, new_write_time;
   { // WARNING: Do not assert in this scope.
     scoped_test_env env;
     const path file = env.create_file("file", 42);
else if (tp.time_since_epoch().count() < 0 && !SupportsNegativeTimes)
     return false;
   else if (tp == file_time_type::max() && !SupportsMaxTime)
     return false;
   else if (tp == file_time_type::min() && !SupportsMinTime)
     return false;
   return true;
 }
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
+TEST_DIAGNOSTIC_POP
 
 // Create a sub-second duration using the smallest period the filesystem supports.
 file_time_type::duration SubSec(long long val) {
   using SubSecT = file_time_type::duration;
   if (SupportsNanosecondRoundTrip) {
     return duration_cast<SubSecT>(NanoSec(val));
   } else {
     return duration_cast<SubSecT>(MicroSec(val));

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

 #include <array>
 #include <list>
 #include <initializer_list>
 #include <string_view>
 
 #include "test_macros.h"
 
 // Ignore warning about std::numeric_limits comparisons being tautological.
-#ifdef __GNUC__
-#pragma GCC diagnostic ignored "-Wtype-limits"
-#endif
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wtype-limits")
 
 struct short_container {
     uint16_t size() const { return 60000; } // not noexcept
 };
 
 template<typename C>
 void test_container(C& c)
 {

libcxx/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp

 // ostream_iterator& operator=(const T& value);
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-#if defined(TEST_COMPILER_CLANG)
-#pragma clang diagnostic ignored "-Wliteral-conversion"
-#endif
-
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(disable: 4244) // conversion from 'X' to 'Y', possible loss of data
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wliteral-conversion")
+TEST_MSVC_DIAGNOSTIC_IGNORED(4244) // conversion from 'X' to 'Y', possible loss of data
 
 int main(int, char**)
 {
     {
         std::ostringstream outf;
         std::ostream_iterator<int> i(outf);
         i = 2.4;
         assert(outf.str() == "2");

libcxx/test/std/language.support/support.runtime/cstdlib.pass.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 <cstdlib>
 
 #include <cstdlib>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-// As of 1/10/2015 clang emits a -Wnonnull warnings even if the warning occurs
-// in an unevaluated context. For this reason we manually suppress the warning.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wnonnull"
-#endif
-
 #ifndef EXIT_FAILURE
 #error EXIT_FAILURE not defined
 #endif
 
 #ifndef EXIT_SUCCESS
 #error EXIT_SUCCESS not defined
 #endif
 

 std::true_type has_abs_imp(int);
 template <class T>
 std::false_type has_abs_imp(...);
 
 template <class T>
 struct has_abs : decltype(has_abs_imp<T>(0)) {};
 
 void test_abs() {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wabsolute-value"
-#endif
+    TEST_DIAGNOSTIC_PUSH
+    TEST_CLANG_DIAGNOSTIC_IGNORED("-Wabsolute-value")
     static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
     static_assert(
         (std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::abs((int)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value),
                   "");
void test_abs() {
     static_assert((std::is_same<decltype(std::abs((char)0)), int>::value),
                   "");
 
     static_assert(!has_abs<unsigned>::value, "");
     static_assert(!has_abs<unsigned long>::value, "");
     static_assert(!has_abs<unsigned long long>::value, "");
     static_assert(!has_abs<size_t>::value, "");
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+    TEST_DIAGNOSTIC_POP
 
     assert(std::abs(-1.) == 1);
 }
 
 int main(int, char**)
 {
     std::size_t s = 0;
     ((void)s);

libcxx/test/std/language.support/support.types/nullptr_t.pass.cpp

 {
     T p = nullptr;
     assert(p == nullptr);
     assert(!(p != nullptr));
     assert(nullptr == p);
     assert(!(nullptr != p));
 }
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wnull-conversion"
-#endif
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wnull-conversion")
 void test_nullptr_conversions() {
     {
         bool b(nullptr);
         assert(!b);
     }
 }
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
+TEST_DIAGNOSTIC_POP
 
 
 int main(int, char**)
 {
     static_assert(sizeof(std::nullptr_t) == sizeof(void*),
                   "sizeof(std::nullptr_t) == sizeof(void*)");
 
     {

libcxx/test/std/library/description/conventions/expos.only.func/synth_three_way.pass.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
 
 // constexpr auto synth-three-way = ...;
 //   via std::tuple<T>(t) <=> std::tuple<U>(u), which exposes its behavior most directly
 
 #include "test_macros.h"
 
-#if defined(TEST_COMPILER_CLANG) || defined(TEST_COMPILER_GCC)
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#elif defined(TEST_COMPILER_MSVC)
-#pragma warning(disable: 4242 4244) // Various truncation warnings
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_MSVC_DIAGNOSTIC_IGNORED(4242 4244) // Various truncation warnings
 
 #include <cassert>
 #include <compare>
 #include <limits>  // quiet_NaN
 #include <tuple>
 #include <utility> // declval
 
 template <typename T, typename U = T>

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp

 //               ios_base::iostate& err, unsigned int& v) const;
 
 #include <limits>
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <sstream>
+
 #include "test_iterators.h"
 #include "test_macros.h"
 
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned
-#endif
+TEST_MSVC_DIAGNOSTIC_IGNORED(4146) // unary minus operator applied to unsigned type, result still unsigned
 
 typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/numerics/c.math/cmath.pass.cpp

 
 template <class T>
 struct has_abs : decltype(has_abs_imp<T>(0)) {};
 
 void test_abs()
 {
     // See also "abs.pass.cpp"
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wabsolute-value"
-#endif
+    TEST_DIAGNOSTIC_PUSH
+    TEST_CLANG_DIAGNOSTIC_IGNORED("-Wabsolute-value")
+
     static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::abs((int)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((unsigned short)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((signed char)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((short)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((char)0)), int>::value), "");
     static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), "");
 
     static_assert(!has_abs<unsigned>::value, "");
     static_assert(!has_abs<unsigned long>::value, "");
     static_assert(!has_abs<unsigned long long>::value, "");
     static_assert(!has_abs<size_t>::value, "");
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+
+    TEST_DIAGNOSTIC_POP
 
     assert(std::abs(-1.) == 1);
 }
 
 
 void test_acos()
 {
     static_assert((std::is_same<decltype(std::acos((float)0)), float>::value), "");

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp

test1()
     static_assert((LCE::increment == c), "");
     static_assert((LCE::modulus == m), "");
 #if TEST_STD_VER >= 11
     static_assert((LCE::min() == (c == 0u ? 1u: 0u)), "");
 #else
     assert((LCE::min() == (c == 0u ? 1u: 0u)));
 #endif
 
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(push)
-    #pragma warning(disable: 4310) // cast truncates constant value
-#endif // TEST_COMPILER_MSVC
+    TEST_DIAGNOSTIC_PUSH
+    TEST_MSVC_DIAGNOSTIC_IGNORED(4310) // cast truncates constant value
 
 #if TEST_STD_VER >= 11
     static_assert((LCE::max() == result_type(m - 1u)), "");
 #else
     assert((LCE::max() == result_type(m - 1u)));
 #endif
 
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(pop)
-#endif // TEST_COMPILER_MSVC
+    TEST_DIAGNOSTIC_POP
 
     static_assert((LCE::default_seed == 1), "");
     where(LCE::multiplier);
     where(LCE::increment);
     where(LCE::modulus);
     where(LCE::default_seed);
 }
 

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.value.bound.pass.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 #include "test_macros.h"
 
-#if defined(TEST_COMPILER_CLANG) || defined(TEST_COMPILER_GCC)
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#elif defined(TEST_COMPILER_MSVC)
-#pragma warning(disable: 4018 4389) // various "signed/unsigned mismatch"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_MSVC_DIAGNOSTIC_IGNORED(4018 4389) // various "signed/unsigned mismatch"
 
 // constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
 
 #include <ranges>
 #include <cassert>
 
 #include "types.h"
 

libcxx/test/std/ranges/range.factories/range.iota.view/end.pass.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 #include "test_macros.h"
 
-#if defined(TEST_COMPILER_CLANG) || defined(TEST_COMPILER_GCC)
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#elif defined(TEST_COMPILER_MSVC)
-#pragma warning(disable: 4018 4389) // various "signed/unsigned mismatch"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_MSVC_DIAGNOSTIC_IGNORED(4018 4389) // various "signed/unsigned mismatch"
 
 // constexpr auto end() const;
 // constexpr iterator end() const requires same_as<W, Bound>;
 
 #include <cassert>
 #include <ranges>
 #include <utility>
 

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/star.pass.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
 
 #include "test_macros.h"
 
-#if defined(TEST_COMPILER_CLANG) || defined(TEST_COMPILER_GCC)
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#elif defined(TEST_COMPILER_MSVC)
-#pragma warning(disable: 4018) // various "signed/unsigned mismatch"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_MSVC_DIAGNOSTIC_IGNORED(4018) // various "signed/unsigned mismatch"
 
 #include <ranges>
 #include <cassert>
 
 #include "../types.h"
 
 struct NotNoexceptCopy {
   using difference_type = int;

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/noncopyable_return_type.pass.cpp

 // <functional>
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 // Prevent warning on the `const NonCopyable()` function type.
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic ignored "-Wignored-qualifiers"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wignored-qualifiers")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wignored-qualifiers")
 
 struct NonCopyable {
     NonCopyable() = default;
     NonCopyable(NonCopyable&&) = delete;
     friend bool operator==(NonCopyable, NonCopyable) { return true; }
 };
 
 struct LargeLambda {

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

 #ifndef __cpp_lib_is_constant_evaluated
 #if TEST_HAS_BUILTIN(__builtin_is_constant_evaluated)
 # error __cpp_lib_is_constant_evaluated should be defined
 #endif
 #endif
 
 // Disable the tautological constant evaluation warnings for this test,
 // because it's explicitly testing those cases.
-#if TEST_HAS_WARNING("-Wconstant-evaluated") && defined(__clang__)
-#pragma clang diagnostic ignored "-Wconstant-evaluated"
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wconstant-evaluated")
+TEST_MSVC_DIAGNOSTIC_IGNORED(5063)
 
 template <bool> struct InTemplate {};
 
 int main(int, char**)
 {
-#ifdef __cpp_lib_is_constant_evaluated
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(push)
-    #pragma warning(disable: 5063) // 'std::is_constant_evaluated' always evaluates to true in manifestly constant-evaluated expressions
-#endif // TEST_COMPILER_MSVC
   // Test the signature
   {
     ASSERT_SAME_TYPE(decltype(std::is_constant_evaluated()), bool);
     ASSERT_NOEXCEPT(std::is_constant_evaluated());
     constexpr bool p = std::is_constant_evaluated();
     assert(p);
   }
   // Test the return value of the builtin for basic sanity only. It's the
   // compiler's job to test the builtin for correctness.
   {
     static_assert(std::is_constant_evaluated(), "");
     bool p = std::is_constant_evaluated();
     assert(!p);
     ASSERT_SAME_TYPE(InTemplate<std::is_constant_evaluated()>, InTemplate<true>);
     static int local_static = std::is_constant_evaluated() ? 42 : -1;
     assert(local_static == 42);
   }
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(pop)
-#endif // TEST_COMPILER_MSVC
-#endif // __cpp_lib_is_constant_evaluated
   return 0;
 }

libcxx/test/std/utilities/meta/meta.rel/is_convertible_fallback.pass.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
 
+// ADDITIONAL_COMPILE_FLAGS: -D _LIBCPP_USE_IS_CONVERTIBLE_FALLBACK
+
 // type_traits
 
 // is_convertible
 
 // Test the fallback implementation.
 
 // libc++ provides a fallback implementation of the compiler trait
 // `__is_convertible` with the same name when clang doesn't.
 // Because this test forces the use of the fallback even when clang provides
 // it causing a keyword incompatibility.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wkeyword-compat"
-#endif
-
-#define _LIBCPP_USE_IS_CONVERTIBLE_FALLBACK
-#include "is_convertible.pass.cpp"
 
 #include "test_macros.h"
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wkeyword-compat")
+
+#include "is_convertible.pass.cpp"

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_destructible
 
-// Prevent warning when testing the Abstract test type.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"
-#endif
-
 #include <type_traits>
 #include "test_macros.h"
 
 
 template <class T>
 void test_is_destructible()
 {
     static_assert( std::is_destructible<T>::value, "");

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_nothrow_destructible
 
-// Prevent warning when testing the Abstract test type.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"
-#endif
-
 #include <type_traits>
 #include "test_macros.h"
 
 template <class T>
 void test_is_nothrow_destructible()
 {
     static_assert( std::is_nothrow_destructible<T>::value, "");
     static_assert( std::is_nothrow_destructible<const T>::value, "");

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_trivially_destructible
 
-// Prevent warning when testing the Abstract test type.
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"
-#endif
-
 #include <type_traits>
 #include "test_macros.h"
 
 template <class T>
 void test_is_trivially_destructible()
 {
     static_assert( std::is_trivially_destructible<T>::value, "");
     static_assert( std::is_trivially_destructible<const T>::value, "");

libcxx/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp

 
 #include <bitset>
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 #include <stdexcept> // for 'invalid_argument'
 
 #include "test_macros.h"
 
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(disable: 6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
-#endif
+TEST_MSVC_DIAGNOSTIC_IGNORED(6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 
 template <std::size_t N>
 void test_char_pointer_ctor()
 {
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             std::bitset<N> v("xxx1010101010xxxx");

libcxx/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp

 
 #include <bitset>
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 #include <cstddef>
 
 #include "test_macros.h"
 
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(disable: 6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
-#endif
+TEST_MSVC_DIAGNOSTIC_IGNORED(6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 
 template <std::size_t N>
 void test_val_ctor()
 {
     {
         TEST_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
         assert(v.size() == N);
         std::size_t M = std::min<std::size_t>(v.size(), 64);

libcxx/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp

 #include <bitset>
 #include <cassert>
 #include <cstddef>
 #include <vector>
 
 #include "../bitset_test_cases.h"
 #include "test_macros.h"
 
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(disable: 6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
-#endif
+TEST_MSVC_DIAGNOSTIC_IGNORED(6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 
 template <std::size_t N>
 void test_reset_one() {
     std::vector<std::bitset<N> > const cases = get_test_cases<N>();
     for (std::size_t c = 0; c != cases.size(); ++c) {
         for (std::size_t i = 0; i != N; ++i) {
             std::bitset<N> v = cases[c];
             v.reset(i);

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

 // template<class... TTypes, class... UTypes>
 //   auto
 //   operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include "test_macros.h"
 
-#if defined(TEST_COMPILER_CLANG) || defined(TEST_COMPILER_GCC)
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#elif defined(TEST_COMPILER_MSVC)
-#pragma warning(disable: 4242 4244) // Various truncation warnings
-#endif
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
+TEST_MSVC_DIAGNOSTIC_IGNORED(4242 4244)
 
 #include <cassert>
 #include <compare>
 #include <limits>
 #include <tuple>
 #include <type_traits> // std::is_constant_evaluated
 
 // A custom three-way result type

libcxx/test/support/charconv_test_helpers.h

void test(T v, Ts... args)
         }
         else
         {
             r = to_chars(buf, buf + sizeof(buf), v, args...);
             assert(r.ec == std::errc{});
 
             r2 = from_chars(buf, r.ptr, x, args...);
 
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(push)
-    #pragma warning(disable: 4127) // conditional expression is constant
-#endif // TEST_COMPILER_MSVC
+            TEST_DIAGNOSTIC_PUSH
+            TEST_MSVC_DIAGNOSTIC_IGNORED(4127) // conditional expression is constant
+
             if (std::is_signed<T>::value && v < 0 && std::is_unsigned<X>::value)
             {
                 assert(x == 0xc);
                 assert(r2.ptr == buf);
                 assert(r2.ec == std::errc::invalid_argument);
             }
             else
             {
                 assert(x == 0xc);
                 assert(r2.ptr == r.ptr);
                 assert(r2.ec == std::errc::result_out_of_range);
             }
-#ifdef TEST_COMPILER_MSVC
-    #pragma warning(pop)
-#endif // TEST_COMPILER_MSVC
+
+            TEST_DIAGNOSTIC_POP
         }
     }
 
 private:
     char buf[100];
 };
 
 template <typename... T>

libcxx/test/support/count_new.h

 };
 
 #ifdef DISABLE_NEW_COUNT
   const bool MemCounter::disable_checking = true;
 #else
   const bool MemCounter::disable_checking = false;
 #endif
 
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(push)
-#pragma warning(disable: 4640) // '%s' construction of local static object is not thread safe (/Zc:threadSafeInit-)
-#endif // TEST_COMPILER_MSVC
+TEST_DIAGNOSTIC_PUSH
+TEST_MSVC_DIAGNOSTIC_IGNORED(4640) // '%s' construction of local static object is not thread safe (/Zc:threadSafeInit-)
 inline MemCounter* getGlobalMemCounter() {
   static MemCounter counter((MemCounter::MemCounterCtorArg_()));
   return &counter;
 }
-#ifdef TEST_COMPILER_MSVC
-#pragma warning(pop)
-#endif
+TEST_DIAGNOSTIC_POP
 
 MemCounter &globalMemCounter = *getGlobalMemCounter();
 
 #ifndef DISABLE_NEW_COUNT
 void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
 {
     getGlobalMemCounter()->newCalled(s);
     void* ret = std::malloc(s);

libcxx/test/support/test_macros.h

 #   include <__config>
 #   define TEST_IMP_INCLUDED_HEADER
 # endif
 #endif
 #ifndef TEST_IMP_INCLUDED_HEADER
 #include <ciso646>
 #endif
 
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wvariadic-macros"
-#endif
-
 #define TEST_STRINGIZE_IMPL(x) #x
 #define TEST_STRINGIZE(x) TEST_STRINGIZE_IMPL(x)
 
 #define TEST_CONCAT1(X, Y) X##Y
 #define TEST_CONCAT(X, Y) TEST_CONCAT1(X, Y)
 
 #ifdef __has_feature
 #define TEST_HAS_FEATURE(X) __has_feature(X)

 #if defined(_LIBCPP_HAS_NO_FGETPOS_FSETPOS)
 #  define TEST_HAS_NO_FGETPOS_FSETPOS
 #endif
 
 #if defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 #  define TEST_HAS_NO_INCOMPLETE_RANGES
 #endif
 
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
+#if defined(TEST_COMPILER_CLANG)
+#  define TEST_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+#  define TEST_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#  define TEST_CLANG_DIAGNOSTIC_IGNORED(str) _Pragma(TEST_STRINGIZE(clang diagnostic ignored str))
+#  define TEST_GCC_DIAGNOSTIC_IGNORED(str)
+#  define TEST_MSVC_DIAGNOSTIC_IGNORED(num)
+#elif defined(TEST_COMPILER_GCC)
+#  define TEST_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+#  define TEST_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#  define TEST_CLANG_DIAGNOSTIC_IGNORED(str)
+#  define TEST_GCC_DIAGNOSTIC_IGNORED(str) _Pragma(TEST_STRINGIZE(GCC diagnostic ignored str))
+#  define TEST_MSVC_DIAGNOSTIC_IGNORED(num)
+#elif defined(TEST_COMPILER_MSVC)
+#  define TEST_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+#  define TEST_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#  define TEST_CLANG_DIAGNOSTIC_IGNORED(str)
+#  define TEST_GCC_DIAGNOSTIC_IGNORED(str)
+#  define TEST_MSVC_DIAGNOSTIC_IGNORED(num) _Pragma(TEST_STRINGIZE(warning(disable: num)))
+#else
+#  define TEST_DIAGNOSTIC_PUSH
+#  define TEST_DIAGNOSTIC_POP
+#  define TEST_CLANG_DIAGNOSTIC_IGNORED(str)
+#  define TEST_GCC_DIAGNOSTIC_IGNORED(str)
+#  define TEST_MSVC_DIAGNOSTIC_IGNORED(num)
 #endif
 
 #endif // SUPPORT_TEST_MACROS_HPP

libcxx/test/support/unique_ptr_test_helper.h

#define INCOMPLETE_TEST_EPILOGUE()                                             \
   IncompleteType* getNewIncompleteArray(int size) {                            \
     return new IncompleteType[size];                                           \
   }                                                                            \
                                                                                \
   template <class IncompleteT, class Del>                                      \
   StoresIncomplete<IncompleteT, Del>::~StoresIncomplete() {}
 #
 
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wvariadic-macros"
-#endif
-
 #if TEST_STD_VER >= 11
 #define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                 \
   static int is_incomplete_test() { __VA_ARGS__ return 0; }                    \
   INCOMPLETE_TEST_EPILOGUE()
 #else
 #define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                 \
   static int is_incomplete_test() { return 0; }                                \
   INCOMPLETE_TEST_EPILOGUE()
 #endif
 
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-
 #endif // TEST_SUPPORT_UNIQUE_PTR_TEST_HELPER_H