[libcxx] Make sure all experimental tests are disabled when enable_experimental=False

[ldionne]

Summary

Previously, we'd run some experimental tests even when enable_experimental=False
was used with lit.

[EricWF]

If the tests are header only, why disable them? We are losing code coverage on things people may be depending on.

[ldionne]

In D55834#1334839, @EricWF wrote:

If the tests are header only, why disable them? We are losing code coverage on things people may be depending on.

I don't expect most people to be using enable_experimental=False, so that shouldn't actually reduce the test coverage. The problem I hit was running CI on older OS X where a test was failing (because of a problem with exceptions in the old dylib). The experimental part doesn't actually use anything in the dylib, but the test as a whole does, and enabling it when I explicitly say enable_experimental=False was surprising certainly not what I expected.

In other words, I fully agree that we should strive to run experimental tests as often as possible (when it makes sense), and we do have the right default here. But when I explicitly say "don't give me experimental tests", I don't want them to run.

If we'd rather not give that option at all, we could consider inferring the c++experimental LIT feature automatically based on stuff like whether use_system_cxx_lib was used and other things, but I don't think it makes a lot of sense.

WDYT?

[mclow.lists]

In other words, I fully agree that we should strive to run experimental tests as often as possible (when it makes sense), and we do have the right default here. But when I explicitly say "don't give me experimental tests", I don't want them to run.

I'm OK with this.

[EricWF]

In D55834#1334932, @ldionne wrote:

In D55834#1334839, @EricWF wrote:

If the tests are header only, why disable them? We are losing code coverage on things people may be depending on.

I don't expect most people to be using enable_experimental=False, so that shouldn't actually reduce the test coverage. The problem I hit was running CI on older OS X where a test was failing (because of a problem with exceptions in the old dylib). The experimental part doesn't actually use anything in the dylib, but the test as a whole does, and enabling it when I explicitly say enable_experimental=False was surprising certainly not what I expected.

In other words, I fully agree that we should strive to run experimental tests as often as possible (when it makes sense), and we do have the right default here. But when I explicitly say "don't give me experimental tests", I don't want them to run.

If we'd rather not give that option at all, we could consider inferring the c++experimental LIT feature automatically based on stuff like whether use_system_cxx_lib was used and other things, but I don't think it makes a lot of sense.

WDYT?

I think you're missing the point of the feature. It's set by CMake when the user disables the experimental library build. But even then, header only experimental stuff should work; which is what this was testing. Now we have no test coverage that we aren't regressing header only functionality.

[ldionne]

In D55834#1336438, @EricWF wrote:

In D55834#1334932, @ldionne wrote:

In D55834#1334839, @EricWF wrote:

If the tests are header only, why disable them? We are losing code coverage on things people may be depending on.

I don't expect most people to be using enable_experimental=False, so that shouldn't actually reduce the test coverage. The problem I hit was running CI on older OS X where a test was failing (because of a problem with exceptions in the old dylib). The experimental part doesn't actually use anything in the dylib, but the test as a whole does, and enabling it when I explicitly say enable_experimental=False was surprising certainly not what I expected.

In other words, I fully agree that we should strive to run experimental tests as often as possible (when it makes sense), and we do have the right default here. But when I explicitly say "don't give me experimental tests", I don't want them to run.

If we'd rather not give that option at all, we could consider inferring the c++experimental LIT feature automatically based on stuff like whether use_system_cxx_lib was used and other things, but I don't think it makes a lot of sense.

WDYT?

I think you're missing the point of the feature. It's set by CMake when the user disables the experimental library build.

You're right. However, where I'm coming from is running the LIT test suite by itself and passing enable_experimental=False. For example, imagine an implementation that does not implement experimental features -- how would such an implementation use the test suite?

Now we have no test coverage that we aren't regressing header only functionality.

I find this statement too strong. We do have coverage by default because the experimental library is built by default. This really only makes a difference if you're explicitly requesting for the experimental library _not_ to be built but would still want to test the code in headers. I find this use case questionable, and of smaller value than having the ability to turn off the experimental tests on their own.

Are you convinced?

libcxx/trunk/test/libcxx/experimental/lit.local.cfg

+# Disable all of the experimental tests if the correct feature is not available.
+if 'c++experimental' not in config.available_features:
+  config.unsupported = True

libcxx/trunk/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // memory_resource * new_delete_resource()
 
 // The lifetime of the value returned by 'new_delete_resource()' should
 // never end, even very late into program termination. This test constructs

libcxx/trunk/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // memory_resource * new_delete_resource()
 
 // The lifetime of the value returned by 'new_delete_resource()' should
 // never end, even very late into program termination. This test constructs

libcxx/trunk/test/std/experimental/lit.local.cfg

+# Disable all of the experimental tests if the correct feature is not available.
+if 'c++experimental' not in config.available_features:
+  config.unsupported = True

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator() noexcept
 

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator;
 
 // template <class T, class U>
 // bool operator==(

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator;
 
 // template <class T>
 // bool operator!=(

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::allocate(size_t n)
 

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*)

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> const&)

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> &&)

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, U1&&, U2&&)

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2, class ...Args1, class ...Args2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2, class ...Args1, class ...Args2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U, class ...Args>
 // void polymorphic_allocator<T>::construct(U *, Args &&...)

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U>
 // void polymorphic_allocator<T>::destroy(U * ptr);

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // memory_resource *
 // polymorphic_allocator<T>::resource() const

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator
 // polymorphic_allocator<T>::select_on_container_copy_construction() const

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/deque>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using deque =
 //     ::std::deque<T, polymorphic_allocator<T>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/forward_list>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using forward_list =
 //     ::std::forward_list<T, polymorphic_allocator<T>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/list>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using list =
 //     ::std::list<T, polymorphic_allocator<T>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/map>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class K, class V, class Compare = less<Key> >
 // using map =
 //     ::std::map<K, V, Compare, polymorphic_allocator<pair<const K, V>>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/regex>
 
 // namespace std { namespace experimental { namespace pmr {
 //
 //  template <class BidirectionalIterator>
 //  using match_results =

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/set>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class V, class Compare = less<V> >
 // using set =
 //     ::std::set<V, Compare, polymorphic_allocator<V>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/string>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class Char, class Traits = ...>
 // using basic_string =
 //     ::std::basic_string<Char, Traits, polymorphic_allocator<Char>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/unordered_map>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class K, class V, class H = hash<K>, class P = equal_to<K> >
 // using unordered_map =
 //     ::std::unordered_map<K, V, H, P, polymorphic_allocator<pair<const K, V>>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/unordered_set>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class V, class H = hash<V>, class P = equal_to<V> >
 // using unordered_set =
 //     ::std::unordered_set<V, H, P, polymorphic_allocator<V>>

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/vector>
 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using vector =
 //     ::std::vector<T, polymorphic_allocator<T>>

libcxx/trunk/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 //-----------------------------------------------------------------------------
 // TESTING memory_resource * get_default_resource() noexcept;
 //         memory_resource * set_default_resource(memory_resource*) noexcept;
 //

libcxx/trunk/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // memory_resource * new_delete_resource()
 
 #include <experimental/memory_resource>
 #include <type_traits>

libcxx/trunk/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++experimental
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/memory_resource>
 
 // memory_resource * null_memory_resource()
 
 #include <experimental/memory_resource>
 #include <new>