[libcxx] [test] Work around MSVC's non-Standard ABI for enums.

[STL_MSFT]

Summary

Work around MSVC's non-Standard ABI for enums.

So this is definitely an MSVC bug, but one that's baked into our layout behavior, so even Clang has to enable it unconditionally when targeting Windows.

In underlying_type.pass.cpp, I'm simply marking the affected static_asserts as libcxx-specific (this probably won't be sufficient when you try to get the Clang/LLVM/libcxx stack running on Windows). In make_signed.pass.cpp and make_unsigned.pass.cpp, I'm giving the enum an explicitly specified underlying type, so the tests below can remain unaffected.

If there's a better way to do this, please let me know. I could give underlying_type.pass.cpp an explicitly specified underlying type, but I'm unsure as to how your C++03 tests work.

[EricWF]

in underlying_type.pass.cpp, I'm simply marking the affected static_asserts as libcxx-specific (this probably won't be sufficient when you try to get the Clang/LLVM/libcxx stack running on Windows). In make_signed.pass.cpp and make_unsigned.pass.cpp, I'm giving the enum an explicitly specified underlying type, so the tests below can remain unaffected.

I think it would be better to check if we are on Windows, and test for the respected result accordingly.

[EricWF]

I'll check in this fix with the suggested change.

[EricWF]

r276589.

test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp

 
 enum E { V = INT_MIN };
 enum F { W = UINT_MAX };
 
 int main()
 {
     static_assert((std::is_same<std::underlying_type<E>::type, int>::value),
                   "E has the wrong underlying type");
-    static_assert((std::is_same<std::underlying_type<F>::type, unsigned>::value),
-                  "F has the wrong underlying type");
+    LIBCPP_STATIC_ASSERT((std::is_same<std::underlying_type<F>::type, unsigned>::value),
+                  "F has the wrong underlying type"); // MSVC's ABI doesn't follow the Standard
 
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::underlying_type_t<E>, int>::value), "");
-    static_assert((std::is_same<std::underlying_type_t<F>, unsigned>::value), "");
+    LIBCPP_STATIC_ASSERT((std::is_same<std::underlying_type_t<F>, unsigned>::value), ""); // MSVC's ABI
 #endif
 
 #if TEST_STD_VER >= 11
     enum G : char { };
 
     static_assert((std::is_same<std::underlying_type<G>::type, char>::value),
                   "G has the wrong underlying type");
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
 #endif
 #endif // TEST_STD_VER >= 11
 }

test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // make_signed
 
 #include <type_traits>
 
+#include "test_macros.h"
+
 enum Enum {zero, one_};
 
+#if TEST_STD_VER >= 11
+enum BigEnum : unsigned long long // MSVC's ABI doesn't follow the Standard
+#else
 enum BigEnum
+#endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
 #if !defined(_LIBCPP_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
 enum HugeEnum : __uint128_t
 {

test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // make_unsigned
 
 #include <type_traits>
 
+#include "test_macros.h"
+
 enum Enum {zero, one_};
 
+#if TEST_STD_VER >= 11
+enum BigEnum : unsigned long long // MSVC's ABI doesn't follow the Standard
+#else
 enum BigEnum
+#endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
 #if !defined(_LIBCPP_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
 enum HugeEnum : __int128_t
 {