1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef SUPPORT_TEST_MACROS_HPP 11 #define SUPPORT_TEST_MACROS_HPP 12 13 #ifdef __has_include 14 # if __has_include(<version>) 15 # include <version> 16 # else 17 # include <ciso646> 18 # endif 19 #else 20 # include <ciso646> 21 #endif 22 23 #define TEST_STRINGIZE_IMPL(...) #__VA_ARGS__ 24 #define TEST_STRINGIZE(...) TEST_STRINGIZE_IMPL(__VA_ARGS__) 25 26 #define TEST_CONCAT1(X, Y) X##Y 27 #define TEST_CONCAT(X, Y) TEST_CONCAT1(X, Y) 28 29 #ifdef __has_feature 30 #define TEST_HAS_FEATURE(X) __has_feature(X) 31 #else 32 #define TEST_HAS_FEATURE(X) 0 33 #endif 34 35 #ifndef __has_include 36 #define __has_include(...) 0 37 #endif 38 39 #ifdef __has_extension 40 #define TEST_HAS_EXTENSION(X) __has_extension(X) 41 #else 42 #define TEST_HAS_EXTENSION(X) 0 43 #endif 44 45 #ifdef __has_warning 46 #define TEST_HAS_WARNING(X) __has_warning(X) 47 #else 48 #define TEST_HAS_WARNING(X) 0 49 #endif 50 51 #ifdef __has_builtin 52 #define TEST_HAS_BUILTIN(X) __has_builtin(X) 53 #else 54 #define TEST_HAS_BUILTIN(X) 0 55 #endif 56 #ifdef __is_identifier 57 // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by 58 // the compiler and '1' otherwise. 59 #define TEST_HAS_BUILTIN_IDENTIFIER(X) !__is_identifier(X) 60 #else 61 #define TEST_HAS_BUILTIN_IDENTIFIER(X) 0 62 #endif 63 64 #if defined(__EDG__) 65 # define TEST_COMPILER_EDG 66 #elif defined(__clang__) 67 # define TEST_COMPILER_CLANG 68 # if defined(__apple_build_version__) 69 # define TEST_COMPILER_APPLE_CLANG 70 # endif 71 #elif defined(_MSC_VER) 72 # define TEST_COMPILER_MSVC 73 #elif defined(__GNUC__) 74 # define TEST_COMPILER_GCC 75 #endif 76 77 #if defined(__apple_build_version__) 78 // Given AppleClang XX.Y.Z, TEST_APPLE_CLANG_VER is XXYZ (e.g. AppleClang 14.0.3 => 1403) 79 #define TEST_APPLE_CLANG_VER (__apple_build_version__ / 10000) 80 #elif defined(__clang_major__) 81 #define TEST_CLANG_VER (__clang_major__ * 100) + __clang_minor__ 82 #elif defined(__GNUC__) 83 // Given GCC XX.YY.ZZ, TEST_GCC_VER is XXYYZZ 84 #define TEST_GCC_VER ((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__) 85 #endif 86 87 /* Make a nice name for the standard version */ 88 #ifndef TEST_STD_VER 89 #if __cplusplus <= 199711L 90 # define TEST_STD_VER 3 91 #elif __cplusplus <= 201103L 92 # define TEST_STD_VER 11 93 #elif __cplusplus <= 201402L 94 # define TEST_STD_VER 14 95 #elif __cplusplus <= 201703L 96 # define TEST_STD_VER 17 97 #elif __cplusplus <= 202002L 98 # define TEST_STD_VER 20 99 #elif __cplusplus <= 202302L 100 # define TEST_STD_VER 23 101 #else 102 # define TEST_STD_VER 99 // greater than current standard 103 // This is deliberately different than _LIBCPP_STD_VER to discourage matching them up. 104 #endif 105 #endif 106 107 // Attempt to deduce the GLIBC version 108 #if (defined(__has_include) && __has_include(<features.h>)) || \ 109 defined(__linux__) 110 #include <features.h> 111 #if defined(__GLIBC_PREREQ) 112 #define TEST_HAS_GLIBC 113 #define TEST_GLIBC_PREREQ(major, minor) __GLIBC_PREREQ(major, minor) 114 #endif 115 #endif 116 117 #if TEST_STD_VER >= 11 118 # define TEST_ALIGNOF(...) alignof(__VA_ARGS__) 119 # define TEST_ALIGNAS(...) alignas(__VA_ARGS__) 120 # define TEST_CONSTEXPR constexpr 121 # define TEST_NOEXCEPT noexcept 122 # define TEST_NOEXCEPT_FALSE noexcept(false) 123 # define TEST_NOEXCEPT_COND(...) noexcept(__VA_ARGS__) 124 #else 125 # if defined(TEST_COMPILER_CLANG) 126 # define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__) 127 # else 128 # define TEST_ALIGNOF(...) __alignof(__VA_ARGS__) 129 # endif 130 # define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__))) 131 # define TEST_CONSTEXPR 132 # define TEST_NOEXCEPT throw() 133 # define TEST_NOEXCEPT_FALSE 134 # define TEST_NOEXCEPT_COND(...) 135 #endif 136 137 #if TEST_STD_VER >= 11 138 # define TEST_THROW_SPEC(...) 139 #else 140 # define TEST_THROW_SPEC(...) throw(__VA_ARGS__) 141 #endif 142 143 #if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L 144 # define TEST_IS_CONSTANT_EVALUATED std::is_constant_evaluated() 145 #elif TEST_HAS_BUILTIN(__builtin_is_constant_evaluated) 146 # define TEST_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated() 147 #else 148 # define TEST_IS_CONSTANT_EVALUATED false 149 #endif 150 151 #if TEST_STD_VER >= 23 152 # define TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED true 153 #else 154 # define TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED (!TEST_IS_CONSTANT_EVALUATED) 155 #endif 156 157 #if TEST_STD_VER >= 20 158 # define TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED true 159 #else 160 # define TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED (!TEST_IS_CONSTANT_EVALUATED) 161 #endif 162 163 #if TEST_STD_VER >= 14 164 # define TEST_CONSTEXPR_CXX14 constexpr 165 #else 166 # define TEST_CONSTEXPR_CXX14 167 #endif 168 169 #if TEST_STD_VER >= 17 170 # define TEST_CONSTEXPR_CXX17 constexpr 171 #else 172 # define TEST_CONSTEXPR_CXX17 173 #endif 174 175 #if TEST_STD_VER >= 20 176 # define TEST_CONSTEXPR_CXX20 constexpr 177 #else 178 # define TEST_CONSTEXPR_CXX20 179 #endif 180 181 #if TEST_STD_VER >= 23 182 # define TEST_CONSTEXPR_CXX23 constexpr 183 #else 184 # define TEST_CONSTEXPR_CXX23 185 #endif 186 187 #if TEST_STD_VER >= 26 188 # define TEST_CONSTEXPR_CXX26 constexpr 189 #else 190 # define TEST_CONSTEXPR_CXX26 191 #endif 192 193 #define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__)) 194 195 #if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \ 196 && !defined(__GXX_RTTI) 197 #define TEST_HAS_NO_RTTI 198 #endif 199 200 #if !defined(TEST_HAS_NO_RTTI) 201 # define RTTI_ASSERT(X) assert(X) 202 #else 203 # define RTTI_ASSERT(X) 204 #endif 205 206 #if !TEST_HAS_FEATURE(cxx_exceptions) && !defined(__cpp_exceptions) \ 207 && !defined(__EXCEPTIONS) 208 #define TEST_HAS_NO_EXCEPTIONS 209 #endif 210 211 #if TEST_HAS_FEATURE(address_sanitizer) || TEST_HAS_FEATURE(hwaddress_sanitizer) || \ 212 TEST_HAS_FEATURE(memory_sanitizer) || TEST_HAS_FEATURE(thread_sanitizer) 213 #define TEST_HAS_SANITIZERS 214 #define TEST_IS_EXECUTED_IN_A_SLOW_ENVIRONMENT 215 #endif 216 217 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 218 # ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION 219 # define TEST_HAS_NO_ALIGNED_ALLOCATION 220 # endif 221 #elif defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_ALIGNED_ALLOCATION 222 # define TEST_HAS_NO_ALIGNED_ALLOCATION 223 #elif TEST_STD_VER < 17 && (!defined(__cpp_aligned_new) || __cpp_aligned_new < 201606L) 224 # define TEST_HAS_NO_ALIGNED_ALLOCATION 225 #endif 226 227 #if TEST_STD_VER > 17 228 # define TEST_CONSTINIT constinit 229 #elif __has_cpp_attribute(clang::require_constant_initialization) 230 # define TEST_CONSTINIT [[clang::require_constant_initialization]] 231 #else 232 # define TEST_CONSTINIT 233 #endif 234 235 #if TEST_STD_VER < 11 236 #define ASSERT_NOEXCEPT(...) 237 #define ASSERT_NOT_NOEXCEPT(...) 238 #else 239 #define ASSERT_NOEXCEPT(...) \ 240 static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept") 241 242 #define ASSERT_NOT_NOEXCEPT(...) \ 243 static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept") 244 #endif 245 246 /* Macros for testing libc++ specific behavior and extensions */ 247 #if defined(_LIBCPP_VERSION) 248 #define LIBCPP_ASSERT(...) assert(__VA_ARGS__) 249 #define LIBCPP_STATIC_ASSERT(...) static_assert(__VA_ARGS__) 250 #define LIBCPP_ASSERT_NOEXCEPT(...) ASSERT_NOEXCEPT(__VA_ARGS__) 251 #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ASSERT_NOT_NOEXCEPT(__VA_ARGS__) 252 #define LIBCPP_ONLY(...) __VA_ARGS__ 253 #else 254 #define LIBCPP_ASSERT(...) static_assert(true, "") 255 #define LIBCPP_STATIC_ASSERT(...) static_assert(true, "") 256 #define LIBCPP_ASSERT_NOEXCEPT(...) static_assert(true, "") 257 #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) static_assert(true, "") 258 #define LIBCPP_ONLY(...) static_assert(true, "") 259 #endif 260 261 #if __has_cpp_attribute(nodiscard) 262 # define TEST_NODISCARD [[nodiscard]] 263 #else 264 # define TEST_NODISCARD 265 #endif 266 267 #define TEST_IGNORE_NODISCARD (void) 268 269 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 270 // from-chars is a C++17 feature, so it's never available anyways 271 #elif !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_FROM_CHARS_FLOATING_POINT 272 # define TEST_HAS_FROM_CHARS_FLOATING_POINT 273 #endif 274 275 namespace test_macros_detail { 276 template <class T, class U> 277 struct is_same { enum { value = 0};} ; 278 template <class T> 279 struct is_same<T, T> { enum {value = 1}; }; 280 } // namespace test_macros_detail 281 282 #define ASSERT_SAME_TYPE(...) \ 283 static_assert((test_macros_detail::is_same<__VA_ARGS__>::value), \ 284 "Types differ unexpectedly") 285 286 #ifndef TEST_HAS_NO_EXCEPTIONS 287 #define TEST_THROW(...) throw __VA_ARGS__ 288 #else 289 #if defined(__GNUC__) 290 #define TEST_THROW(...) __builtin_abort() 291 #else 292 #include <stdlib.h> 293 #define TEST_THROW(...) ::abort() 294 #endif 295 #endif 296 297 #if defined(__GNUC__) || defined(__clang__) 298 // This function can be used to hide some objects from compiler optimizations. 299 // 300 // For example, this is useful to hide the result of a call to `new` and ensure 301 // that the compiler doesn't elide the call to new/delete. Otherwise, elliding 302 // calls to new/delete is allowed by the Standard and compilers actually do it 303 // when optimizations are enabled. 304 template <class Tp> 305 inline Tp const& DoNotOptimize(Tp const& value) { 306 // The `m` constraint is invalid in the AMDGPU backend. 307 # if defined(__AMDGPU__) || defined(__NVPTX__) 308 asm volatile("" : : "r"(value) : "memory"); 309 # else 310 asm volatile("" : : "r,m"(value) : "memory"); 311 # endif 312 return value; 313 } 314 315 template <class Tp> 316 inline Tp& DoNotOptimize(Tp& value) { 317 // The `m` and `r` output constraint is invalid in the AMDGPU backend as well 318 // as i8 / i1 arguments, so we just capture the pointer instead. 319 # if defined(__AMDGPU__) 320 Tp* tmp = &value; 321 asm volatile("" : "+v"(tmp) : : "memory"); 322 # elif defined(__clang__) 323 asm volatile("" : "+r,m"(value) : : "memory"); 324 # else 325 asm volatile("" : "+m,r"(value) : : "memory"); 326 # endif 327 return value; 328 } 329 #else 330 #include <intrin.h> 331 template <class Tp> 332 inline Tp const& DoNotOptimize(Tp const& value) { 333 const volatile void* volatile unused = __builtin_addressof(value); 334 static_cast<void>(unused); 335 _ReadWriteBarrier(); 336 return value; 337 } 338 #endif 339 340 #if defined(__GNUC__) 341 #define TEST_ALWAYS_INLINE __attribute__((always_inline)) 342 #define TEST_NOINLINE __attribute__((noinline)) 343 #elif defined(_MSC_VER) 344 #define TEST_ALWAYS_INLINE __forceinline 345 #define TEST_NOINLINE __declspec(noinline) 346 #else 347 #define TEST_ALWAYS_INLINE 348 #define TEST_NOINLINE 349 #endif 350 351 #ifdef _WIN32 352 #define TEST_NOT_WIN32(...) ((void)0) 353 #else 354 #define TEST_NOT_WIN32(...) __VA_ARGS__ 355 #endif 356 357 #if defined(TEST_WINDOWS_DLL) ||defined(__MVS__) || defined(_AIX) 358 // Macros for waiving cases when we can't count allocations done within 359 // the library implementation. 360 // 361 // On Windows, when libc++ is built as a DLL, references to operator new/delete 362 // within the DLL are bound at link time to the operator new/delete within 363 // the library; replacing them in the user executable doesn't override the 364 // calls within the library. 365 // 366 // The same goes on IBM zOS. 367 // The same goes on AIX. 368 #define ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(...) ((void)(__VA_ARGS__)) 369 #define TEST_SUPPORTS_LIBRARY_INTERNAL_ALLOCATIONS 0 370 #else 371 #define ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(...) assert(__VA_ARGS__) 372 #define TEST_SUPPORTS_LIBRARY_INTERNAL_ALLOCATIONS 1 373 #endif 374 375 #if (defined(TEST_WINDOWS_DLL) && !defined(_MSC_VER)) || \ 376 defined(__MVS__) 377 // Normally, a replaced e.g. 'operator new' ends up used if the user code 378 // does a call to e.g. 'operator new[]'; it's enough to replace the base 379 // versions and have it override all of them. 380 // 381 // When the fallback operators are located within the libc++ library and we 382 // can't override the calls within it (see above), this fallback mechanism 383 // doesn't work either. 384 // 385 // On Windows, when using the MSVC vcruntime, the operator new/delete fallbacks 386 // are linked separately from the libc++ library, linked statically into 387 // the end user executable, and these fallbacks work even in DLL configurations. 388 // In MinGW configurations when built as a DLL, and on zOS, these fallbacks 389 // don't work though. 390 #define ASSERT_WITH_OPERATOR_NEW_FALLBACKS(...) ((void)(__VA_ARGS__)) 391 #else 392 #define ASSERT_WITH_OPERATOR_NEW_FALLBACKS(...) assert(__VA_ARGS__) 393 #endif 394 395 #ifdef _WIN32 396 #define TEST_WIN_NO_FILESYSTEM_PERMS_NONE 397 #endif 398 399 // Support for carving out parts of the test suite, like removing wide characters, etc. 400 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_WIDE_CHARACTERS 401 # define TEST_HAS_NO_WIDE_CHARACTERS 402 #endif 403 404 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_UNICODE 405 # define TEST_HAS_NO_UNICODE 406 #elif defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001 407 # define TEST_HAS_NO_UNICODE 408 #endif 409 410 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 411 # ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 412 # define TEST_HAS_OPEN_WITH_WCHAR 413 # endif 414 #elif defined(_LIBCPP_VERSION) && _LIBCPP_HAS_OPEN_WITH_WCHAR 415 # define TEST_HAS_OPEN_WITH_WCHAR 416 #endif 417 418 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 419 # ifdef _LIBCPP_HAS_NO_INT128 420 # define TEST_HAS_NO_INT128 421 # endif 422 #elif (defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_INT128) || defined(_MSVC_STL_VERSION) 423 # define TEST_HAS_NO_INT128 424 #endif 425 426 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_LOCALIZATION 427 # define TEST_HAS_NO_LOCALIZATION 428 #endif 429 430 #if TEST_STD_VER <= 17 || !defined(__cpp_char8_t) 431 # define TEST_HAS_NO_CHAR8_T 432 #endif 433 434 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_THREADS 435 # define TEST_HAS_NO_THREADS 436 #endif 437 438 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_FILESYSTEM 439 # define TEST_HAS_NO_FILESYSTEM 440 #endif 441 442 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 443 # ifdef _LIBCPP_HAS_NO_C8RTOMB_MBRTOC8 444 # define TEST_HAS_NO_C8RTOMB_MBRTOC8 445 # endif 446 #elif defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_C8RTOMB_MBRTOC8 447 # define TEST_HAS_NO_C8RTOMB_MBRTOC8 448 #endif 449 450 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_RANDOM_DEVICE 451 # define TEST_HAS_NO_RANDOM_DEVICE 452 #endif 453 454 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 455 // This is a C++20 feature, so it's never available anyways 456 # define TEST_HAS_NO_EXPERIMENTAL_TZDB 457 #elif defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_EXPERIMENTAL_TZDB 458 # define TEST_HAS_NO_EXPERIMENTAL_TZDB 459 #endif 460 461 #if defined(_LIBCPP_VERSION) && !_LIBCPP_HAS_TIME_ZONE_DATABASE 462 # define TEST_HAS_NO_TIME_ZONE_DATABASE 463 #endif 464 465 #if defined(TEST_COMPILER_CLANG) 466 # define TEST_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") 467 # define TEST_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") 468 # define TEST_CLANG_DIAGNOSTIC_IGNORED(str) _Pragma(TEST_STRINGIZE(clang diagnostic ignored str)) 469 # define TEST_GCC_DIAGNOSTIC_IGNORED(str) 470 # define TEST_MSVC_DIAGNOSTIC_IGNORED(num) 471 #elif defined(TEST_COMPILER_GCC) 472 # define TEST_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") 473 # define TEST_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") 474 # define TEST_CLANG_DIAGNOSTIC_IGNORED(str) 475 # define TEST_GCC_DIAGNOSTIC_IGNORED(str) _Pragma(TEST_STRINGIZE(GCC diagnostic ignored str)) 476 # define TEST_MSVC_DIAGNOSTIC_IGNORED(num) 477 #elif defined(TEST_COMPILER_MSVC) 478 # define TEST_DIAGNOSTIC_PUSH _Pragma("warning(push)") 479 # define TEST_DIAGNOSTIC_POP _Pragma("warning(pop)") 480 # define TEST_CLANG_DIAGNOSTIC_IGNORED(str) 481 # define TEST_GCC_DIAGNOSTIC_IGNORED(str) 482 # define TEST_MSVC_DIAGNOSTIC_IGNORED(num) _Pragma(TEST_STRINGIZE(warning(disable: num))) 483 #else 484 # define TEST_DIAGNOSTIC_PUSH 485 # define TEST_DIAGNOSTIC_POP 486 # define TEST_CLANG_DIAGNOSTIC_IGNORED(str) 487 # define TEST_GCC_DIAGNOSTIC_IGNORED(str) 488 # define TEST_MSVC_DIAGNOSTIC_IGNORED(num) 489 #endif 490 491 #if __has_cpp_attribute(msvc::no_unique_address) 492 #define TEST_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] 493 #elif __has_cpp_attribute(no_unique_address) 494 #define TEST_NO_UNIQUE_ADDRESS [[no_unique_address]] 495 #else 496 #define TEST_NO_UNIQUE_ADDRESS 497 #endif 498 499 #ifdef _LIBCPP_SHORT_WCHAR 500 # define TEST_SHORT_WCHAR 501 #endif 502 503 #ifdef _LIBCPP_ABI_MICROSOFT 504 # define TEST_ABI_MICROSOFT 505 #endif 506 507 // This is a temporary workaround for user-defined `operator new` definitions 508 // not being picked up on Apple platforms in some circumstances. This is under 509 // investigation and should be short-lived. 510 #ifdef __APPLE__ 511 # define TEST_WORKAROUND_BUG_109234844_WEAK __attribute__((weak)) 512 #else 513 # define TEST_WORKAROUND_BUG_109234844_WEAK /* nothing */ 514 #endif 515 516 #ifdef _AIX 517 # define TEST_IF_AIX(arg_true, arg_false) arg_true 518 #else 519 # define TEST_IF_AIX(arg_true, arg_false) arg_false 520 #endif 521 522 // Clang-18 has support for deducing this, but it does not set the FTM. 523 #ifdef _LIBCPP_USE_FROZEN_CXX03_HEADERS 524 // This is a C++20 featue, so we don't care whether the compiler could support it 525 #elif defined(_LIBCPP_VERSION) && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER 526 # define TEST_HAS_EXPLICIT_THIS_PARAMETER 527 #endif 528 529 // Placement `operator new`/`operator new[]` are not yet constexpr in C++26 530 // when using MS ABI, because they are from <vcruntime_new.h>. 531 #if defined(__cpp_lib_constexpr_new) && __cpp_lib_constexpr_new >= 202406L 532 # define TEST_CONSTEXPR_OPERATOR_NEW constexpr 533 #else 534 # define TEST_CONSTEXPR_OPERATOR_NEW 535 #endif 536 537 #if defined(_MSC_VER) || __SIZEOF_LONG_DOUBLE__ == __SIZEOF_DOUBLE__ 538 # define TEST_LONG_DOUBLE_IS_DOUBLE 539 #endif 540 541 #endif // SUPPORT_TEST_MACROS_HPP 542