[libcxx][test] compiler options are non-portable

[CaseyCarter]

Summary

... it's easier to suppress warnings internally, where we can detect the compiler.

• Rename TEST_COMPILER_C1XX to TEST_COMPILER_MSVC
• Rename all TEST_WORKAROUND_C1XX_<meow> to TEST_WORKAROUND_MSVC_<meow>

[ldionne]

Could we include "test_macros.h" and use TEST_COMPILER_CLANG/TEST_COMPILER_C1XX instead? (By the way, it seems to me that TEST_COMPILER_C1XX should be renamed to something more sensible).

[CaseyCarter]

Address review comments.

[CaseyCarter]

In D117422#3248686, @ldionne wrote:

Could we include "test_macros.h" and use TEST_COMPILER_CLANG/TEST_COMPILER_C1XX instead?

Done.

(By the way, it seems to me that TEST_COMPILER_C1XX should be renamed to something more sensible).

Renamed "C1XX" to "MSVC" everywhere except for one comment about "Microsoft's C1XX front end" where the precision seems significant.

libcxx/include/__support/win32/limits_msvc_win32.h

 // -*- C++ -*-
 //===-----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
 #define _LIBCPP_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
 
 #if !defined(_LIBCPP_MSVCRT)
 #error "This header complements the Microsoft C Runtime library, and should not be included otherwise."
 #endif
 #if defined(__clang__)
-#error "This header should only be included when using Microsofts C1XX frontend"
+#error "This header should only be included when using Microsoft's C1XX frontend"
 #endif
 
 #include <float.h> // limit constants
 #include <limits.h> // CHAR_BIT
 #include <math.h> // HUGE_VAL
 #include <ymath.h> // internal MSVC header providing the needed functionality
 
 #define __CHAR_BIT__       CHAR_BIT

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp

 // 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_C1XX
+#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 "user_defined_integral.h"

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_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(push)
     #pragma warning(disable: 4244) // conversion from 'float' to 'int', possible loss of data
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
     std::vector<int> v(array, array + 3);
-#ifdef TEST_COMPILER_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(pop)
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
     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/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 #if defined(TEST_COMPILER_CLANG)
 #pragma clang diagnostic ignored "-Wliteral-conversion"
 #endif
 
-#ifdef TEST_COMPILER_C1XX
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(disable: 4244) // conversion from 'X' to 'Y', possible loss of data
 #endif
 
 int main(int, char**)
 {
     {
         std::ostringstream outf;
         std::ostream_iterator<int> i(outf);

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, libcpp-no-concepts
-// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
 
 // 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
+
 #include <cassert>
 #include <compare>
 #include <limits>  // quiet_NaN
 #include <tuple>
 #include <utility> // declval
 
-#include "test_macros.h"
-
 template <typename T, typename U = T>
 concept can_synth_three_way = requires(T t, U u) { std::tuple<T>(t) <=> std::tuple<U>(u); };
 
 template <typename T, typename U>
 constexpr auto synth_three_way(const T& t, const U& u) {
   return std::tuple<T>(t) <=> std::tuple<U>(u);
 }
 

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

 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <sstream>
 #include "test_iterators.h"
 #include "test_macros.h"
 
-#ifdef TEST_COMPILER_C1XX
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned
 #endif
 
 typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
 
 class my_facet
     : public F
 {

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_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(push)
     #pragma warning(disable: 4310) // cast truncates constant value
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
 
 #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_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(pop)
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
 
     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-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
+#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
 
 // constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
 
 #include <ranges>
 #include <cassert>
 
-#include "test_macros.h"
 #include "types.h"
 
 constexpr bool test() {
   {
     std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(0), SomeInt(10));
     assert(std::ranges::next(io.begin(), 10) == io.end());
   }
 

 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }
-

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-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
+#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
 
 // constexpr auto end() const;
 // constexpr iterator end() const requires same_as<W, Bound>;
 
 #include <ranges>
 #include <cassert>
 
-#include "test_macros.h"
 #include "types.h"
 
 template<class T, class U>
 constexpr void testType(U u) {
   {
     std::ranges::iota_view<T, U> io(T(0), u);
     assert(std::ranges::next(io.begin(), 10) == io.end());
   }

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-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
-
 // 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
+
 #include <ranges>
 #include <cassert>
 
-#include "test_macros.h"
 #include "../types.h"
 
 struct NotNoexceptCopy {
   using difference_type = int;
 
   int value_;
   constexpr explicit NotNoexceptCopy(int value = 0) : value_(value) {}
   NotNoexceptCopy(const NotNoexceptCopy&) noexcept(false) = default;

libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

 #ifndef TEST_HAS_NO_EXCEPTIONS
     struct ThrowsOnCopy {
       ThrowsOnCopy(ThrowsOnCopy const&) {
         throw 42;
       }
       ThrowsOnCopy() = default;
       bool operator()() const {
         assert(false);
-#if defined(TEST_COMPILER_C1XX)
+#ifdef TEST_COMPILER_MSVC
         __assume(0);
 #else
         __builtin_unreachable();
 #endif
       }
     };
     {
         ThrowsOnCopy cp;

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

 #pragma clang diagnostic ignored "-Wconstant-evaluated"
 #endif
 
 template <bool> struct InTemplate {};
 
 int main(int, char**)
 {
 #ifdef __cpp_lib_is_constant_evaluated
-#ifdef TEST_COMPILER_C1XX
+#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_C1XX
+#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_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(pop)
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
 #endif // __cpp_lib_is_constant_evaluated
   return 0;
 }

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"
 
-#if defined(TEST_COMPILER_C1XX)
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(disable: 6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 #endif
 
 template <std::size_t N>
 void test_char_pointer_ctor()
 {
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS

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"
 
-#if defined(TEST_COMPILER_C1XX)
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(disable: 6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 #endif
 
 template <std::size_t N>
 void test_val_ctor()
 {
     {
         TEST_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);

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"
 
-#if defined(TEST_COMPILER_C1XX)
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(disable: 6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 #endif
 
 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) {

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

 
 // template <class... Types> class tuple;
 
 // template<class... TTypes, class... UTypes>
 //   auto
 //   operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts
-// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
+
+#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
 
 #include <cassert>
 #include <compare>
 #include <limits>
 #include <tuple>
 #include <type_traits> // std::is_constant_evaluated
 
-#include "test_macros.h"
-
 // A custom three-way result type
 struct CustomEquality {
   friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; }
   friend constexpr bool operator<(const CustomEquality&, int) noexcept { return false; }
   friend constexpr bool operator<(int, const CustomEquality&) noexcept { return false; }
 };
 
 constexpr bool test() {

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp

return v2.index() == v.index() &&
          v2.index() == Idx &&
          std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
 void test_constexpr_copy_ctor() {
   // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
 #if TEST_STD_VER > 17
   using V = std::variant<long, void*, const int>;
-#ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
   static_assert(std::is_trivially_copy_constructible<V>::value, "");
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(!std::is_copy_assignable<V>::value, "");
   static_assert(!std::is_move_assignable<V>::value, "");
-#else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
-#endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
   static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
   static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
 #endif // > C++17
 }
 
 int main(int, char**) {
   test_copy_ctor_basic();

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp

return v2.index() == v.index() &&
          v2.index() == Idx &&
         std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
 void test_constexpr_move_ctor() {
   // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
 #if TEST_STD_VER > 17
   using V = std::variant<long, void*, const int>;
-#ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
   static_assert(std::is_trivially_copy_constructible<V>::value, "");
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(!std::is_copy_assignable<V>::value, "");
   static_assert(!std::is_move_assignable<V>::value, "");
-#else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
-#endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
   static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
   static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
 #endif // > C++17
 }
 
 int main(int, char**) {
   test_move_ctor_basic();
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
   test_constexpr_move_ctor();
 
   return 0;
 }

libcxx/test/support/archetypes.h

 #if TEST_STD_VER >= 11
 
 namespace ArchetypeBases {
 
 template <bool, class T>
 struct DepType : T {};
 
 struct NullBase {
-#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#ifndef TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
 protected:
-#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#endif // !TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
   NullBase() = default;
   NullBase(NullBase const&) = default;
   NullBase& operator=(NullBase const&) = default;
   NullBase(NullBase &&) = default;
   NullBase& operator=(NullBase &&) = default;
 };
 
 template <class Derived, bool Explicit = false>
struct TestBase {
     explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
         ++alive; ++constructed; ++value_constructed;
     }
     TestBase& operator=(int xvalue) noexcept {
       value = xvalue;
       ++assigned; ++value_assigned;
       return *this;
     }
-#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#ifndef TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
 protected:
-#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#endif // !TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
     ~TestBase() {
       assert(value != -999); assert(alive > 0);
       --alive; ++destroyed; value = -999;
     }
     explicit TestBase(TestBase const& o) noexcept : value(o.value) {
         assert(o.value != -1); assert(o.value != -999);
         ++alive; ++constructed; ++copy_constructed;
     }
struct ValueBase {
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
         value = xvalue;
         return *this;
     }
     //~ValueBase() { assert(value != -999); value = -999; }
     int value;
-#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#ifndef TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
 protected:
-#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#endif // !TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
     constexpr static int check_value(int const& val) {
 #if TEST_STD_VER < 14
       return val == -1 || val == 999 ? (TEST_THROW(42), 0) : val;
 #else
       assert(val != -1); assert(val != 999);
       return val;
 #endif
     }
struct TrivialValueBase {
     explicit constexpr TrivialValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr TrivialValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     int value;
-#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#ifndef TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
 protected:
-#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
+#endif // !TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
     constexpr TrivialValueBase() noexcept : value(0) {}
 };
 
 }
 
 //============================================================================//
 // Trivial Implicit Test Types
 namespace ImplicitTypes {

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_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(push)
     #pragma warning(disable: 4127) // conditional expression is constant
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
             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_C1XX
+#ifdef TEST_COMPILER_MSVC
     #pragma warning(pop)
-#endif // TEST_COMPILER_C1XX
+#endif // TEST_COMPILER_MSVC
         }
     }
 
 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 _MSC_VER
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(push)
 #pragma warning(disable: 4640) // '%s' construction of local static object is not thread safe (/Zc:threadSafeInit-)
-#endif // _MSC_VER
+#endif // TEST_COMPILER_MSVC
 inline MemCounter* getGlobalMemCounter() {
   static MemCounter counter((MemCounter::MemCounterCtorArg_()));
   return &counter;
 }
-#ifdef _MSC_VER
+#ifdef TEST_COMPILER_MSVC
 #pragma warning(pop)
 #endif
 
 MemCounter &globalMemCounter = *getGlobalMemCounter();
 
 #ifndef DISABLE_NEW_COUNT
 void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
 {

libcxx/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.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
 
-// Verify TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE.
+// Verify TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE.
 
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
 struct S {
   S(S const&) = default;
   S(S&&) = default;
   S& operator=(S const&) = delete;
   S& operator=(S&&) = delete;
 };
 
 int main(int, char**) {
-#if defined(TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE)
+#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(!std::is_trivially_copyable<S>::value, "");
 #else
   static_assert(std::is_trivially_copyable<S>::value, "");
 #endif
 
   return 0;
 }

libcxx/test/support/test.workarounds/c1xx_broken_za_ctor_check.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
 
-// Verify TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK.
+// Verify TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK.
 
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
 struct X {
     X(int) {}
 
     X(X&&) = default;
     X& operator=(X&&) = default;
 
 private:
     X(const X&) = default;
     X& operator=(const X&) = default;
 };
 
 void PushFront(X&&) {}
 
 template<class T = int>
 auto test(int) -> decltype(PushFront(std::declval<T>()), std::true_type{});
 auto test(long) -> std::false_type;
 
 int main(int, char**) {
-#if defined(TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK)
+#ifdef TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK
     static_assert(!decltype(test(0))::value, "");
 #else
     static_assert(decltype(test(0))::value, "");
 #endif
 
   return 0;
 }

libcxx/test/support/test_macros.h

 #if defined(__EDG__)
 # define TEST_COMPILER_EDG
 #elif defined(__clang__)
 # define TEST_COMPILER_CLANG
 # if defined(__apple_build_version__)
 #  define TEST_COMPILER_APPLE_CLANG
 # endif
 #elif defined(_MSC_VER)
-# define TEST_COMPILER_C1XX
+# define TEST_COMPILER_MSVC
 #elif defined(__GNUC__)
 # define TEST_COMPILER_GCC
 #endif
 
 #if defined(__apple_build_version__)
 #define TEST_APPLE_CLANG_VER (__clang_major__ * 100) + __clang_minor__
 #elif defined(__clang_major__)
 #define TEST_CLANG_VER (__clang_major__ * 100) + __clang_minor__

libcxx/test/support/test_workarounds.h

 #define SUPPORT_TEST_WORKAROUNDS_H
 
 #include "test_macros.h"
 
 #if defined(TEST_COMPILER_EDG)
 # define TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR // VSO-424280
 #endif
 
-#if defined(TEST_COMPILER_C1XX)
+#ifdef TEST_COMPILER_MSVC
 # if _MSC_VER < 1927
-#  define TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE // VSO-117743
+#  define TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE // VSO-117743
 # endif
 # ifndef _MSC_EXTENSIONS
-#  define TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK // VSO-119998
+#  define TEST_WORKAROUND_MSVC_BROKEN_ZA_CTOR_CHECK // VSO-119998
 # endif
 #endif
 
 #endif // SUPPORT_TEST_WORKAROUNDS_H