[libc++][test] Skip string_view tests for other vendors on older modes

[jloser]

Summary

string_view is supported all the way back to C++03 as an extension in
libc++, and so many of the tests run in all standards modes for all vendors.
This is unlikely desired by other standard library vendors using our test suite.
So, disable the tests for vendors other than libc++ in these older standards
modes.

[jloser]

Simplify the // UNSUPPORTED clauses in the literal tests

[philnik]

LGTM, but I'd like to wait for a second reviewer.

[Mordante]

Thanks for the cleanup! There are several minor issues.

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

15 ↗

(On Diff #433637)

This isn't needed, see line 8.

libcxx/test/std/strings/string.view/string.view.cons/from_range.pass.cpp

16 ↗

(On Diff #433637)

This isn't needed, see line 8.

libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp

20

Can you move this more to the top, (before // <functional>) of the file like we do in the other tests?

Same for other places.

libcxx/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp

31 ↗

(On Diff #433637)

Is this intended? It adds new unused variables.

(This file contains a similar commented out block at line 71.)

The same for the next file.

[jloser]

Fix placement of // UNSUPPORTED and Mordante's comments

[jloser]

libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp

20

Done! Good spot.

libcxx/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp

31 ↗

(On Diff #433637)

Sorry, this was done in a separate PR (https://github.com/llvm/llvm-project/commit/6423a9f0ec8ba70049ea76e7bcfc9a9d1a54e826) and was wrong to begin with. It is fixed with https://reviews.llvm.org/D126901

[Mordante]

There are a few places where the UNSUPPORTED isn't in the proper spot, I've marked all of them. Please update these before landing this patch.
Other than these nits, LGTM.

libcxx/test/std/strings/string.view/char.bad.fail.cpp

14

Please move up.

libcxx/test/std/strings/string.view/string.view.access/front.pass.cpp

15

Please move up.

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp

15

Please move up.

libcxx/test/std/strings/string.view/char.bad.fail.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 //   ... manipulating sequences of any non-array trivial standard-layout types.
 
 #include <string>
 #include "../basic.string/test_traits.h"
 
 struct NotTrivial {
     NotTrivial() : value(3) {}
     int value;
 };
 
 struct NotStandardLayout {

libcxx/test/std/strings/string.view/string.view.hash/char_type.hash.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: !stdlib=libc++ && (c++11 || c++14)
 
 // <string_view>
 
 // Test that hash specializations for <string_view> require "char_traits<_CharT>" not just any "_Trait".
 
 #include <string_view>
 #include <string> // for 'mbstate_t'
 

libcxx/test/std/strings/string.view/string.view.hash/enabled_hashes.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: !stdlib=libc++ && (c++11 || c++14)
 
 // <string_view>
 
 // Test that <string_view> provides all of the arithmetic, enum, and pointer
 // hash specializations.
 
 #include <string_view>
 

libcxx/test/std/strings/string.view/string.view.hash/string_view.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <functional>
 
 // template <class T>
 // struct hash
 //     : public unary_function<T, size_t>
 // {
 //     size_t operator()(T val) const;
 // };
 
 // Not very portable
 
 #include <string_view>
 #include <string>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 

libcxx/test/std/strings/string.view/string.view.access/back.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const _CharT& front();
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.access/data.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const _CharT* data() const noexcept;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.access/front.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const _CharT& back();
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename CharT>
 bool test ( const CharT *s, size_t len ) {
     typedef std::basic_string_view<CharT> SV;
     SV sv ( s, len );

libcxx/test/std/strings/string.view/string.view.access/index.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const _CharT& operator[](size_type _pos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.capacity/capacity.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // [string.view.capacity], capacity
 // constexpr size_type size()     const noexcept;
 // constexpr size_type length()   const noexcept;
 // constexpr size_type max_size() const noexcept;
 // constexpr bool empty()         const noexcept;
 

libcxx/test/std/strings/string.view/string.view.comparison/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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator==(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.comparison/greater.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator>(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.comparison/greater_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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator>=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.comparison/less.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator<(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.comparison/less_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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator<=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.comparison/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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator!=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.cons/assign.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr basic_string_view& operator=(const basic_string_view &) noexcept = default;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.cons/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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr basic_string_view () noexcept;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.cons/from_literal.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr basic_string_view(const _CharT* _s)
 //    : __data (_s), __size(_Traits::length(_s)) {}
 
-
 #include <string_view>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template<typename CharT>

libcxx/test/std/strings/string.view/string.view.cons/from_ptr_len.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 //  constexpr basic_string_view(const _CharT* _s, size_type _len)
 //      : __data (_s), __size(_len) {}
 
-
 #include <string_view>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename CharT>
 void test ( const CharT *s, size_t sz ) {

libcxx/test/std/strings/string.view/string.view.cons/from_string.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class Allocator>
 // basic_string_view(const basic_string<_CharT, _Traits, Allocator>& _str) noexcept
 
-
 #include <string_view>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct dummy_char_traits : public std::char_traits<char> {};
 

libcxx/test/std/strings/string.view/string.view.cons/from_string1.compile.fail.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class Allocator>
 // basic_string_view(const basic_string<_CharT, _Traits, Allocator>& _str) noexcept
 
 #include <string_view>
 #include <string>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.cons/from_string2.compile.fail.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class Allocator>
 // basic_string_view(const basic_string<_CharT, _Traits, Allocator>& _str) noexcept
 
 #include <string_view>
 #include <string>
 #include <cassert>

libcxx/test/std/strings/string.view/string.view.find/find_char_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find(charT c, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_first_not_of(charT c, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // size_type find_first_not_of(const basic_string& str, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_of_char_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_first_of(charT c, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // size_type find_first_of(const basic_string_view& str, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // size_type find_last_not_of(charT c, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // size_type find_last_not_of(const basic_string& str, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class S>
 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {

libcxx/test/std/strings/string.view/string.view.find/find_last_of_char_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_last_of(charT c, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // size_type find_last_of(const basic_string& str, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find(const charT* s, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_pointer_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find(const charT* s, size_type pos, size_type n) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/find_string_view_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type find(const basic_string_view& str, size_type pos = 0) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.find/rfind_char_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 // constexpr size_type rfind(charT c, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"

libcxx/test/std/strings/string.view/string.view.find/rfind_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 // constexpr size_type rfind(const charT* s, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"

libcxx/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 // constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"

libcxx/test/std/strings/string.view/string.view.find/rfind_string_view_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr size_type rfind(const basic_string& str, size_type pos = npos) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.io/stream_insert.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-localization
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
 
 // <string_view>
 
 // template<class charT, class traits, class Allocator>
 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& os,
 //              const basic_string_view<charT,traits> str);
 

libcxx/test/std/strings/string.view/string.view.io/stream_insert_decl_present.compile.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // template<class charT, class traits, class Allocator>
 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& os,
 //              const basic_string_view<charT,traits> str);
 
 #include <string_view>
 #include <iosfwd>
 
 template <class SV, class = void>
 struct HasDecl : std::false_type {};
 template <class SV>
 struct HasDecl<SV, decltype(static_cast<void>(std::declval<std::ostream&>() << std::declval<SV&>()))> : std::true_type {};
 
 static_assert(HasDecl<std::string_view>::value, "streaming operator declaration not present");

libcxx/test/std/strings/string.view/string.view.iterators/begin.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const_iterator begin() const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.iterators/end.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const_iterator end() const;
 
 #include <string_view>
 #include <cassert>
 #include <cstddef>
 

libcxx/test/std/strings/string.view/string.view.iterators/rbegin.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // const_iterator rbegin() const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.iterators/rend.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr const_iterator rend() const;
 
 #include <string_view>
 #include <cassert>
 #include <cstddef>
 

libcxx/test/std/strings/string.view/string.view.modifiers/remove_prefix.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // void remove_prefix(size_type _n)
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.modifiers/remove_suffix.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // void remove_suffix(size_type _n)
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.modifiers/swap.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // void swap(basic_string_view& _other) noexcept
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.nonmem/quoted.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // UNSUPPORTED: no-localization
+// UNSUPPORTED: !stdlib=libc++ && c++14
 
 // <iomanip>
 
 // quoted
 
 #include <iomanip>
 #include <sstream>
 #include <string_view>

libcxx/test/std/strings/string.view/string.view.ops/compare.pointer.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr int compare(const charT* s) const;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.ops/compare.pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
 
 #include <string_view>
 #include <cassert>
 #include <stdexcept>
 

libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;
 
 #include <string_view>
 #include <cassert>
 #include <stdexcept>
 

libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1,
 //             const charT* s, size_type n2) const;
 
 #include <string_view>
 #include <cassert>
 #include <stdexcept>

libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
 //             size_type pos2, size_type n2) const;
 
 #include <string_view>
 #include <cassert>
 #include <stdexcept>

libcxx/test/std/strings/string.view/string.view.ops/compare.sv.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr int compare(basic_string_view str) const noexcept;
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/string.view.ops/copy.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;
 
 // Throws: out_of_range if pos > size().
 // Remarks: Let rlen be the smaller of n and size() - pos.
 // Requires: [s, s+rlen) is a valid range.
 // Effects: Equivalent to std::copy_n(begin() + pos, rlen, s).
 // Returns: rlen.
 
-
 #include <string_view>
 #include <algorithm>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 
 template<typename CharT>

libcxx/test/std/strings/string.view/string.view.ops/substr.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
 
 // Throws: out_of_range if pos > size().
 // Effects: Determines the effective length rlen of the string to reference as the smaller of n and size() - pos.
 // Returns: basic_string_view(data()+pos, rlen).
 

libcxx/test/std/strings/string.view/string_view.literals/literal.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
-
 // Note: libc++ supports string_view before C++17, but literals were introduced in C++14
+// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: !stdlib=libc++ && c++14
 
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     typedef std::u8string_view u8string_view;

libcxx/test/std/strings/string.view/string_view.literals/literal.verify.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
 //
 //===----------------------------------------------------------------------===//
 
+// Note: libc++ supports string_view before C++17, but literals were introduced in C++14
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: !stdlib=libc++ && c++14
 
 #include <string_view>
 
 void f() {
   {
     using std::string_view;
     string_view foo = ""sv; // expected-error {{no matching literal operator}}
   }
   {
     std::string_view foo = ""sv; // expected-error {{no matching literal operator}}
   }
 }

libcxx/test/std/strings/string.view/traits_mismatch.compile.fail.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 //   The string_views's value type must be the same as the traits's char_type
 
 #include <string_view>
 
 int main(int, char**)
 {
     std::basic_string_view<char, std::char_traits<wchar_t>> s;
 
   return 0;
 }

libcxx/test/std/strings/string.view/trivially_copyable.compile.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // P2251 was voted into C++23, but is supported even in C++17 mode by all vendors.
 
 // <string_view>
 
 #include <string_view>
 #include <type_traits>
 
 #include "test_macros.h"

libcxx/test/std/strings/string.view/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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // <string_view>
 
 // Test nested types and default template args:
 
 // template<class charT, class traits = char_traits<charT>>
 // {
 // public:
 //     // types: