Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@342073 91177308-0d34-0410-b5e6-96231b3b80d8

include/algorithm

@@ -646,6 +646,7 @@ template <class BidirectionalIterator, class Compare>
 #include <iterator>
 #include <cstddef>
 #include <bit>
+#include <version>
 
 #include <__debug>
 

include/any

@@ -87,6 +87,7 @@ namespace std {
 #include <typeinfo>
 #include <type_traits>
 #include <cstdlib>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/array

@@ -112,6 +112,7 @@ template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexce
 #include <algorithm>
 #include <stdexcept>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
+#include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/atomic

@@ -544,6 +544,7 @@ void atomic_signal_fence(memory_order m) noexcept;
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -559,10 +560,6 @@ void atomic_signal_fence(memory_order m) noexcept;
 #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

@@ -21,6 +21,7 @@ namespace std {
 */
 
 #include <__config>
+#include <version>
 
 #if defined(__IBMCPP__)
 #include "support/ibm/support.h"

include/chrono

@@ -798,6 +798,7 @@ constexpr chrono::year                                  operator ""y(unsigned lo
 #include <type_traits>
 #include <ratio>
 #include <limits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/cmath

@@ -303,6 +303,7 @@ long double    truncl(long double x);
 
 #include <__config>
 #include <math.h>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/complex

@@ -245,6 +245,7 @@ template<class T, class charT, class traits>
 #include <stdexcept>
 #include <cmath>
 #include <sstream>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/cstddef

@@ -35,6 +35,7 @@ Types:
 */
 
 #include <__config>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/deque

@@ -161,6 +161,7 @@ template <class T, class Allocator>
 #include <iterator>
 #include <algorithm>
 #include <stdexcept>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/exception

@@ -81,6 +81,7 @@ template <class E> void rethrow_if_nested(const E& e);
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
+#include <version>
 
 #if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
 #include <vcruntime_exception.h>

include/filesystem

@@ -244,6 +244,7 @@
 #include <utility>
 #include <iomanip> // for quoted
 #include <string_view>
+#include <version>
 
 #include <__debug>
 
@@ -256,10 +257,6 @@ _LIBCPP_PUSH_MACROS
 
 #ifndef _LIBCPP_CXX03_LANG
 
-#if _LIBCPP_STD_VER >= 17
-#define __cpp_lib_filesystem 201703
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 struct _FilesystemClock {

include/forward_list

@@ -177,6 +177,7 @@ template <class T, class Allocator>
 #include <limits>
 #include <iterator>
 #include <algorithm>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/functional

@@ -487,6 +487,7 @@ POLICY:  For non-variadic implementations, the number of arguments is limited
 #include <memory>
 #include <tuple>
 #include <utility>
+#include <version>
 
 #include <__functional_base>
 
@@ -2340,8 +2341,6 @@ bind(_Fp&& __f, _BoundArgs&&... __bound_args)
 
 #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

@@ -46,6 +46,7 @@ template <class charT, class traits, class Allocator>
 #include <__config>
 #include <__string>
 #include <istream>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/iterator

@@ -418,6 +418,7 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
 #include <type_traits>
 #include <cstddef>
 #include <initializer_list>
+#include <version>
 #ifdef __APPLE__
 #include <Availability.h>
 #endif

include/list

@@ -181,6 +181,7 @@ template <class T, class Alloc>
 #include <iterator>
 #include <algorithm>
 #include <type_traits>
+#include <version>
 
 #include <__debug>
 

include/map

@@ -460,6 +460,7 @@ swap(multimap<Key, T, Compare, Allocator>& x,
 #include <functional>
 #include <initializer_list>
 #include <type_traits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/memory

@@ -667,6 +667,7 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 #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

@@ -194,6 +194,7 @@ template<class Callable, class ...Args>
 #ifndef _LIBCPP_CXX03_LANG
 #include <tuple>
 #endif
+#include <version>
 #include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/new

@@ -91,6 +91,7 @@ void  operator delete[](void* ptr, void*) noexcept;
 #include <exception>
 #include <type_traits>
 #include <cstddef>
+#include <version>
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif

include/numeric

@@ -142,6 +142,7 @@ template <class M, class N>
 #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

@@ -156,6 +156,7 @@ template<class T>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/regex

@@ -769,6 +769,7 @@ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 #include <memory>
 #include <vector>
 #include <deque>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/scoped_allocator

@@ -108,6 +108,7 @@ template <class OuterA1, class OuterA2, class... InnerAllocs>
 
 #include <__config>
 #include <memory>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/set

@@ -402,6 +402,7 @@ swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
 #include <__tree>
 #include <__node_handle>
 #include <functional>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/shared_mutex

@@ -124,6 +124,7 @@ template <class Mutex>
 */
 
 #include <__config>
+#include <version>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

include/string

@@ -510,6 +510,7 @@ basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++1
 #include <type_traits>
 #include <initializer_list>
 #include <__functional_base>
+#include <version>
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #include <cstdint>
 #endif

include/string_view

@@ -178,6 +178,7 @@ namespace std {
 #include <iterator>
 #include <limits>
 #include <stdexcept>
+#include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/tuple

@@ -141,6 +141,7 @@ template <class... Types>
 #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

@@ -404,6 +404,7 @@ namespace std
 */
 #include <__config>
 #include <cstddef>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -4758,7 +4759,6 @@ struct __has_operator_addressof
 
 #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

@@ -386,6 +386,7 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #include <functional>
 #include <stdexcept>
 #include <tuple>
+#include <version>
 
 #include <__debug>
 

include/unordered_set

@@ -338,6 +338,7 @@ template <class Value, class Hash, class Pred, class Alloc>
 #include <__hash_table>
 #include <__node_handle>
 #include <functional>
+#include <version>
 
 #include <__debug>
 

include/utility

@@ -203,6 +203,7 @@ template <size_t I>
 #include <cstddef>
 #include <cstring>
 #include <cstdint>
+#include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

include/variant

@@ -208,6 +208,7 @@ namespace std {
 #include <type_traits>
 #include <utility>
 #include <limits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/vector

@@ -276,6 +276,7 @@ void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
 #include <stdexcept>
 #include <algorithm>
 #include <cstring>
+#include <version>
 #include <__split_buffer>
 #include <__functional_base>
 

include/version

@@ -101,4 +101,17 @@ __cpp_lib_void_t                            201411L <type_traits>
 #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

@@ -0,0 +1,36 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,41 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+*/
+
+// XFAIL
+// #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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+*/
+
+// XFAIL
+// #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

@@ -0,0 +1,40 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,44 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,36 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,39 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+*/
+
+// XFAIL
+// #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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,33 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,53 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,35 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,34 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,36 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,32 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,34 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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

@@ -0,0 +1,135 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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
+*/
+}