Create infrastructure for defining and testing feature test macros

[mclow.lists]

Summary

In P0941, the committee standardized a bunch of feature test macros.
[ I think it's a bad idea, but whatever. ]

This patch puts the existing libc++ feature test macros in <version>, where P0941 specifies, and makes sure that all the correct headers include <version>. It also introduces a full set of tests, one per header file that might get something defined.

At the moment, most of those tests are empty, since libc++ does not define many feature test macros.
But now it's easy to add more. Put them in <version> and update the appropriate tests. Helpfully, the list is at the top of each of the test files.

[ldionne]

Thanks! I don't like feature test macros either, but we should still strive for conformance.

[mclow.lists]

landed as revision 342073

include/algorithm

 #include <iterator>
 #include <cstddef>
 #include <bit>
+#include <version>
 
 #include <__debug>
 

include/any

 #include <typeinfo>
 #include <type_traits>
 #include <cstdlib>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/array

 #include <algorithm>
 #include <stdexcept>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
+#include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/atomic

 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

 #error C++ standard library is incompatible with <stdatomic.h>
 #endif
 
-#if _LIBCPP_STD_VER > 14
-# define __cpp_lib_atomic_is_always_lock_free 201603L
-#endif
-
 #define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) \
   _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_consume || \
                            __m == memory_order_acquire || \

include/bit

 */
 
 #include <__config>
+#include <version>
 
 #if defined(__IBMCPP__)
 #include "support/ibm/support.h"

include/chrono

 #include <type_traits>
 #include <ratio>
 #include <limits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/cmath

 
 #include <__config>
 #include <math.h>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/complex

 #include <stdexcept>
 #include <cmath>
 #include <sstream>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/cstddef

 */
 
 #include <__config>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/deque

 #include <iterator>
 #include <algorithm>
 #include <stdexcept>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/exception

 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
+#include <version>
 
 #if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
 #include <vcruntime_exception.h>

include/filesystem

 #include <utility>
 #include <iomanip> // for quoted
 #include <string_view>
+#include <version>
 
 #include <__debug>
 

 
 #ifndef _LIBCPP_CXX03_LANG
 
-#if _LIBCPP_STD_VER >= 17
-#define __cpp_lib_filesystem 201703
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 struct _FilesystemClock {

include/forward_list

 #include <limits>
 #include <iterator>
 #include <algorithm>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/functional

 #include <memory>
 #include <tuple>
 #include <utility>
+#include <version>
 
 #include <__functional_base>
 

 
 #if _LIBCPP_STD_VER > 14
 
-#define __cpp_lib_invoke 201411
-
 template <class _Fn, class ..._Args>
 result_of_t<_Fn&&(_Args&&...)>
 invoke(_Fn&& __f, _Args&&... __args)

include/iomanip

 #include <__config>
 #include <__string>
 #include <istream>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/iterator

 #include <type_traits>
 #include <cstddef>
 #include <initializer_list>
+#include <version>
 #ifdef __APPLE__
 #include <Availability.h>
 #endif

include/list

 #include <iterator>
 #include <algorithm>
 #include <type_traits>
+#include <version>
 
 #include <__debug>
 

include/map

 #include <functional>
 #include <initializer_list>
 #include <type_traits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/memory

 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/mutex

 #ifndef _LIBCPP_CXX03_LANG
 #include <tuple>
 #endif
+#include <version>
 #include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/new

 #include <exception>
 #include <type_traits>
 #include <cstddef>
+#include <version>
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif

include/numeric

 #include <iterator>
 #include <limits> // for numeric_limits
 #include <functional>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/optional

 #include <stdexcept>
 #include <type_traits>
 #include <utility>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/regex

 #include <memory>
 #include <vector>
 #include <deque>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/scoped_allocator

 
 #include <__config>
 #include <memory>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/set

 #include <__tree>
 #include <__node_handle>
 #include <functional>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/shared_mutex

 */
 
 #include <__config>
+#include <version>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

include/string

 #include <type_traits>
 #include <initializer_list>
 #include <__functional_base>
+#include <version>
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #include <cstdint>
 #endif

include/string_view

 #include <iterator>
 #include <limits>
 #include <stdexcept>
+#include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/tuple

 #include <type_traits>
 #include <__functional_base>
 #include <utility>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/type_traits

 */
 #include <__config>
 #include <cstddef>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

 
 #if _LIBCPP_STD_VER > 14
 
-#define __cpp_lib_void_t 201411
 template <class...> using void_t = void;
 
 # ifndef _LIBCPP_HAS_NO_VARIADICS

include/unordered_map

 #include <functional>
 #include <stdexcept>
 #include <tuple>
+#include <version>
 
 #include <__debug>
 

include/unordered_set

 #include <__hash_table>
 #include <__node_handle>
 #include <functional>
+#include <version>
 
 #include <__debug>
 

include/utility

 #include <cstddef>
 #include <cstring>
 #include <cstdint>
+#include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/variant

 #include <type_traits>
 #include <utility>
 #include <limits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/vector

 #include <stdexcept>
 #include <algorithm>
 #include <cstring>
+#include <version>
 #include <__split_buffer>
 #include <__functional_base>
 

include/version

 #pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER > 11
+#endif
+
+#if _LIBCPP_STD_VER > 14
+# define __cpp_lib_atomic_is_always_lock_free           201603L
+# define __cpp_lib_filesystem                           201703L
+# define __cpp_lib_invoke                               201411L
+# define __cpp_lib_void_t                               201411L
+#endif
+
+#if _LIBCPP_STD_VER > 17
+#endif
+
 #endif  // _LIBCPP_VERSIONH

test/std/language.support/support.limits/support.limits.general/algorithm.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <algorithm> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_clamp                             201603L
+    __cpp_lib_constexpr_swap_algorithms         201806L
+    __cpp_lib_parallel_algorithm                201603L
+    __cpp_lib_robust_nonmodifying_seq_ops       201304L
+    __cpp_lib_sample                            201603L
+
+*/
+
+#include <algorithm>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <algorithm> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/any.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <any> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_any                               201606L
+
+*/
+
+#include <any>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <any> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/array.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <array> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_array_constexpr                   201603L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <array>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <array> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/atomic.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <atomic> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_atomic_is_always_lock_free        201603L
+    __cpp_lib_atomic_ref                        201806L
+
+*/
+
+#include <atomic>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <atomic> are defined.
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_atomic_is_always_lock_free)
+#  error "__cpp_lib_atomic_is_always_lock_free is not defined"
+# elif __cpp_lib_atomic_is_always_lock_free < 201603L
+#  error "__cpp_lib_atomic_is_always_lock_free has an invalid value"
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/bit.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <bit> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_bit_cast                          201806L
+
+*/
+
+#include <bit>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <bit> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/chrono.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <chrono> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_chrono                            201611L
+
+*/
+
+#include <chrono>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <chrono> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/cmath.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <cmath> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_hypot                             201603L
+    __cpp_lib_math_special_functions            201603L
+
+*/
+
+#include <cmath>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <cmath> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/complex.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <complex> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_complex_udls                      201309L
+
+*/
+
+#include <complex>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <complex> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/concepts.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <concepts> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_concepts                          201806L
+
+*/
+
+#include <concepts>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <concepts> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/cstddef.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <cstddef> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_byte                              201603L
+
+*/
+
+#include <cstddef>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <cstddef> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/deque.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <deque> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <deque>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <deque> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/exception.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <exception> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_uncaught_exceptions               201411L
+
+*/
+
+#include <exception>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <exception> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/execution.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <execution> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_execution                         201603L
+
+*/
+
+#include <execution>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <execution> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/filesystem.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <filesystem> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_filesystem                        201703L
+
+*/
+
+#include <filesystem>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <filesystem> are defined.
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_filesystem)
+#  error "__cpp_lib_filesystem is not defined"
+# elif __cpp_lib_filesystem < 201703L
+#  error "__cpp_lib_filesystem has an invalid value"
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/forward_list.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <forward_list> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_incomplete_container_elements     201505L
+    __cpp_lib_list_remove_return_type           201806L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <forward_list>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <forward_list> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/functional.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <functional> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_boyer_moore_searcher              201603L
+    __cpp_lib_invoke                            201411L
+    __cpp_lib_not_fn                            201603L
+    __cpp_lib_result_of_sfinae                  201210L
+    __cpp_lib_transparent_operators             201510L
+
+*/
+
+#include <functional>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <functional> are defined.
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_invoke)
+#  error "__cpp_lib_invoke is not defined"
+# elif __cpp_lib_invoke < 201411L
+#  error "__cpp_lib_invoke has an invalid value"
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/iomanip.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <iomanip> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_quoted_string_io                  201304L
+
+*/
+
+#include <iomanip>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <iomanip> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/iterator.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <iterator> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_array_constexpr                   201603L
+    __cpp_lib_make_reverse_iterator             201402L
+    __cpp_lib_nonmember_container_access        201411L
+    __cpp_lib_null_iterators                    201304L
+
+*/
+
+#include <iterator>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <iterator> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/list.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <list> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_incomplete_container_elements     201505L
+    __cpp_lib_list_remove_return_type           201806L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <list>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <list> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/map.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <map> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_generic_associative_lookup        201304L
+    __cpp_lib_map_try_emplace                   201411L
+    __cpp_lib_node_extract                      201606L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <map>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <map> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/memory.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <memory> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_addressof_constexpr               201603L
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_enable_shared_from_this           201603L
+    __cpp_lib_make_unique                       201304L
+    __cpp_lib_raw_memory_algorithms             201606L
+    __cpp_lib_shared_ptr_arrays                 201611L
+    __cpp_lib_shared_ptr_weak_type              201606L
+    __cpp_lib_transparent_operators             201510L
+
+*/
+
+#include <memory>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <memory> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/memory_resource.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <memory_resource> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_memory_resource                   201603L
+
+*/
+
+#include <memory_resource>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <memory_resource> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/mutex.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <mutex> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_scoped_lock                       201703L
+
+*/
+
+#include <mutex>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <mutex> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/new.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <new> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_hardware_interference_size        201703L
+    __cpp_lib_launder                           201606L
+
+*/
+
+#include <new>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <new> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/numeric.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <numeric> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_gcd_lcm                           201606L
+    __cpp_lib_parallel_algorithm                201603L
+
+*/
+
+#include <numeric>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <numeric> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/optional.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <optional> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_optional                          201606L
+
+*/
+
+#include <optional>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <optional> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/regex.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <regex> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <regex>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <regex> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <scoped_allocator> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+
+*/
+
+#include <scoped_allocator>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <scoped_allocator> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/set.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <set> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_generic_associative_lookup        201304L
+    __cpp_lib_node_extract                      201606L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <set>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <set> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/shared_mutex.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <shared_mutex> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_shared_mutex                      201505L
+    __cpp_lib_shared_timed_mutex                201402L
+
+*/
+
+#include <shared_mutex>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <shared_mutex> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/string.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <string> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_nonmember_container_access        201411L
+    __cpp_lib_string_udls                       201304L
+    __cpp_lib_string_view                       201606L
+
+*/
+
+#include <string>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <string> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/string_view.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <string_view> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_string_view                       201606L
+
+*/
+
+#include <string_view>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <string_view> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/tuple.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <tuple> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_apply                             201603L
+    __cpp_lib_make_from_tuple                   201606L
+    __cpp_lib_tuple_element_t                   201402L
+    __cpp_lib_tuples_by_type                    201304L
+
+*/
+
+#include <tuple>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <tuple> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/type_traits.version.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> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_bool_constant                     201505L
+    __cpp_lib_has_unique_object_representations 201606L
+    __cpp_lib_integral_constant_callable        201304L
+    __cpp_lib_is_aggregate                      201703L
+    __cpp_lib_is_final                          201402L
+    __cpp_lib_is_invocable                      201703L
+    __cpp_lib_is_null_pointer                   201309L
+    __cpp_lib_is_swappable                      201603L
+    __cpp_lib_logical_traits                    201510L
+    __cpp_lib_result_of_sfinae                  201210L
+    __cpp_lib_transformation_trait_aliases      201304L
+    __cpp_lib_type_trait_variable_templates     201510L
+    __cpp_lib_void_t                            201411L
+
+*/
+
+#include <type_traits>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <type_traits> are defined.
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_void_t)
+#  error "__cpp_lib_void_t is not defined"
+# elif __cpp_lib_void_t < 201411L
+#  error "__cpp_lib_void_t has an invalid value"
+# endif
+#endif
+
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/unordered_map.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <unordered_map> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_node_extract                      201606L
+    __cpp_lib_nonmember_container_access        201411L
+    __cpp_lib_unordered_map_try_emplace         201411L
+
+*/
+
+#include <unordered_map>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <unordered_map> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/unordered_set.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <unordered_set> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_node_extract                      201606L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <unordered_set>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <unordered_set> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/utility.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <utility> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_as_const                          201510L
+    __cpp_lib_exchange_function                 201304L
+    __cpp_lib_integer_sequence                  201304L
+    __cpp_lib_to_chars                          201611L
+    __cpp_lib_tuples_by_type                    201304L
+
+*/
+
+#include <utility>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <utility> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/variant.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <variant> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_variant                           201606L
+
+*/
+
+#include <variant>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <variant> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/vector.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <vector> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_incomplete_container_elements     201505L
+    __cpp_lib_nonmember_container_access        201411L
+
+*/
+
+#include <vector>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <vector> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}

test/std/language.support/support.limits/support.limits.general/version.version.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <version> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_addressof_constexpr               201603L
+    __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_any                               201606L
+    __cpp_lib_apply                             201603L
+    __cpp_lib_array_constexpr                   201603L
+    __cpp_lib_as_const                          201510L
+    __cpp_lib_atomic_is_always_lock_free        201603L
+    __cpp_lib_atomic_ref                        201806L
+    __cpp_lib_bit_cast                          201806L
+    __cpp_lib_bool_constant                     201505L
+    __cpp_lib_boyer_moore_searcher              201603L
+    __cpp_lib_byte                              201603L
+    __cpp_lib_chrono                            201611L
+    __cpp_lib_clamp                             201603L
+    __cpp_lib_complex_udls                      201309L
+    __cpp_lib_concepts                          201806L
+    __cpp_lib_constexpr_swap_algorithms         201806L
+    __cpp_lib_enable_shared_from_this           201603L
+    __cpp_lib_exchange_function                 201304L
+    __cpp_lib_execution                         201603L
+    __cpp_lib_filesystem                        201703L
+    __cpp_lib_gcd_lcm                           201606L
+    __cpp_lib_generic_associative_lookup        201304L
+    __cpp_lib_hardware_interference_size        201703L
+    __cpp_lib_has_unique_object_representations 201606L
+    __cpp_lib_hypot                             201603L
+    __cpp_lib_incomplete_container_elements     201505L
+    __cpp_lib_integer_sequence                  201304L
+    __cpp_lib_integral_constant_callable        201304L
+    __cpp_lib_invoke                            201411L
+    __cpp_lib_is_aggregate                      201703L
+    __cpp_lib_is_final                          201402L
+    __cpp_lib_is_invocable                      201703L
+    __cpp_lib_is_null_pointer                   201309L
+    __cpp_lib_is_swappable                      201603L
+    __cpp_lib_launder                           201606L
+    __cpp_lib_list_remove_return_type           201806L
+    __cpp_lib_logical_traits                    201510L
+    __cpp_lib_make_from_tuple                   201606L
+    __cpp_lib_make_reverse_iterator             201402L
+    __cpp_lib_make_unique                       201304L
+    __cpp_lib_map_try_emplace                   201411L
+    __cpp_lib_math_special_functions            201603L
+    __cpp_lib_memory_resource                   201603L
+    __cpp_lib_node_extract                      201606L
+    __cpp_lib_nonmember_container_access        201411L
+    __cpp_lib_not_fn                            201603L
+    __cpp_lib_null_iterators                    201304L
+    __cpp_lib_optional                          201606L
+    __cpp_lib_parallel_algorithm                201603L
+    __cpp_lib_quoted_string_io                  201304L
+    __cpp_lib_raw_memory_algorithms             201606L
+    __cpp_lib_result_of_sfinae                  201210L
+    __cpp_lib_robust_nonmodifying_seq_ops       201304L
+    __cpp_lib_sample                            201603L
+    __cpp_lib_scoped_lock                       201703L
+    __cpp_lib_shared_mutex                      201505L
+    __cpp_lib_shared_ptr_arrays                 201611L
+    __cpp_lib_shared_ptr_weak_type              201606L
+    __cpp_lib_shared_timed_mutex                201402L
+    __cpp_lib_string_udls                       201304L
+    __cpp_lib_string_view                       201606L
+    __cpp_lib_to_chars                          201611L
+    __cpp_lib_transformation_trait_aliases      201304L
+    __cpp_lib_transparent_operators             201510L
+    __cpp_lib_tuple_element_t                   201402L
+    __cpp_lib_tuples_by_type                    201304L
+    __cpp_lib_type_trait_variable_templates     201510L
+    __cpp_lib_uncaught_exceptions               201411L
+    __cpp_lib_unordered_map_try_emplace         201411L
+    __cpp_lib_variant                           201606L
+    __cpp_lib_void_t                            201411L
+
+*/
+
+#include <version>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <version> are defined.
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_atomic_is_always_lock_free)
+#  error "__cpp_lib_atomic_is_always_lock_free is not defined"
+# elif __cpp_lib_atomic_is_always_lock_free < 201603L
+#  error "__cpp_lib_atomic_is_always_lock_free has an invalid value"
+# endif
+#endif
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_filesystem)
+#  error "__cpp_lib_filesystem is not defined"
+# elif __cpp_lib_filesystem < 201703L
+#  error "__cpp_lib_filesystem has an invalid value"
+# endif
+#endif
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_invoke)
+#  error "__cpp_lib_invoke is not defined"
+# elif __cpp_lib_invoke < 201411L
+#  error "__cpp_lib_invoke has an invalid value"
+# endif
+#endif
+
+#if _TEST_STD_VER > 14
+# if !defined(__cpp_lib_void_t)
+#  error "__cpp_lib_void_t is not defined"
+# elif __cpp_lib_void_t < 201411L
+#  error "__cpp_lib_void_t has an invalid value"
+# endif
+#endif
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}