[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

This isn't needed, see line 8.

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

16

This isn't needed, see line 8.

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

18

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

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

18

Done! Good spot.

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

31

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

12

Please move up.

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

13

Please move up.

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

13

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

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

 
 // template <class T>
 // struct hash
 //     : public unary_function<T, size_t>
 // {
 //     size_t operator()(T val) const;
 // };
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const _CharT& front();
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const _CharT* data() const noexcept;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename CharT>
 void test ( const CharT *s, size_t len ) {
     std::basic_string_view<CharT> sv ( s, len );

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const _CharT& back();
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const _CharT& operator[](size_type _pos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::basic_string_view<CharT> SV;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <limits>
 
 #include "test_macros.h"
 
 template<typename SV>
 void test1 () {

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr basic_string_view& operator=(const basic_string_view &) noexcept = default;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename T>
 #if TEST_STD_VER > 11
 constexpr

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr basic_string_view () noexcept;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename T>
 void test () {
 #if TEST_STD_VER > 11

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.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, c++14, c++17
 
 // <string_view>
 
 //  template <class It, class End>
 //  constexpr basic_string_view(It begin, End end)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <iterator>
 
 #include "make_string.h"
 #include "test_iterators.h"
 
 template<class It, class Sentinel, class CharT>

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

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

libcxx/test/std/strings/string.view/string.view.cons/from_range.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, c++14, c++17, c++20
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // <string_view>
 
 //  template <class Range>
 //  constexpr basic_string_view(Range&& range);
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <array>
 #include <cassert>
 #include <iterator>
 #include <ranges>
 #include <type_traits>
 #include <vector>
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // template<class Allocator>
 // basic_string_view(const basic_string<_CharT, _Traits, Allocator>& _str) noexcept
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
 
 #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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // template<class Allocator>
 // basic_string_view(const basic_string<_CharT, _Traits, Allocator>& _str) noexcept
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <string>
 #include <cassert>
 
 struct dummy_char_traits : public std::char_traits<char> {};
 
 int main(int, char**) {
     using string_view = std::basic_string_view<char>;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // template<class Allocator>
 // basic_string_view(const basic_string<_CharT, _Traits, Allocator>& _str) noexcept
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <string>
 #include <cassert>
 
 struct dummy_char_traits : public std::char_traits<char> {};
 
 int main(int, char**) {
     using string_view = std::basic_string_view<char, dummy_char_traits>;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find(charT c, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_first_not_of(charT c, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // size_type find_first_not_of(const basic_string& str, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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_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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_first_of(charT c, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // size_type find_first_of(const basic_string_view& str, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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_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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // size_type find_last_not_of(charT c, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // size_type find_last_not_of(const basic_string& str, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_last_of(charT c, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // size_type find_last_of(const basic_string& str, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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_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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find(const charT* s, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find(const charT* s, size_type pos, size_type n) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type find(const basic_string_view& str, size_type pos = 0) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 // constexpr size_type rfind(charT c, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 // constexpr size_type rfind(const charT* s, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 // constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr size_type rfind(const basic_string& str, size_type pos = npos) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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);
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const_iterator begin() const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class S>
 void
 test(S s)

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const_iterator end() const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // const_iterator rbegin() const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class S>
 void
 test(S s)

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const_iterator rend() const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 
 template <class S>
 void

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // void remove_prefix(size_type _n)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::basic_string_view<CharT> SV;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // void remove_suffix(size_type _n)
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::basic_string_view<CharT> SV;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // void swap(basic_string_view& _other) noexcept
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::basic_string_view<CharT> SV;

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr int compare(const charT* s) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1,
 //             const charT* s, size_type n2) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
 //             size_type pos2, size_type n2) const;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr int compare(basic_string_view str) const noexcept;
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
 

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

 // 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.
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
 
 #include <string_view>
 #include <algorithm>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 

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
 //
 //===----------------------------------------------------------------------===//
 
 // <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).
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <algorithm>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename CharT>

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

 int main(int, char**)
 {
     {
     typedef std::string_view SV;
     const char *s = "abcde";
     SV  sv0 {};
     SV  sv1 { s + 4, 1 };
     SV  sv2 { s + 3, 2 };
-//     SV  sv3 { s + 2, 3 };
-//     SV  sv4 { s + 1, 4 };
-//     SV  sv5 { s    , 5 };
+    SV  sv3 { s + 2, 3 };
+    SV  sv4 { s + 1, 4 };
+    SV  sv5 { s    , 5 };
     SV  svNot {"def", 3 };
 
     LIBCPP_ASSERT_NOEXCEPT(sv0.ends_with(""));
 
     assert ( sv0.ends_with(""));
     assert (!sv0.ends_with("e"));
 
     assert ( sv1.ends_with(""));

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

 int main(int, char**)
 {
     {
     typedef std::string_view SV;
     const char *s = "abcde";
     SV  sv0 {};
     SV  sv1 { s, 1 };
     SV  sv2 { s, 2 };
-//     SV  sv3 { s, 3 };
-//     SV  sv4 { s, 4 };
-//     SV  sv5 { s, 5 };
+    SV  sv3 { s, 3 };
+    SV  sv4 { s, 4 };
+    SV  sv5 { s, 5 };
     SV  svNot {"def", 3 };
 
     LIBCPP_ASSERT_NOEXCEPT(sv0.starts_with(""));
 
     assert ( sv0.starts_with(""));
     assert (!sv0.starts_with("a"));
 
     assert ( sv1.starts_with(""));

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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 //   The string_views's value type must be the same as the traits's char_type
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #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
 //
 //===----------------------------------------------------------------------===//
 
 // P2251 was voted into C++23, but is supported even in C++17 mode by all vendors.
 
 // <string_view>
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <type_traits>
 
 #include "test_macros.h"
 
 static_assert(std::is_trivially_copyable<std::basic_string_view<char> >::value, "");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(std::is_trivially_copyable<std::basic_string_view<wchar_t> >::value, "");
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
 static_assert(std::is_trivially_copyable<std::basic_string_view<char8_t> >::value, "");
 #endif
 static_assert(std::is_trivially_copyable<std::basic_string_view<char16_t> >::value, "");
 static_assert(std::is_trivially_copyable<std::basic_string_view<char32_t> >::value, "");

libcxx/test/std/strings/string.view/types.pass.cpp

 //     using const_reverse_iterator    = reverse_iterator<const_iterator>;
 //     using iterator                  = const_reverse_iterator;
 //     using size_type                 = size_t;
 //     using difference_type           = ptrdiff_t;
 //     static constexpr size_type npos = size_type(-1);
 //
 // };
 
+// UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14)
+
 #include <string_view>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class Traits>
 void