[libc++] [test] Refactor string_view comparison tests for comprehensiveness.

[• Quuxplusone]

Summary

There are two commits here:

[libc++] [test] C++03-friendly MAKE_STRING macro.

Used in the new string_view test in this PR. (We support string_view in C++03. I don't object if we want to just stop doing that.)

[libc++] [test] Refactor string_view comparison tests for comprehensiveness.

[• Quuxplusone]

Fix TEST_HAS_NO_WIDE_CHARACTERS build, and remove some trailing whitespace.

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.comparison/opeq.pass.cpp

49–52 ↗

(On Diff #390125)

I expected these to fail-to-compile on clang-cl, for the reasons discussed (at length!) in D113161; but it didn't fail, at least not on buildkite. Strange.

[jloser]

libcxx/test/std/strings/string.view/string.view.comparison/opeq.pass.cpp

49–52 ↗

(On Diff #390125)

Any ideas why it doesn't fail on clang-cl on buildkit?

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.comparison/opeq.pass.cpp

49–52 ↗

(On Diff #390125)

Since these functions are small inline functions, they probably just get inlined everywhere, so the colliding symbols are never actually generated. I hypothesize that clang-cl might not bother to complain unless the symbols are actually generated (e.g. by taking the addresses of these functions, or by failing to inline them). Of course then I still don't understand why it was complaining in your case and not mine.

[Mordante]

Nice cleanup. I see quite a bit of repetition in the tests, but I don't see a simple way to avoid that.

libcxx/test/support/test_macros.h

154

As you already mentioned in your commit message these are unused and don't look too pretty. I would prefer to not add them until we really need them.

[• Quuxplusone]

Abandon the TEST_IS_CONSTANT_EVALUATED -> TEST_IS_RUNTIME refactoring, until it becomes needed.
Rebased. I'm calling this "ready for review."

[jloser]

Any idea what the existing motivation is to support string_view all the way back to C++03?

[ldionne]

In D114658#3157163, @jloser wrote:

Any idea what the existing motivation is to support string_view all the way back to C++03?

It was seen as a really useful type and at the time it was thought that it would be beneficial for users that are stuck in C++03 to be able to use this. After being bit by backporting features a couple of times, we don't do this anymore and we instead encourage people to upgrade to a newer version of the standard.

libcxx/test/std/strings/string.view/string.view.comparison/opge.pass.cpp

1 ↗

(On Diff #390212)

Can you name the new tests something less terse, e.g. equal.pass.cpp and so on?

libcxx/test/std/strings/string.view/string.view.comparison/opgt.pass.cpp

12 ↗

(On Diff #390212)

Nitpick. Applies elsewhere too.

libcxx/test/std/strings/string.view/string.view.comparison/opne.pass.cpp

48–52 ↗

(On Diff #390212)

Can you link to http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads so it's easy to see what you are testing for exhaustiveness? Same for other operators.

[• Quuxplusone]

Fix TEST_IS_CONSTEXPR for C++14/17.
Rename the new test files per @ldionne.

[Mordante]

LGTM!

[ldionne]

Thanks!

libcxx/test/std/strings/string.view/string.view.comparison/less_equal.pass.cpp

45

Here and in other places -- this is unusual.

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)
+
+#include <string_view>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+
+template<class T>
+struct ConvertibleTo {
+    T t_;
+    TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
+    TEST_CONSTEXPR operator T() const {
+        return t_;
+    }
+};
+
+template<class SV>
+TEST_CONSTEXPR_CXX14 bool test()
+{
+    typedef typename SV::value_type CharT;
+    typedef typename SV::traits_type Traits;
+
+    // Test the behavior of the operator, both with and without implicit conversions.
+    SV v[] = {
+        SV(MAKE_CSTRING(CharT, "")),
+        SV(MAKE_CSTRING(CharT, "abc")),
+        SV(MAKE_CSTRING(CharT, "abcdef")),
+        SV(MAKE_CSTRING(CharT, "acb")),
+    };
+    for (int i=0; i < 4; ++i) {
+        for (int j=0; j < 4; ++j) {
+            // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
+            bool expected = (i == j);
+            assert((v[i] == v[j]) == expected);
+            assert((v[i].data() == v[j]) == expected);
+            assert((v[i] == v[j].data()) == expected);
+            assert((ConvertibleTo<SV>(v[i]) == v[j]) == expected);
+            assert((v[i] == ConvertibleTo<SV>(v[j])) == expected);
+
+            if (!TEST_IS_CONSTANT_EVALUATED) {
+                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+                assert((std::basic_string<CharT, Traits>(v[i]) == v[j]) == expected);
+                assert((v[i] == std::basic_string<CharT, Traits>(v[j])) == expected);
+            }
+        }
+    }
+
+    // Test its behavior with embedded null bytes.
+    SV abc = SV(MAKE_CSTRING(CharT, "abc"));
+    SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
+    SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
+    assert((abc == abc0def) == false);
+    assert((abc == abcdef) == false);
+    assert((abc0def == abc) == false);
+    assert((abc0def == abcdef) == false);
+    assert((abcdef == abc) == false);
+    assert((abcdef == abc0def) == false);
+
+    assert((abc.data() == abc0def) == false);
+    assert((abc0def == abc.data()) == false);
+
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+        assert((std::basic_string<CharT, Traits>(abc) == abc0def) == false);
+        assert((abc0def == std::basic_string<CharT, Traits>(abc)) == false);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test<std::string_view>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring_view>();
+#endif
+#if TEST_STD_VER >= 11
+    test<std::u16string_view>();
+    test<std::u32string_view>();
+#endif
+#if TEST_STD_VER > 14
+    static_assert(test<std::string_view>(), "");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    static_assert(test<std::wstring_view>(), "");
+#endif
+    static_assert(test<std::u16string_view>(), "");
+    static_assert(test<std::u32string_view>(), "");
+#endif
+
+#if TEST_STD_VER > 11
+    test<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    static_assert(test<std::basic_string_view<char, constexpr_char_traits<char>>>(), "");
+#endif
+
+#if TEST_STD_VER > 17
+    test<std::u8string_view>();
+    static_assert(test<std::u8string_view>());
+#endif
+
+    return 0;
+}

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)
+
+#include <string_view>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+
+template<class T>
+struct ConvertibleTo {
+    T t_;
+    TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
+    TEST_CONSTEXPR operator T() const {
+        return t_;
+    }
+};
+
+template<class SV>
+TEST_CONSTEXPR_CXX14 bool test()
+{
+    typedef typename SV::value_type CharT;
+    typedef typename SV::traits_type Traits;
+
+    // Test the behavior of the operator, both with and without implicit conversions.
+    SV v[] = {
+        SV(MAKE_CSTRING(CharT, "")),
+        SV(MAKE_CSTRING(CharT, "abc")),
+        SV(MAKE_CSTRING(CharT, "abcdef")),
+        SV(MAKE_CSTRING(CharT, "acb")),
+    };
+    for (int i=0; i < 4; ++i) {
+        for (int j=0; j < 4; ++j) {
+            // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
+            bool expected = (i > j);
+            assert((v[i] > v[j]) == expected);
+            assert((v[i].data() > v[j]) == expected);
+            assert((v[i] > v[j].data()) == expected);
+            assert((ConvertibleTo<SV>(v[i]) > v[j]) == expected);
+            assert((v[i] > ConvertibleTo<SV>(v[j])) == expected);
+
+            if (!TEST_IS_CONSTANT_EVALUATED) {
+                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+                assert((std::basic_string<CharT, Traits>(v[i]) > v[j]) == expected);
+                assert((v[i] > std::basic_string<CharT, Traits>(v[j])) == expected);
+            }
+        }
+    }
+
+    // Test its behavior with embedded null bytes.
+    SV abc = SV(MAKE_CSTRING(CharT, "abc"));
+    SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
+    SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
+    assert((abc > abc0def) == false);
+    assert((abc > abcdef) == false);
+    assert((abc0def > abc) == true);
+    assert((abc0def > abcdef) == false);
+    assert((abcdef > abc) == true);
+    assert((abcdef > abc0def) == true);
+
+    assert((abc.data() > abc0def) == false);
+    assert((abc0def > abc.data()) == true);
+
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+        assert((std::basic_string<CharT, Traits>(abc) > abc0def) == false);
+        assert((abc0def > std::basic_string<CharT, Traits>(abc)) == true);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test<std::string_view>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring_view>();
+#endif
+#if TEST_STD_VER >= 11
+    test<std::u16string_view>();
+    test<std::u32string_view>();
+#endif
+#if TEST_STD_VER > 14
+    static_assert(test<std::string_view>(), "");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    static_assert(test<std::wstring_view>(), "");
+#endif
+    static_assert(test<std::u16string_view>(), "");
+    static_assert(test<std::u32string_view>(), "");
+#endif
+
+#if TEST_STD_VER > 11
+    test<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    static_assert(test<std::basic_string_view<char, constexpr_char_traits<char>>>(), "");
+#endif
+
+#if TEST_STD_VER > 17
+    test<std::u8string_view>();
+    static_assert(test<std::u8string_view>());
+#endif
+
+    return 0;
+}

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)
+
+#include <string_view>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+
+template<class T>
+struct ConvertibleTo {
+    T t_;
+    TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
+    TEST_CONSTEXPR operator T() const {
+        return t_;
+    }
+};
+
+template<class SV>
+TEST_CONSTEXPR_CXX14 bool test()
+{
+    typedef typename SV::value_type CharT;
+    typedef typename SV::traits_type Traits;
+
+    // Test the behavior of the operator, both with and without implicit conversions.
+    SV v[] = {
+        SV(MAKE_CSTRING(CharT, "")),
+        SV(MAKE_CSTRING(CharT, "abc")),
+        SV(MAKE_CSTRING(CharT, "abcdef")),
+        SV(MAKE_CSTRING(CharT, "acb")),
+    };
+    for (int i=0; i < 4; ++i) {
+        for (int j=0; j < 4; ++j) {
+            // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
+            bool expected = (i >= j);
+            assert((v[i] >= v[j]) == expected);
+            assert((v[i].data() >= v[j]) == expected);
+            assert((v[i] >= v[j].data()) == expected);
+            assert((ConvertibleTo<SV>(v[i]) >= v[j]) == expected);
+            assert((v[i] >= ConvertibleTo<SV>(v[j])) == expected);
+
+            if (!TEST_IS_CONSTANT_EVALUATED) {
+                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+                assert((std::basic_string<CharT, Traits>(v[i]) >= v[j]) == expected);
+                assert((v[i] >= std::basic_string<CharT, Traits>(v[j])) == expected);
+            }
+        }
+    }
+
+    // Test its behavior with embedded null bytes.
+    SV abc = SV(MAKE_CSTRING(CharT, "abc"));
+    SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
+    SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
+    assert((abc >= abc0def) == false);
+    assert((abc >= abcdef) == false);
+    assert((abc0def >= abc) == true);
+    assert((abc0def >= abcdef) == false);
+    assert((abcdef >= abc) == true);
+    assert((abcdef >= abc0def) == true);
+
+    assert((abc.data() >= abc0def) == false);
+    assert((abc0def >= abc.data()) == true);
+
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+        assert((std::basic_string<CharT, Traits>(abc) >= abc0def) == false);
+        assert((abc0def >= std::basic_string<CharT, Traits>(abc)) == true);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test<std::string_view>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring_view>();
+#endif
+#if TEST_STD_VER >= 11
+    test<std::u16string_view>();
+    test<std::u32string_view>();
+#endif
+#if TEST_STD_VER > 14
+    static_assert(test<std::string_view>(), "");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    static_assert(test<std::wstring_view>(), "");
+#endif
+    static_assert(test<std::u16string_view>(), "");
+    static_assert(test<std::u32string_view>(), "");
+#endif
+
+#if TEST_STD_VER > 11
+    test<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    static_assert(test<std::basic_string_view<char, constexpr_char_traits<char>>>(), "");
+#endif
+
+#if TEST_STD_VER > 17
+    test<std::u8string_view>();
+    static_assert(test<std::u8string_view>());
+#endif
+
+    return 0;
+}

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)
+
+#include <string_view>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+
+template<class T>
+struct ConvertibleTo {
+    T t_;
+    TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
+    TEST_CONSTEXPR operator T() const {
+        return t_;
+    }
+};
+
+template<class SV>
+TEST_CONSTEXPR_CXX14 bool test()
+{
+    typedef typename SV::value_type CharT;
+    typedef typename SV::traits_type Traits;
+
+    // Test the behavior of the operator, both with and without implicit conversions.
+    SV v[] = {
+        SV(MAKE_CSTRING(CharT, "")),
+        SV(MAKE_CSTRING(CharT, "abc")),
+        SV(MAKE_CSTRING(CharT, "abcdef")),
+        SV(MAKE_CSTRING(CharT, "acb")),
+    };
+    for (int i=0; i < 4; ++i) {
+        for (int j=0; j < 4; ++j) {
+            // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
+            bool expected = (i < j);
+            assert((v[i] < v[j]) == expected);
+            assert((v[i].data() < v[j]) == expected);
+            assert((v[i] < v[j].data()) == expected);
+            assert((ConvertibleTo<SV>(v[i]) < v[j]) == expected);
+            assert((v[i] < ConvertibleTo<SV>(v[j])) == expected);
+
+            if (!TEST_IS_CONSTANT_EVALUATED) {
+                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+                assert((std::basic_string<CharT, Traits>(v[i]) < v[j]) == expected);
+                assert((v[i] < std::basic_string<CharT, Traits>(v[j])) == expected);
+            }
+        }
+    }
+
+    // Test its behavior with embedded null bytes.
+    SV abc = SV(MAKE_CSTRING(CharT, "abc"));
+    SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
+    SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
+    assert((abc < abc0def) == true);
+    assert((abc < abcdef) == true);
+    assert((abc0def < abc) == false);
+    assert((abc0def < abcdef) == true);
+    assert((abcdef < abc) == false);
+    assert((abcdef < abc0def) == false);
+
+    assert((abc.data() < abc0def) == true);
+    assert((abc0def < abc.data()) == false);
+
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+        assert((std::basic_string<CharT, Traits>(abc) < abc0def) == true);
+        assert((abc0def < std::basic_string<CharT, Traits>(abc)) == false);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test<std::string_view>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring_view>();
+#endif
+#if TEST_STD_VER >= 11
+    test<std::u16string_view>();
+    test<std::u32string_view>();
+#endif
+#if TEST_STD_VER > 14
+    static_assert(test<std::string_view>(), "");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    static_assert(test<std::wstring_view>(), "");
+#endif
+    static_assert(test<std::u16string_view>(), "");
+    static_assert(test<std::u32string_view>(), "");
+#endif
+
+#if TEST_STD_VER > 11
+    test<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    static_assert(test<std::basic_string_view<char, constexpr_char_traits<char>>>(), "");
+#endif
+
+#if TEST_STD_VER > 17
+    test<std::u8string_view>();
+    static_assert(test<std::u8string_view>());
+#endif
+
+    return 0;
+}

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)
+
+#include <string_view>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+
+template<class T>
+struct ConvertibleTo {
+    T t_;
+    TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
+    TEST_CONSTEXPR operator T() const {
+        return t_;
+    }
+};
+
+template<class SV>
+TEST_CONSTEXPR_CXX14 bool test()
+{
+    typedef typename SV::value_type CharT;
+    typedef typename SV::traits_type Traits;
+
+    // Test the behavior of the operator, both with and without implicit conversions.
+    SV v[] = {
+        SV(MAKE_CSTRING(CharT, "")),
+        SV(MAKE_CSTRING(CharT, "abc")),
+        SV(MAKE_CSTRING(CharT, "abcdef")),
+        SV(MAKE_CSTRING(CharT, "acb")),
+    };
+    for (int i=0; i < 4; ++i) {
+        for (int j=0; j < 4; ++j) {
+            // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
+            bool expected = (i <= j);
+            assert((v[i] <= v[j]) == expected);
+            assert((v[i].data() <= v[j]) == expected);
+            assert((v[i] <= v[j].data()) == expected);
+            assert((ConvertibleTo<SV>(v[i]) <= v[j]) == expected);
+            assert((v[i] <= ConvertibleTo<SV>(v[j])) == expected);
+
+            if (!TEST_IS_CONSTANT_EVALUATED) {
+                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+                assert((std::basic_string<CharT, Traits>(v[i]) <= v[j]) == expected);
+                assert((v[i] <= std::basic_string<CharT, Traits>(v[j])) == expected);
+            }
+        }
+    }
+
+    // Test its behavior with embedded null bytes.
+    SV abc = SV(MAKE_CSTRING(CharT, "abc"));
+    SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
+    SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
+    assert((abc <= abc0def) == true);
+    assert((abc <= abcdef) == true);
+    assert((abc0def <= abc) == false);
+    assert((abc0def <= abcdef) == true);
+    assert((abcdef <= abc) == false);
+    assert((abcdef <= abc0def) == false);
+
+    assert((abc.data() <= abc0def) == true);
+    assert((abc0def <= abc.data()) == false);
+
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+        assert((std::basic_string<CharT, Traits>(abc) <= abc0def) == true);
+        assert((abc0def <= std::basic_string<CharT, Traits>(abc)) == false);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test<std::string_view>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring_view>();
+#endif
+#if TEST_STD_VER >= 11
+    test<std::u16string_view>();
+    test<std::u32string_view>();
+#endif
+#if TEST_STD_VER > 14
+    static_assert(test<std::string_view>(), "");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    static_assert(test<std::wstring_view>(), "");
+#endif
+    static_assert(test<std::u16string_view>(), "");
+    static_assert(test<std::u32string_view>(), "");
+#endif
+
+#if TEST_STD_VER > 11
+    test<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    static_assert(test<std::basic_string_view<char, constexpr_char_traits<char>>>(), "");
+#endif
+
+#if TEST_STD_VER > 17
+    test<std::u8string_view>();
+    static_assert(test<std::u8string_view>());
+#endif
+
+    return 0;
+}

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)
+
+#include <string_view>
+#include <cassert>
+#include <string>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+
+template<class T>
+struct ConvertibleTo {
+    T t_;
+    TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
+    TEST_CONSTEXPR operator T() const {
+        return t_;
+    }
+};
+
+template<class SV>
+TEST_CONSTEXPR_CXX14 bool test()
+{
+    typedef typename SV::value_type CharT;
+    typedef typename SV::traits_type Traits;
+
+    // Test the behavior of the operator, both with and without implicit conversions.
+    SV v[] = {
+        SV(MAKE_CSTRING(CharT, "")),
+        SV(MAKE_CSTRING(CharT, "abc")),
+        SV(MAKE_CSTRING(CharT, "abcdef")),
+        SV(MAKE_CSTRING(CharT, "acb")),
+    };
+    for (int i=0; i < 4; ++i) {
+        for (int j=0; j < 4; ++j) {
+            // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
+            bool expected = (i != j);
+            assert((v[i] != v[j]) == expected);
+            assert((v[i].data() != v[j]) == expected);
+            assert((v[i] != v[j].data()) == expected);
+            assert((ConvertibleTo<SV>(v[i]) != v[j]) == expected);
+            assert((v[i] != ConvertibleTo<SV>(v[j])) == expected);
+
+            if (!TEST_IS_CONSTANT_EVALUATED) {
+                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+                assert((std::basic_string<CharT, Traits>(v[i]) != v[j]) == expected);
+                assert((v[i] != std::basic_string<CharT, Traits>(v[j])) == expected);
+            }
+        }
+    }
+
+    // Test its behavior with embedded null bytes.
+    SV abc = SV(MAKE_CSTRING(CharT, "abc"));
+    SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
+    SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
+    assert((abc != abc0def) == true);
+    assert((abc != abcdef) == true);
+    assert((abc0def != abc) == true);
+    assert((abc0def != abcdef) == true);
+    assert((abcdef != abc) == true);
+    assert((abcdef != abc0def) == true);
+
+    assert((abc.data() != abc0def) == true);
+    assert((abc0def != abc.data()) == true);
+
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+        assert((std::basic_string<CharT, Traits>(abc) != abc0def) == true);
+        assert((abc0def != std::basic_string<CharT, Traits>(abc)) == true);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test<std::string_view>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring_view>();
+#endif
+#if TEST_STD_VER >= 11
+    test<std::u16string_view>();
+    test<std::u32string_view>();
+#endif
+#if TEST_STD_VER > 14
+    static_assert(test<std::string_view>(), "");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    static_assert(test<std::wstring_view>(), "");
+#endif
+    static_assert(test<std::u16string_view>(), "");
+    static_assert(test<std::u32string_view>(), "");
+#endif
+
+#if TEST_STD_VER > 11
+    test<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    static_assert(test<std::basic_string_view<char, constexpr_char_traits<char>>>(), "");
+#endif
+
+#if TEST_STD_VER > 17
+    test<std::u8string_view>();
+    static_assert(test<std::u8string_view>());
+#endif
+
+    return 0;
+}

libcxx/test/std/strings/string.view/string.view.comparison/opeq.string_view.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>
-
-// template<class charT, class traits>
-//   constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs);
-// template<class charT, class traits>
-//   constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(S lhs, const typename S::value_type* rhs, bool x)
-{
-    assert((lhs == rhs) == x);
-    assert((rhs == lhs) == x);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), "", true);
-    test(S(""), "abcde", false);
-    test(S(""), "abcdefghij", false);
-    test(S(""), "abcdefghijklmnopqrst", false);
-    test(S("abcde"), "", false);
-    test(S("abcde"), "abcde", true);
-    test(S("abcde"), "abcdefghij", false);
-    test(S("abcde"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghij"), "", false);
-    test(S("abcdefghij"), "abcde", false);
-    test(S("abcdefghij"), "abcdefghij", true);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghijklmnopqrst"), "", false);
-    test(S("abcdefghijklmnopqrst"), "abcde", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-    static_assert (  sv1     == "", "" );
-    static_assert (  ""      == sv1, "" );
-    static_assert (!(sv1     == "abcde"), "" );
-    static_assert (!("abcde" == sv1), "" );
-
-    static_assert (  sv2      == "abcde", "" );
-    static_assert (  "abcde"  == sv2, "" );
-    static_assert (!(sv2      == "abcde0"), "" );
-    static_assert (!("abcde0" == sv2), "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opeq.string_view.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 charT, class traits, class Allocator>
-//   bool operator==(const charT* lhs, const basic_string<charT,traits> rhs);
-// template<class charT, class traits, class Allocator>
-//   bool operator==(const basic_string_view<charT,traits> lhs, const CharT* rhs);
-
-#include <string_view>
-#include <string>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class S>
-void
-test(const std::string &lhs, S rhs, bool x)
-{
-    assert((lhs == rhs) == x);
-    assert((rhs == lhs) == x);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test("", S(""), true);
-    test("", S("abcde"), false);
-    test("", S("abcdefghij"), false);
-    test("", S("abcdefghijklmnopqrst"), false);
-    test("abcde", S(""), false);
-    test("abcde", S("abcde"), true);
-    test("abcde", S("abcdefghij"), false);
-    test("abcde", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghij", S(""), false);
-    test("abcdefghij", S("abcde"), false);
-    test("abcdefghij", S("abcdefghij"), true);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghijklmnopqrst", S(""), false);
-    test("abcdefghijklmnopqrst", S("abcde"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opeq.string_view.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
-//
-//===----------------------------------------------------------------------===//
-
-// <string_view>
-
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator==(const basic_string_view<charT,traits> lhs,
-//                   const basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(S lhs, S rhs, bool x)
-{
-    assert((lhs == rhs) == x);
-    assert((rhs == lhs) == x);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), S(""), true);
-    test(S(""), S("abcde"), false);
-    test(S(""), S("abcdefghij"), false);
-    test(S(""), S("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), S(""), false);
-    test(S("abcde"), S("abcde"), true);
-    test(S("abcde"), S("abcdefghij"), false);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), S(""), false);
-    test(S("abcdefghij"), S("abcde"), false);
-    test(S("abcdefghij"), S("abcdefghij"), true);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), S(""), false);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2;
-    constexpr SV  sv3 { "abcde", 5 };
-    static_assert (  sv1 == sv2, "" );
-    static_assert (!(sv1 == sv3), "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opge.string_view.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>
-
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator>=(const charT* lhs, basic_string_view<charT,traits> rhs);
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator>=(basic_string_view<charT,traits> lhs, const charT* rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs >= rhs) == x);
-    assert((rhs >= lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test("", S(""), true, true);
-    test("", S("abcde"), false, true);
-    test("", S("abcdefghij"), false, true);
-    test("", S("abcdefghijklmnopqrst"), false, true);
-    test("abcde", S(""), true, false);
-    test("abcde", S("abcde"), true, true);
-    test("abcde", S("abcdefghij"), false, true);
-    test("abcde", S("abcdefghijklmnopqrst"), false, true);
-    test("abcdefghij", S(""), true, false);
-    test("abcdefghij", S("abcde"), true, false);
-    test("abcdefghij", S("abcdefghij"), true, true);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), false, true);
-    test("abcdefghijklmnopqrst", S(""), true, false);
-    test("abcdefghijklmnopqrst", S("abcde"), true, false);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), true, false);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (  sv1     >= "", "" );
-    static_assert (  ""      >= sv1, "" );
-    static_assert (!(sv1     >= "abcde"), "" );
-    static_assert (  "abcde" >= sv1, "" );
-
-    static_assert (  sv2      >= "", "" );
-    static_assert (!(""       >= sv2), "" );
-    static_assert (  sv2      >= "abcde", "" );
-    static_assert (  "abcde"  >= sv2, "" );
-    static_assert (!(sv2      >= "abcde0"), "" );
-    static_assert (  "abcde0" >= sv2, "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opge.string_view.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 charT, class traits, class Allocator>
-//   bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
-//                   basic_string_view<charT,traits> rhs);
-//   bool operator>=(basic_string_view<charT,traits> lhs,
-//            const basic_string<charT,traits,Allocator>&  rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class S>
-void
-test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
-{
-    assert((lhs >= rhs) == x);
-    assert((rhs >= lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), "", true, true);
-    test(S(""), "abcde", false, true);
-    test(S(""), "abcdefghij", false, true);
-    test(S(""), "abcdefghijklmnopqrst", false, true);
-    test(S("abcde"), "", true, false);
-    test(S("abcde"), "abcde", true, true);
-    test(S("abcde"), "abcdefghij", false, true);
-    test(S("abcde"), "abcdefghijklmnopqrst", false, true);
-    test(S("abcdefghij"), "", true, false);
-    test(S("abcdefghij"), "abcde", true, false);
-    test(S("abcdefghij"), "abcdefghij", true, true);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", false, true);
-    test(S("abcdefghijklmnopqrst"), "", true, false);
-    test(S("abcdefghijklmnopqrst"), "abcde", true, false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", true, false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true, true);
-    }
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opge.string_view.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
-//
-//===----------------------------------------------------------------------===//
-
-// <string_view>
-
-// template<class charT, class traits>
-//   constexpr bool operator>=(basic_string_view<charT,traits> lhs,
-//                  basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const S& lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs >= rhs) == x);
-    assert((rhs >= lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), S(""), true, true);
-    test(S(""), S("abcde"), false, true);
-    test(S(""), S("abcdefghij"), false, true);
-    test(S(""), S("abcdefghijklmnopqrst"), false, true);
-    test(S("abcde"), S(""), true, false);
-    test(S("abcde"), S("abcde"), true, true);
-    test(S("abcde"), S("abcdefghij"), false, true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), false, true);
-    test(S("abcdefghij"), S(""), true, false);
-    test(S("abcdefghij"), S("abcde"), true, false);
-    test(S("abcdefghij"), S("abcdefghij"), true, true);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true);
-    test(S("abcdefghijklmnopqrst"), S(""), true, false);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true, false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (  sv1 >= sv1,  "" );
-    static_assert (  sv2 >= sv2,  "" );
-
-    static_assert (!(sv1 >= sv2), "" );
-    static_assert (  sv2 >= sv1,  "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opgt.string_view.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 template<class charT, class traits, class Allocator>
-//   bool operator>(const charT* lhs, basic_string_view<charT,traits> rhs);
-// constexpr template<class charT, class traits, class Allocator>
-//   bool operator>(basic_string_view<charT,traits> lhs, const charT* rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs > rhs) == x);
-    assert((rhs > lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test("", S(""), false, false);
-    test("", S("abcde"), false, true);
-    test("", S("abcdefghij"), false, true);
-    test("", S("abcdefghijklmnopqrst"), false, true);
-    test("abcde", S(""), true, false);
-    test("abcde", S("abcde"), false, false);
-    test("abcde", S("abcdefghij"), false, true);
-    test("abcde", S("abcdefghijklmnopqrst"), false, true);
-    test("abcdefghij", S(""), true, false);
-    test("abcdefghij", S("abcde"), true, false);
-    test("abcdefghij", S("abcdefghij"), false, false);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), false, true);
-    test("abcdefghijklmnopqrst", S(""), true, false);
-    test("abcdefghijklmnopqrst", S("abcde"), true, false);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), true, false);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (!(sv1     > ""), "" );
-    static_assert (!(""      > sv1), "" );
-    static_assert (!(sv1     > "abcde"), "" );
-    static_assert (  "abcde" > sv1, "" );
-
-    static_assert (  sv2      > "", "" );
-    static_assert (!(""       > sv2), "" );
-    static_assert (!(sv2      > "abcde"), "" );
-    static_assert (!("abcde"  > sv2), "" );
-    static_assert (!(sv2      > "abcde0"), "" );
-    static_assert (  "abcde0" > sv2, "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opgt.string_view.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 charT, class traits, class Allocator>
-//   bool operator>(const basic_string<charT,traits,Allocator>& lhs,
-//                   basic_string_view<charT,traits> rhs);
-//   bool operator>(basic_string_view<charT,traits> lhs,
-//            const basic_string<charT,traits,Allocator>&  rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class S>
-void
-test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
-{
-    assert((lhs > rhs) == x);
-    assert((rhs > lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), "", false, false);
-    test(S(""), "abcde", false, true);
-    test(S(""), "abcdefghij", false, true);
-    test(S(""), "abcdefghijklmnopqrst", false, true);
-    test(S("abcde"), "", true, false);
-    test(S("abcde"), "abcde", false, false);
-    test(S("abcde"), "abcdefghij", false, true);
-    test(S("abcde"), "abcdefghijklmnopqrst", false, true);
-    test(S("abcdefghij"), "", true, false);
-    test(S("abcdefghij"), "abcde", true, false);
-    test(S("abcdefghij"), "abcdefghij", false, false);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", false, true);
-    test(S("abcdefghijklmnopqrst"), "", true, false);
-    test(S("abcdefghijklmnopqrst"), "abcde", true, false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", true, false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false, false);
-    }
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opgt.string_view.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
-//
-//===----------------------------------------------------------------------===//
-
-// <string_view>
-
-// template<class charT, class traits>
-//  constexpr bool operator>(basic_string_view<charT,traits> lhs,
-//                  basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const S& lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs > rhs) == x);
-    assert((rhs > lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), S(""), false, false);
-    test(S(""), S("abcde"), false, true);
-    test(S(""), S("abcdefghij"), false, true);
-    test(S(""), S("abcdefghijklmnopqrst"), false, true);
-    test(S("abcde"), S(""), true, false);
-    test(S("abcde"), S("abcde"), false, false);
-    test(S("abcde"), S("abcdefghij"), false, true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), false, true);
-    test(S("abcdefghij"), S(""), true, false);
-    test(S("abcdefghij"), S("abcde"), true, false);
-    test(S("abcdefghij"), S("abcdefghij"), false, false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true);
-    test(S("abcdefghijklmnopqrst"), S(""), true, false);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true, false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (!(sv1 > sv1), "" );
-    static_assert (!(sv2 > sv2), "" );
-
-    static_assert (!(sv1 > sv2), "" );
-    static_assert (  sv2 > sv1, "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/ople.string_view.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>
-
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator<=(const charT* lhs, basic_string_view<charT,traits> rhs);
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator<=(basic_string_view<charT,traits> lhs, const charT* rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs <= rhs) == x);
-    assert((rhs <= lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test("", S(""), true, true);
-    test("", S("abcde"), true, false);
-    test("", S("abcdefghij"), true, false);
-    test("", S("abcdefghijklmnopqrst"), true, false);
-    test("abcde", S(""), false, true);
-    test("abcde", S("abcde"), true, true);
-    test("abcde", S("abcdefghij"), true, false);
-    test("abcde", S("abcdefghijklmnopqrst"), true, false);
-    test("abcdefghij", S(""), false, true);
-    test("abcdefghij", S("abcde"), false, true);
-    test("abcdefghij", S("abcdefghij"), true, true);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), true, false);
-    test("abcdefghijklmnopqrst", S(""), false, true);
-    test("abcdefghijklmnopqrst", S("abcde"), false, true);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), false, true);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (  sv1     <= "", "" );
-    static_assert (  ""      <= sv1, "" );
-    static_assert (  sv1     <= "abcde", "" );
-    static_assert (!("abcde" <= sv1), "" );
-
-    static_assert (!(sv2      <= ""), "" );
-    static_assert (  ""       <= sv2, "" );
-    static_assert (  sv2      <= "abcde", "" );
-    static_assert (  "abcde"  <= sv2, "" );
-    static_assert (  sv2      <= "abcde0", "" );
-    static_assert (!("abcde0" <= sv2), "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/ople.string_view.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 charT, class traits, class Allocator>
-//   bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
-//                   basic_string_view<charT,traits> rhs);
-//   bool operator<=(basic_string_view<charT,traits> lhs,
-//            const basic_string<charT,traits,Allocator>&  rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class S>
-void
-test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
-{
-    assert((lhs <= rhs) == x);
-    assert((rhs <= lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), "", true, true);
-    test(S(""), "abcde", true, false);
-    test(S(""), "abcdefghij", true, false);
-    test(S(""), "abcdefghijklmnopqrst", true, false);
-    test(S("abcde"), "", false, true);
-    test(S("abcde"), "abcde", true, true);
-    test(S("abcde"), "abcdefghij", true, false);
-    test(S("abcde"), "abcdefghijklmnopqrst", true, false);
-    test(S("abcdefghij"), "", false, true);
-    test(S("abcdefghij"), "abcde", false, true);
-    test(S("abcdefghij"), "abcdefghij", true, true);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", true, false);
-    test(S("abcdefghijklmnopqrst"), "", false, true);
-    test(S("abcdefghijklmnopqrst"), "abcde", false, true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", false, true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true, true);
-    }
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/ople.string_view.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
-//
-//===----------------------------------------------------------------------===//
-
-// <string_view>
-
-// template<class charT, class traits>
-//   constexpr bool operator<=(basic_string_view<charT,traits> lhs,
-//                  basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const S& lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs <= rhs) == x);
-    assert((rhs <= lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), S(""), true, true);
-    test(S(""), S("abcde"), true, false);
-    test(S(""), S("abcdefghij"), true, false);
-    test(S(""), S("abcdefghijklmnopqrst"), true, false);
-    test(S("abcde"), S(""), false, true);
-    test(S("abcde"), S("abcde"), true, true);
-    test(S("abcde"), S("abcdefghij"), true, false);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true, false);
-    test(S("abcdefghij"), S(""), false, true);
-    test(S("abcdefghij"), S("abcde"), false, true);
-    test(S("abcdefghij"), S("abcdefghij"), true, true);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false);
-    test(S("abcdefghijklmnopqrst"), S(""), false, true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), false, true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (  sv1 <= sv1,  "" );
-    static_assert (  sv2 <= sv2,  "" );
-
-    static_assert (  sv1 <= sv2,  "" );
-    static_assert (!(sv2 <= sv1), "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/oplt.string_view.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>
-
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator<(const charT* lhs, basic_string_view<charT,traits> rhs);
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator<(basic_string_view<charT,traits> lhs, const charT* rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs < rhs) == x);
-    assert((rhs < lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test("", S(""), false, false);
-    test("", S("abcde"), true, false);
-    test("", S("abcdefghij"), true, false);
-    test("", S("abcdefghijklmnopqrst"), true, false);
-    test("abcde", S(""), false, true);
-    test("abcde", S("abcde"), false, false);
-    test("abcde", S("abcdefghij"), true, false);
-    test("abcde", S("abcdefghijklmnopqrst"), true, false);
-    test("abcdefghij", S(""), false, true);
-    test("abcdefghij", S("abcde"), false, true);
-    test("abcdefghij", S("abcdefghij"), false, false);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), true, false);
-    test("abcdefghijklmnopqrst", S(""), false, true);
-    test("abcdefghijklmnopqrst", S("abcde"), false, true);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), false, true);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (!(sv1     < ""), "" );
-    static_assert (!(""      < sv1), "" );
-    static_assert (  sv1     < "abcde", "" );
-    static_assert (!("abcde" < sv1), "" );
-
-    static_assert (!(sv2      < ""), "" );
-    static_assert (  ""       < sv2, "" );
-    static_assert (!(sv2      < "abcde"), "" );
-    static_assert (!("abcde"  < sv2), "" );
-    static_assert (  sv2      < "abcde0", "" );
-    static_assert (!("abcde0" < sv2), "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/oplt.string_view.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 charT, class traits, class Allocator>
-//   bool operator<(const basic_string<charT,traits,Allocator>& lhs,
-//                   basic_string_view<charT,traits> rhs);
-//   bool operator<(basic_string_view<charT,traits> lhs,
-//            const basic_string<charT,traits,Allocator>&  rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class S>
-void
-test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
-{
-    assert((lhs < rhs) == x);
-    assert((rhs < lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), "", false, false);
-    test(S(""), "abcde", true, false);
-    test(S(""), "abcdefghij", true, false);
-    test(S(""), "abcdefghijklmnopqrst", true, false);
-    test(S("abcde"), "", false, true);
-    test(S("abcde"), "abcde", false, false);
-    test(S("abcde"), "abcdefghij", true, false);
-    test(S("abcde"), "abcdefghijklmnopqrst", true, false);
-    test(S("abcdefghij"), "", false, true);
-    test(S("abcdefghij"), "abcde", false, true);
-    test(S("abcdefghij"), "abcdefghij", false, false);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", true, false);
-    test(S("abcdefghijklmnopqrst"), "", false, true);
-    test(S("abcdefghijklmnopqrst"), "abcde", false, true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", false, true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false, false);
-    }
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/oplt.string_view.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
-//
-//===----------------------------------------------------------------------===//
-
-// <string_view>
-
-// template<class charT, class traits>
-//   constexpr bool operator<(basic_string_view<charT,traits> lhs,
-//                  basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(const S& lhs, const S& rhs, bool x, bool y)
-{
-    assert((lhs < rhs) == x);
-    assert((rhs < lhs) == y);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), S(""), false, false);
-    test(S(""), S("abcde"), true, false);
-    test(S(""), S("abcdefghij"), true, false);
-    test(S(""), S("abcdefghijklmnopqrst"), true, false);
-    test(S("abcde"), S(""), false, true);
-    test(S("abcde"), S("abcde"), false, false);
-    test(S("abcde"), S("abcdefghij"), true, false);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true, false);
-    test(S("abcdefghij"), S(""), false, true);
-    test(S("abcdefghij"), S("abcde"), false, true);
-    test(S("abcdefghij"), S("abcdefghij"), false, false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false);
-    test(S("abcdefghijklmnopqrst"), S(""), false, true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), false, true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (!(sv1 < sv1), "" );
-    static_assert (!(sv2 < sv2), "" );
-
-    static_assert (  sv1 < sv2,  "" );
-    static_assert (!(sv2 < sv1), "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opne.string_view.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>
-
-// template<class charT, class traits>
-//   constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs);
-// template<class charT, class traits>
-//   constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(S lhs, const typename S::value_type* rhs, bool x)
-{
-    assert((lhs != rhs) == x);
-    assert((rhs != lhs) == x);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), "", false);
-    test(S(""), "abcde", true);
-    test(S(""), "abcdefghij", true);
-    test(S(""), "abcdefghijklmnopqrst", true);
-    test(S("abcde"), "", true);
-    test(S("abcde"), "abcde", false);
-    test(S("abcde"), "abcdefghij", true);
-    test(S("abcde"), "abcdefghijklmnopqrst", true);
-    test(S("abcdefghij"), "", true);
-    test(S("abcdefghij"), "abcde", true);
-    test(S("abcdefghij"), "abcdefghij", false);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
-    test(S("abcdefghijklmnopqrst"), "", true);
-    test(S("abcdefghijklmnopqrst"), "abcde", true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2 { "abcde", 5 };
-
-    static_assert (!(sv1     != ""), "" );
-    static_assert (!(""      != sv1), "" );
-    static_assert (  sv1     != "abcde", "" );
-    static_assert (  "abcde" != sv1, "" );
-
-    static_assert (!(sv2      != "abcde"), "" );
-    static_assert (!("abcde"  != sv2), "" );
-    static_assert (  sv2      != "abcde0",   "" );
-    static_assert (  "abcde0" != sv2, "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opne.string_view.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 charT, class traits, class Allocator>
-//   bool operator!=(const basic_string<charT, traits, Allocator> &lhs, basic_string_view<charT,traits> rhs);
-// template<class charT, class traits, class Allocator>
-//   bool operator!=(basic_string_view<charT,traits> lhs, const basic_string<charT, traits, Allocator> &rhs);
-
-#include <string_view>
-#include <string>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class S>
-void
-test(const std::string &lhs, S rhs, bool x)
-{
-    assert((lhs != rhs) == x);
-    assert((rhs != lhs) == x);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test("", S(""), false);
-    test("", S("abcde"), true);
-    test("", S("abcdefghij"), true);
-    test("", S("abcdefghijklmnopqrst"), true);
-    test("abcde", S(""), true);
-    test("abcde", S("abcde"), false);
-    test("abcde", S("abcdefghij"), true);
-    test("abcde", S("abcdefghijklmnopqrst"), true);
-    test("abcdefghij", S(""), true);
-    test("abcdefghij", S("abcde"), true);
-    test("abcdefghij", S("abcdefghij"), false);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), true);
-    test("abcdefghijklmnopqrst", S(""), true);
-    test("abcdefghijklmnopqrst", S("abcde"), true);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), true);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.comparison/opne.string_view.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
-//
-//===----------------------------------------------------------------------===//
-
-// <string_view>
-
-// template<class charT, class traits, class Allocator>
-//   constexpr bool operator!=(const basic_string_view<charT,traits> lhs,
-//                   const basic_string_view<charT,traits> rhs);
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-#include "constexpr_char_traits.h"
-
-template <class S>
-void
-test(S lhs, S rhs, bool x)
-{
-    assert((lhs != rhs) == x);
-    assert((rhs != lhs) == x);
-}
-
-int main(int, char**)
-{
-    {
-    typedef std::string_view S;
-    test(S(""), S(""), false);
-    test(S(""), S("abcde"), true);
-    test(S(""), S("abcdefghij"), true);
-    test(S(""), S("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), S(""), true);
-    test(S("abcde"), S("abcde"), false);
-    test(S("abcde"), S("abcdefghij"), true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), S(""), true);
-    test(S("abcdefghij"), S("abcde"), true);
-    test(S("abcdefghij"), S("abcdefghij"), false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), S(""), true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
-
-#if TEST_STD_VER > 11
-    {
-    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
-    constexpr SV  sv1;
-    constexpr SV  sv2;
-    constexpr SV  sv3 { "abcde", 5 };
-    static_assert (!( sv1 != sv2), "" );
-    static_assert (   sv1 != sv3,  "" );
-    }
-#endif
-
-  return 0;
-}

libcxx/test/support/make_string.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUPPORT_TEST_MAKE_STRING_H
 #define SUPPORT_TEST_MAKE_STRING_H
 
 #include "test_macros.h"
 
-#if TEST_STD_VER < 11
-#error This header requires C++11 or greater
-#endif
-
 #include <string>
 #include <string_view>
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+# define MKSTR_WCHAR_ONLY(...) __VA_ARGS__
+# define MKSTR_AS_WCHAR_LITERAL(x) TEST_CONCAT(L, x), sizeof(TEST_CONCAT(L, x)) / sizeof(wchar_t) - 1
+#else
+# define MKSTR_WCHAR_ONLY(...)
+#endif
+
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-#define CHAR8_ONLY(x) x,
+#define MKSTR_CHAR8_ONLY(...) __VA_ARGS__
+#define MKSTR_AS_U8_LITERAL(x) TEST_CONCAT(u8, x), sizeof(TEST_CONCAT(u8, x)) / sizeof(char8_t) - 1
 #else
-#define CHAR8_ONLY(x)
+#define MKSTR_CHAR8_ONLY(...)
 #endif
 
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-# define IF_WIDE_CHARACTERS(...) __VA_ARGS__
+#if TEST_STD_VER >= 11
+#define MKSTR_CXX11_ONLY(...) __VA_ARGS__
+#define MKSTR_AS_U16_LITERAL(x) TEST_CONCAT(u, x), sizeof(TEST_CONCAT(u, x)) / sizeof(char16_t) - 1
+#define MKSTR_AS_U32_LITERAL(x) TEST_CONCAT(U, x), sizeof(TEST_CONCAT(U, x)) / sizeof(char32_t) - 1
 #else
-# define IF_WIDE_CHARACTERS(...) /* nothing */
+#define MKSTR_CXX11_ONLY(...)
 #endif
 
-#define MKSTR(Str)                                                             \
-  {                                                                            \
-    Str, IF_WIDE_CHARACTERS(TEST_CONCAT(L, Str),)                              \
-        CHAR8_ONLY(TEST_CONCAT(u8, Str)) TEST_CONCAT(u, Str),                  \
-        TEST_CONCAT(U, Str)                                                    \
-  }
+#define MKSTR(Str) MultiStringType(                \
+    MKSTR_WCHAR_ONLY(MKSTR_AS_WCHAR_LITERAL(Str),) \
+    MKSTR_CHAR8_ONLY(MKSTR_AS_U8_LITERAL(Str),)    \
+    MKSTR_CXX11_ONLY(MKSTR_AS_U16_LITERAL(Str),    \
+                     MKSTR_AS_U32_LITERAL(Str),)   \
+    Str, sizeof(Str) - 1                           \
+  )
 
-struct MultiStringType {
-  const char* s;
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  const wchar_t* w;
-#endif
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-  const char8_t* u8;
-#endif
-  const char16_t* u16;
-  const char32_t* u32;
+#define MKSTR_LEN(CharT, Str) MKSTR(Str).length((const CharT*)0)
 
-  constexpr operator const char*() const { return s; }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  constexpr operator const wchar_t*() const { return w; }
-#endif
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-  constexpr operator const char8_t*() const { return u8; }
-#endif
-  constexpr operator const char16_t*() const { return u16; }
-  constexpr operator const char32_t*() const { return u32; }
+struct MultiStringType {
+  MKSTR_WCHAR_ONLY(const wchar_t* w_; size_t wn_; )
+  MKSTR_CHAR8_ONLY(const char8_t* u8_; size_t u8n_; )
+  MKSTR_CXX11_ONLY(const char16_t* u16_; size_t u16n_; )
+  MKSTR_CXX11_ONLY(const char32_t* u32_; size_t u32n_; )
+  const char* s_; size_t sn_;
+
+  TEST_CONSTEXPR MultiStringType(
+      MKSTR_WCHAR_ONLY(const wchar_t *w, size_t wn,)
+      MKSTR_CHAR8_ONLY(const char8_t *u8, size_t u8n,)
+      MKSTR_CXX11_ONLY(const char16_t *u16, size_t u16n,)
+      MKSTR_CXX11_ONLY(const char32_t *u32, size_t u32n,)
+      const char *s, size_t sn)
+    : MKSTR_WCHAR_ONLY(w_(w), wn_(wn),)
+      MKSTR_CHAR8_ONLY(u8_(u8), u8n_(u8n),)
+      MKSTR_CXX11_ONLY(u16_(u16), u16n_(u16n),)
+      MKSTR_CXX11_ONLY(u32_(u32), u32n_(u32n),)
+      s_(s), sn_(sn) {}
+
+  TEST_CONSTEXPR const char *as_ptr(const char*) const { return s_; }
+  MKSTR_WCHAR_ONLY(TEST_CONSTEXPR const wchar_t *as_ptr(const wchar_t*) const { return w_; })
+  MKSTR_CHAR8_ONLY(constexpr const char8_t *as_ptr(const char8_t*) const { return u8_; })
+  MKSTR_CXX11_ONLY(constexpr const char16_t *as_ptr(const char16_t*) const { return u16_; })
+  MKSTR_CXX11_ONLY(constexpr const char32_t *as_ptr(const char32_t*) const { return u32_; })
+
+  TEST_CONSTEXPR size_t length(const char*) const { return sn_; }
+  MKSTR_WCHAR_ONLY(TEST_CONSTEXPR size_t length(const wchar_t*) const { return wn_; })
+  MKSTR_CHAR8_ONLY(constexpr size_t length(const char8_t*) const { return u8n_; })
+  MKSTR_CXX11_ONLY(constexpr size_t length(const char16_t*) const { return u16n_; })
+  MKSTR_CXX11_ONLY(constexpr size_t length(const char32_t*) const { return u32n_; })
+
+  // These implicit conversions are used by some tests. TODO: maybe eliminate them?
+  TEST_CONSTEXPR operator const char*() const { return s_; }
+  MKSTR_WCHAR_ONLY(TEST_CONSTEXPR operator const wchar_t*() const { return w_; })
+  MKSTR_CHAR8_ONLY(constexpr operator const char8_t*() const { return u8_; })
+  MKSTR_CXX11_ONLY(constexpr operator const char16_t*() const { return u16_; })
+  MKSTR_CXX11_ONLY(constexpr operator const char32_t*() const { return u32_; })
 };
 
-// Helper to convert a const char* string to a basic_string<CharT>.
+// Helper to convert a const char* string to a const CharT*.
 // This helper is used in unit tests to make them generic. The input should be
 // valid ASCII which means the input is also valid UTF-8.
+#define MAKE_CSTRING(CharT, Str)                                               \
+  MKSTR(Str).as_ptr((const CharT*)0)
+
+// Like MAKE_CSTRING but makes a basic_string<CharT>. Embedded nulls are OK.
 #define MAKE_STRING(CharT, Str)                                                \
-  std::basic_string<CharT> {                                                   \
-    static_cast<const CharT*>(MultiStringType MKSTR(Str))                      \
-  }
+  std::basic_string<CharT>(MAKE_CSTRING(CharT, Str), MKSTR_LEN(CharT, Str))
 
+// Like MAKE_CSTRING but makes a basic_string_view<CharT>. Embedded nulls are OK.
 #define MAKE_STRING_VIEW(CharT, Str)                                           \
-  std::basic_string_view<CharT> {                                              \
-    static_cast<const CharT*>(MultiStringType MKSTR(Str))                      \
-  }
-
-// Like MAKE_STRING but converts to a const CharT*.
-#define MAKE_CSTRING(CharT, Str)                                               \
-  static_cast<const CharT*>(MultiStringType MKSTR(Str))
+  std::basic_string_view<CharT>(MAKE_CSTRING(CharT, Str), MKSTR_LEN(CharT, Str))
 
 #endif

libcxx/test/support/test_macros.h

 
 #if TEST_STD_VER >= 11
 # define TEST_THROW_SPEC(...)
 #else
 # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
 #if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
-#  define TEST_IS_CONSTANT_EVALUATED std::is_constant_evaluated()
+# define TEST_IS_CONSTANT_EVALUATED std::is_constant_evaluated()
+#elif __has_builtin(__builtin_is_constant_evaluated)
+# define TEST_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
 #else
-#  define TEST_IS_CONSTANT_EVALUATED false
+# define TEST_IS_CONSTANT_EVALUATED false
 #endif
 
 #if TEST_STD_VER >= 14
 # define TEST_CONSTEXPR_CXX14 constexpr
 #else
 # define TEST_CONSTEXPR_CXX14
 #endif
 
 #if TEST_STD_VER >= 17