[libcxx] adds consistent comparison for `basic_string`

[cjdb]

Summary

• Removes operator!= and inequality operators for basic_string (in C++20 mode).
• Adds operator<=> for basic_string (in C++20 mode).

Implements parts of P1614 'The Mothership Has Landed'.

Depends on D80891.

[miscco]

libcxx/include/string

362

I think we should not delete them from the synopsis as they are used in pre C++20 mode. You could mark them with until C++17 and then spaceship with C++20

3948

I think you are missing this specialization below. That said, I am unsure whether this is actually needed at all.

[cjdb]

Applies @miscco's suggestions.

libcxx/include/string

362

Thanks! I was wondering how to address this problem...

3948

I assume Howard had his reasons, so I've moved it outside of the block, just in case. Will delete at someone's request.

[miscco]

libcxx/include/string

3948

That sounds reasonable. Thanks!

[curdeius]

libcxx/include/string

417

Shouldn't notes like "(Until C++17)" be just trailing comments?

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/pointer_string.pass.cpp

36

I may be missing something, but it seems that there are no tests for the basic cases like:
"abc" < "acb"
"cba" > "aaa"
All (non-equal) tests fall into the shorter/longer check.

[cjdb]

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/pointer_string.pass.cpp

36

Done. I also added these tests to the inequality tests.

[cjdb]

Ping.

[curdeius]

libcxx/include/string

362

You changed the order of parameters and now this overload is the same as the one below.
And BTW, why removing spaces in <...>? :)

365

I think you should mark the overloads removed in C++20 as removed in C++20 or until C++17 instead of just C++17 as the latter is misleading.

418

Return type is not bool -> see below in standard.

422

This overload doesn't seem to be marked noexcept by the standard: http://eel.is/c++draft/string.syn.

422

Where is the return type? Standard marks it as see below.

3970

I think you should just use noexcept instead of _NOEXCEPT as it should be always available in C++20.

4008

This _NOEXCEPT should be kept as is of course.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/pointer_string.pass.cpp

14

bool?

36

Great!

[cjdb]

Needs rebase, etc.

[cjdb]

rebases to activate CI and get on people's radar

[• Quuxplusone]

@cjdb: I think you should go ahead and land the additions to "libcxx/test/std/strings/basic.string/string.nonmembers/" (other than ".../string_opcmp/", obviously). These look like good additions to the test suite, and should pass both before and after your spaceship-related changes. (It is mildly shocking that the old test suite lacked any tests where one operand was not a prefix of the other.)

libcxx/include/string

3946

Either remove [[nodiscard]] (the easy path), or replace it with _LIBCPP_NODISCARD_EXT and put a libcxx/test/libcxx/ test on it.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_string.pass.cpp

14

This comment suggests to me that we should have a new allocation-focused test that verifies that the comparison does no allocations (i.e. that we don't do it by converting the string_view to string, or anything equally dumb). And it should test all seven comparison operators in all modes. But this is largely orthogonal to this patch and could be done in a separate PR. I'll volunteer myself for it if you don't want it.

Separately, I think we need some tests for comparing wstring and maybe even u8string. As string comparison's relationship to char_traits gets more complicated, our existing lack of wstring tests becomes more glaring. This is also largely orthogonal to this patch, and would affect the existing tests for < > <= >= == !=.

25

I don't understand why you pass strong_ordering::foo but then implicitly convert it to weak_ordering here. Do we expect string::operator<=> to return weak_ordering? Why?
I suggest

template<class S, class O>
constexpr void test(const S& lhs, const S& rhs, O expected)
{
    auto actual = (lhs <=> rhs);
    ASSERT_SAME_TYPE(decltype(actual), decltype(expected));
    assert(actual == expected);
}

60

Bizarre whitespace between basic_string and <. I guess it's for consistency with "string_string_view.pass.cpp" line 61; but I'd lose the whitespace in both cases.

[cjdb]

In D80895#2751401, @Quuxplusone wrote:

@cjdb: I think you should go ahead and land the additions to "libcxx/test/std/strings/basic.string/string.nonmembers/" (other than ".../string_opcmp/", obviously). These look like good additions to the test suite, and should pass both before and after your spaceship-related changes.

SGTM, gimme an hour or so.

(It is mildly shocking that the old test suite lacked any tests where one operand was not a prefix of the other.)

If you think that's shocking, check out our container comparison tests.

libcxx/include/string

3946

It's still unclear to me why _LIBCPP_NODISCARD_EXT is desirable over an attribute users can already disable.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_string.pass.cpp

14

This comment suggests to me that we should have a new allocation-focused test that verifies that the comparison does no allocations (i.e. that we don't do it by converting the string_view to string, or anything equally dumb). And it should test all seven comparison operators in all modes. But this is largely orthogonal to this patch and could be done in a separate PR. I'll volunteer myself for it if you don't want it.

If you're concerned about std::string_view(x) doing an allocation: that should be a part of the string_view test suite, not the string comparison suite.
If you're concerned about an arbitrary allocation happening, then I'm not sure how we'd go about doing that in a feasible manner (why would we do this for comparison, and not string::clear, for example?).
Regardless of what you're wanting here, I'm happy to review when the time comes.

Separately, I think we need some tests for comparing wstring and maybe even u8string. As string comparison's relationship to char_traits gets more complicated, our existing lack of wstring tests becomes more glaring. This is also largely orthogonal to this patch, and would affect the existing tests for < > <= >= == !=.

This is a reasonable request, but since we don't have these tests for the other operators, I wonder if it'd be better to do this in a separate patch as one unit (i.e. after this patch lands, but not long after).

25

See below for a whole set of tests. The proposed change sounds reasonable to me: will fix in an hour or so.

[Mordante]

Do these changes require updating the status of papers?

libcxx/include/string

3946

The [[nodiscard]] is an extension, can you the _LIBCPP_NODISCARD_EXT macro and add it to the list extensions.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/pointer_string.pass.cpp

14

Please address the comment above.

32

Can you turn the test into a templated test and test with all allowed string types?
The support header make_string.h has some macros that will be useful for these tests.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_pointer.pass.cpp

15

Please use bool.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_string.pass.cpp

13

Please add the function being tested.

[• Quuxplusone]

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_pointer.pass.cpp

15

No, operator<=> isn't bool though! It's one of the ordering types, and apparently depends on _Traits (so even changing auto to std::strong_ordering wouldn't be right). I think auto is fine.

[cjdb]

libcxx/include/string

3946

This doesn't answer my question. Most attributes don't change the meaning of a program, so it doesn't make sense to me why this macro is useful at all. Unless I'm grepping wrong, we don't have a _LIBCPP_NOEXCEPT_EXT macro for when the standard doesn't put noexcept on things. Why is [[nodiscard]] any different? This is at least my fourth time asking this question without an answer; I'd appreciate one please.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/pointer_string.pass.cpp

14

@curdeius was asking why it was bool, because it shouldn't be, so I've already addressed it.

32

Not sure I understand what you're asking for, but let's take this up on Discord.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_string.pass.cpp

13

There isn't a function that's being tested. See the comment below.

[zoecarver]

libcxx/include/string

3946

This is C++20 mode, so we can probably assume that all compilers support [[nodiscard]], however, and this is a more general rule of thumb, if we decide that it would be beneficial to put [[nodiscard]] somewhere, we should probably use _LIBCPP_NODISCARD_ATTRIBUTE or _LIBCPP_NOEXCEPT_EXT because it works on more platforms (i.e., [[clang::warn_unused_result]] on earlier versions of clang).

For places where the standard doesn't specifically ask us to use nodiscard, I think for now at least, it still makes sense to use _LIBCPP_NODISCARD_EXT (we can have a discussion at some point about retiring this attribute, if you'd like). This allows users to disable [[nodiscard]] if it's causing problems, or they don't want to use it for some reason. We can argue about the merits of such a configuration, but it's something that we have in libc++, and we shouldn't pull the rug from under people, at least not without discussion first.

In the future you can generally look at the definition of such macros to see why they're useful, etc.

[cjdb]

libcxx/include/string

3946

This is C++20 mode, so we can probably assume that all compilers support [[nodiscard]], however, and this is a more general rule of thumb, if we decide that it would be beneficial to put [[nodiscard]] somewhere, we should probably use _LIBCPP_NODISCARD_ATTRIBUTE or _LIBCPP_NOEXCEPT_EXT because it works on more platforms (i.e., [[clang::warn_unused_result]] on earlier versions of clang).

Aren't we now only supporting as far back as LLVM ${CURRENT_VERSION}-2? That would mean this patch only needs to worry about LLVM 11+, and this attribute has been supported since Clang 3.9.

For places where the standard doesn't specifically ask us to use nodiscard, I think for now at least, it still makes sense to use _LIBCPP_NODISCARD_EXT (we can have a discussion at some point about retiring this attribute, if you'd like). This allows users to disable [[nodiscard]] if it's causing problems, or they don't want to use it for some reason. We can argue about the merits of such a configuration, but it's something that we have in libc++, and we shouldn't pull the rug from under people, at least not without discussion first.

In the future you can generally look at the definition of such macros to see why they're useful, etc.

This still doesn't address my original question. Given -Wno-unused-result turns off [[nodiscard]], and is present on both Clang and GCC, I don't see why we want to have two ways to toggle the same thing.

[Mordante]

libcxx/include/string

3946

This doesn't answer my question.

True when I started my review these comments weren't there yet, so our messages crossed.

The problem isn't the compiler support. The problem is that this function isn't declared as [[nodiscard]] in the Standard. In that case we use _LIBCPP_NOEXCEPT_EXT. See https://libcxx.llvm.org/docs/UsingLibcxx.html#libc-extensions for more information. I hope that clarifies the issue.

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_pointer.pass.cpp

15

Good point.

[cjdb]

libcxx/include/string

3946

We seem to be going in circles. You're saying "we need to use _LIBCPP_NOEXCEPT_EXT because it's an extension and the user might want to disable it". I'm saying "they already can, with -Wno-unused-result: why do we need two ways to do this?", to which the collective reply seems to be "we need to use _LIBCPP_NOEXCEPT_EXT because it's an extension and the user might want to disable it".

This document (which I'd read before initially asking why) doesn't address my question either.

libcxx/include/string

 operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
 
 template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
 
 template<class charT, class traits, class Allocator>
 bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                           const basic_string<charT, traits, Allocator>& rhs) noexcept;
 
 template<class charT, class traits, class Allocator>
-bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
+bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;
 
 template<class charT, class traits, class Allocator>
-bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;
+bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
 bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;
+                const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
+bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
+bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
 bool operator< (const basic_string<charT, traits, Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;
+                const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
+bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
+bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
 bool operator> (const basic_string<charT, traits, Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;
+                const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
+bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
+bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
+bool operator<=(const basic_string<charT, traits, Allocator>& lhs, // C++17
                 const basic_string<charT, traits, Allocator>& rhs) noexcept;
 
 template<class charT, class traits, class Allocator>
-bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
+bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
+bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
 
 template<class charT, class traits, class Allocator>
-bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
+bool operator>=(const basic_string<charT, traits, Allocator>& lhs, // C++17
                 const basic_string<charT, traits, Allocator>& rhs) noexcept;
 
 template<class charT, class traits, class Allocator>
-bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
+bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; // C++17
+
+template<class charT, class traits, class Allocator>
+bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++17
+
+template<class charT, class traits, class Allocator>
+bool operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+                 const basic_string<charT, traits, Allocator>& rhs) noexcept; // C++20
 
 template<class charT, class traits, class Allocator>
-bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
+operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; // C++20
 
 template<class charT, class traits, class Allocator>
 void swap(basic_string<charT, traits, Allocator>& lhs,
           basic_string<charT, traits, Allocator>& rhs)
             noexcept(noexcept(lhs.swap(rhs)));
 
 template<class charT, class traits, class Allocator>
 basic_istream<charT, traits>&
basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
     {
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
         __set_long_cap(0);
         __set_short_size(0);
     }
 }
 
 // operator==
-
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    size_t __lhs_sz = __lhs.size();
-    return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
-                                                        __rhs.data(),
-                                                        __lhs_sz) == 0;
-}
-
 template<class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
            const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
 {
     size_t __lhs_sz = __lhs.size();
     if (__lhs_sz != __rhs.size())
         return false;
     const char* __lp = __lhs.data();
     const char* __rp = __rhs.data();
     if (__lhs.__is_long())
         return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
     for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
         if (*__lp != *__rp)
             return false;
     return true;
 }
 
+#if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+// operator==
+template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+{
+    return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
+}
+
+template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+           const _CharT* __rhs) _NOEXCEPT
+{
+    return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
+}
+
+// operator<=>
+template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+auto
+operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+{
+    return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
+}
+
+template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+auto
+operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+            const _CharT* __rhs) _NOEXCEPT
+{
+    return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
+}
+#else
+// operator==
+template<class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+{
+    size_t __lhs_sz = __lhs.size();
+    return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
+                                                        __rhs.data(),
+                                                        __lhs_sz) == 0;
+}
+
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     typedef basic_string<_CharT, _Traits, _Allocator> _String;
     _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");

 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return !(__lhs < __rhs);
 }
+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 
 // operator +
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
           const basic_string<_CharT, _Traits, _Allocator>& __rhs)
 {

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/pointer_string.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<class charT, class traits, class Allocator>
+//   bool operator<=>(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
+
+#include <string>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+void
+test(const typename S::value_type* lhs, const S& rhs, std::weak_ordering x)
+{
+    assert((lhs <=> rhs) == x);
+}
+
+
+int main(int, char**)
+{
+    {
+    typedef std::string S;
+    test("abc", S("acb"), std::strong_ordering::less);
+    test("acb", S("abc"), std::strong_ordering::greater);
+    test("aaa", S("cba"), std::strong_ordering::less);
+    test("cba", S("aaa"), std::strong_ordering::greater);
+    }
+    {
+    typedef std::string S;
+    test("", S(""), std::strong_ordering::equal);
+    test("", S("abcde"), std::strong_ordering::less);
+    test("", S("abcdefghij"), std::strong_ordering::less);
+    test("", S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test("abcde", S(""), std::strong_ordering::greater);
+    test("abcde", S("abcde"), std::strong_ordering::equal);
+    test("abcde", S("abcdefghij"), std::strong_ordering::less);
+    test("abcde", S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test("abcdefghij", S(""), std::strong_ordering::greater);
+    test("abcdefghij", S("abcde"), std::strong_ordering::greater);
+    test("abcdefghij", S("abcdefghij"), std::strong_ordering::equal);
+    test("abcdefghij", S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test("abcdefghijklmnopqrst", S(""), std::strong_ordering::greater);
+    test("abcdefghijklmnopqrst", S("abcde"), std::strong_ordering::greater);
+    test("abcdefghijklmnopqrst", S("abcdefghij"), std::strong_ordering::greater);
+    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), std::strong_ordering::equal);
+    }
+
+    {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test("", S(""), std::weak_ordering::equivalent);
+    test("", S("abcde"), std::weak_ordering::less);
+    test("", S("abcdefghij"), std::weak_ordering::less);
+    test("", S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test("abcde", S(""), std::weak_ordering::greater);
+    test("abcde", S("abcde"), std::weak_ordering::equivalent);
+    test("abcde", S("abcdefghij"), std::weak_ordering::less);
+    test("abcde", S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test("abcdefghij", S(""), std::weak_ordering::greater);
+    test("abcdefghij", S("abcde"), std::weak_ordering::greater);
+    test("abcdefghij", S("abcdefghij"), std::weak_ordering::equivalent);
+    test("abcdefghij", S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test("abcdefghijklmnopqrst", S(""), std::weak_ordering::greater);
+    test("abcdefghijklmnopqrst", S("abcde"), std::weak_ordering::greater);
+    test("abcdefghijklmnopqrst", S("abcdefghij"), std::weak_ordering::greater);
+    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), std::weak_ordering::equivalent);
+    }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<class charT, class traits, class Allocator>
+//   bool operator>(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
+
+#include <string>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+void
+test(const S& lhs, const typename S::value_type* rhs, std::weak_ordering x)
+{
+    assert((lhs <=> rhs) == x);
+}
+
+int main(int, char**)
+{
+    {
+    typedef std::string S;
+    test(S("abc"), "acb", std::strong_ordering::less);
+    test(S("acb"), "abc", std::strong_ordering::greater);
+    test(S("aaa"), "cba", std::strong_ordering::less);
+    test(S("cba"), "aaa", std::strong_ordering::greater);
+    }
+    {
+    typedef std::string S;
+    test(S(""), "", std::strong_ordering::equal);
+    test(S(""), "abcde", std::strong_ordering::less);
+    test(S(""), "abcdefghij", std::strong_ordering::less);
+    test(S(""), "abcdefghijklmnopqrst", std::strong_ordering::less);
+    test(S("abcde"), "", std::strong_ordering::greater);
+    test(S("abcde"), "abcde", std::strong_ordering::equal);
+    test(S("abcde"), "abcdefghij", std::strong_ordering::less);
+    test(S("abcde"), "abcdefghijklmnopqrst", std::strong_ordering::less);
+    test(S("abcdefghij"), "", std::strong_ordering::greater);
+    test(S("abcdefghij"), "abcde", std::strong_ordering::greater);
+    test(S("abcdefghij"), "abcdefghij", std::strong_ordering::equal);
+    test(S("abcdefghij"), "abcdefghijklmnopqrst", std::strong_ordering::less);
+    test(S("abcdefghijklmnopqrst"), "", std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), "abcde", std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), "abcdefghij", std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", std::strong_ordering::equal);
+    }
+
+    {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S(""), "", std::weak_ordering::equivalent);
+    test(S(""), "abcde", std::weak_ordering::less);
+    test(S(""), "abcdefghij", std::weak_ordering::less);
+    test(S(""), "abcdefghijklmnopqrst", std::weak_ordering::less);
+    test(S("abcde"), "", std::weak_ordering::greater);
+    test(S("abcde"), "abcde", std::weak_ordering::equivalent);
+    test(S("abcde"), "abcdefghij", std::weak_ordering::less);
+    test(S("abcde"), "abcdefghijklmnopqrst", std::weak_ordering::less);
+    test(S("abcdefghij"), "", std::weak_ordering::greater);
+    test(S("abcdefghij"), "abcde", std::weak_ordering::greater);
+    test(S("abcdefghij"), "abcdefghij", std::weak_ordering::equivalent);
+    test(S("abcdefghij"), "abcdefghijklmnopqrst", std::weak_ordering::less);
+    test(S("abcdefghijklmnopqrst"), "", std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), "abcde", std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), "abcdefghij", std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", std::weak_ordering::equivalent);
+    }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_string.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// we get this comparison "for free" because the string implicitly converts to the string_view
+
+#include <string>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+void
+test(const S& lhs, const S& rhs, std::weak_ordering x)
+{
+    assert((lhs <=> rhs) == x);
+}
+
+int main(int, char**)
+{
+    {
+    typedef std::string S;
+    test(S("abc"), S("acb"), std::strong_ordering::less);
+    test(S("acb"), S("abc"), std::strong_ordering::greater);
+    test(S("aaa"), S("cba"), std::strong_ordering::less);
+    test(S("cba"), S("aaa"), std::strong_ordering::greater);
+    }
+    {
+    typedef std::string S;
+    test(S(""), S(""), std::strong_ordering::equal);
+    test(S(""), S("abcde"), std::strong_ordering::less);
+    test(S(""), S("abcdefghij"), std::strong_ordering::less);
+    test(S(""), S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(S("abcde"), S(""), std::strong_ordering::greater);
+    test(S("abcde"), S("abcde"), std::strong_ordering::equal);
+    test(S("abcde"), S("abcdefghij"), std::strong_ordering::less);
+    test(S("abcde"), S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(S("abcdefghij"), S(""), std::strong_ordering::greater);
+    test(S("abcdefghij"), S("abcde"), std::strong_ordering::greater);
+    test(S("abcdefghij"), S("abcdefghij"), std::strong_ordering::equal);
+    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(S("abcdefghijklmnopqrst"), S(""), std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S("abcde"), std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), std::strong_ordering::equal);
+    }
+
+    {
+    typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
+    test(S(""), S(""), std::weak_ordering::equivalent);
+    test(S(""), S("abcde"), std::weak_ordering::less);
+    test(S(""), S("abcdefghij"), std::weak_ordering::less);
+    test(S(""), S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(S("abcde"), S(""), std::weak_ordering::greater);
+    test(S("abcde"), S("abcde"), std::weak_ordering::equivalent);
+    test(S("abcde"), S("abcdefghij"), std::weak_ordering::less);
+    test(S("abcde"), S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(S("abcdefghij"), S(""), std::weak_ordering::greater);
+    test(S("abcdefghij"), S("abcde"), std::weak_ordering::greater);
+    test(S("abcdefghij"), S("abcdefghij"), std::weak_ordering::equivalent);
+    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(S("abcdefghijklmnopqrst"), S(""), std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S("abcde"), std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), std::weak_ordering::equivalent);
+    }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/string_string_view.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// we get this comparison "for free" because the string implicitly converts to the string_view
+
+#include <string>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& lhs, SV rhs, std::weak_ordering x)
+{
+    assert((lhs <=> rhs) == x);
+}
+
+int main(int, char**)
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test(S("abc"), SV("acb"), std::strong_ordering::less);
+    test(S("acb"), SV("abc"), std::strong_ordering::greater);
+    test(S("aaa"), SV("cba"), std::strong_ordering::less);
+    test(S("cba"), SV("aaa"), std::strong_ordering::greater);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test(S(""), SV(""), std::strong_ordering::equal);
+    test(S(""), SV("abcde"), std::strong_ordering::less);
+    test(S(""), SV("abcdefghij"), std::strong_ordering::less);
+    test(S(""), SV("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(S("abcde"), SV(""), std::strong_ordering::greater);
+    test(S("abcde"), SV("abcde"), std::strong_ordering::equal);
+    test(S("abcde"), SV("abcdefghij"), std::strong_ordering::less);
+    test(S("abcde"), SV("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(S("abcdefghij"), SV(""), std::strong_ordering::greater);
+    test(S("abcdefghij"), SV("abcde"), std::strong_ordering::greater);
+    test(S("abcdefghij"), SV("abcdefghij"), std::strong_ordering::equal);
+    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(S("abcdefghijklmnopqrst"), SV(""), std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), SV("abcde"), std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), std::strong_ordering::equal);
+    }
+
+    {
+    typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::basic_string_view<char, std::char_traits<char>> SV;
+    test(S(""), SV(""), std::weak_ordering::equivalent);
+    test(S(""), SV("abcde"), std::weak_ordering::less);
+    test(S(""), SV("abcdefghij"), std::weak_ordering::less);
+    test(S(""), SV("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(S("abcde"), SV(""), std::weak_ordering::greater);
+    test(S("abcde"), SV("abcde"), std::weak_ordering::equivalent);
+    test(S("abcde"), SV("abcdefghij"), std::weak_ordering::less);
+    test(S("abcde"), SV("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(S("abcdefghij"), SV(""), std::weak_ordering::greater);
+    test(S("abcdefghij"), SV("abcde"), std::weak_ordering::greater);
+    test(S("abcdefghij"), SV("abcdefghij"), std::weak_ordering::equivalent);
+    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(S("abcdefghijklmnopqrst"), SV(""), std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), SV("abcde"), std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), std::weak_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), std::weak_ordering::equivalent);
+    }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.nonmembers/string_opcmp/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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// we get this comparison "for free" because the string implicitly converts to the string_view
+
+#include <string>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class SV, class S>
+void
+test(SV lhs, const S& rhs, std::weak_ordering x)
+{
+    assert((lhs <=> rhs) == x);
+}
+
+int main(int, char**)
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test(SV("abc"), S("acb"), std::strong_ordering::less);
+    test(SV("acb"), S("abc"), std::strong_ordering::greater);
+    test(SV("aaa"), S("cba"), std::strong_ordering::less);
+    test(SV("cba"), S("aaa"), std::strong_ordering::greater);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test(SV(""), S(""), std::strong_ordering::equal);
+    test(SV(""), S("abcde"), std::strong_ordering::less);
+    test(SV(""), S("abcdefghij"), std::strong_ordering::less);
+    test(SV(""), S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(SV("abcde"), S(""), std::strong_ordering::greater);
+    test(SV("abcde"), S("abcde"), std::strong_ordering::equal);
+    test(SV("abcde"), S("abcdefghij"), std::strong_ordering::less);
+    test(SV("abcde"), S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(SV("abcdefghij"), S(""), std::strong_ordering::greater);
+    test(SV("abcdefghij"), S("abcde"), std::strong_ordering::greater);
+    test(SV("abcdefghij"), S("abcdefghij"), std::strong_ordering::equal);
+    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), std::strong_ordering::less);
+    test(SV("abcdefghijklmnopqrst"), S(""), std::strong_ordering::greater);
+    test(SV("abcdefghijklmnopqrst"), S("abcde"), std::strong_ordering::greater);
+    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), std::strong_ordering::greater);
+    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), std::strong_ordering::equal);
+    }
+
+    {
+    typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::basic_string_view<char, std::char_traits<char>> SV;
+    test(SV(""), S(""), std::weak_ordering::equivalent);
+    test(SV(""), S("abcde"), std::weak_ordering::less);
+    test(SV(""), S("abcdefghij"), std::weak_ordering::less);
+    test(SV(""), S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(SV("abcde"), S(""), std::weak_ordering::greater);
+    test(SV("abcde"), S("abcde"), std::weak_ordering::equivalent);
+    test(SV("abcde"), S("abcdefghij"), std::weak_ordering::less);
+    test(SV("abcde"), S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(SV("abcdefghij"), S(""), std::weak_ordering::greater);
+    test(SV("abcdefghij"), S("abcde"), std::weak_ordering::greater);
+    test(SV("abcdefghij"), S("abcdefghij"), std::weak_ordering::equivalent);
+    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), std::weak_ordering::less);
+    test(SV("abcdefghijklmnopqrst"), S(""), std::weak_ordering::greater);
+    test(SV("abcdefghijklmnopqrst"), S("abcde"), std::weak_ordering::greater);
+    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), std::weak_ordering::greater);
+    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), std::weak_ordering::equivalent);
+    }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp

 {
     assert((lhs > rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test("abc", S("acb"), false);
+    test("acb", S("abc"), true);
+    test("aaa", S("cba"), false);
+    test("cba", S("aaa"), true);
+    }
+    {
+    typedef std::string S;
     test("", S(""), false);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp

 {
     assert((lhs > rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), "acb", false);
+    test(S("acb"), "abc", true);
+    test(S("aaa"), "cba", false);
+    test(S("cba"), "aaa", true);
+    }
+    {
+    typedef std::string S;
     test(S(""), "", false);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp

 {
     assert((lhs > rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), S("acb"), false);
+    test(S("acb"), S("abc"), true);
+    test(S("aaa"), S("cba"), false);
+    test(S("cba"), S("aaa"), true);
+    }
+    {
+    typedef std::string S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp

test(const S& lhs, SV rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(S("abc"), SV("acb"), false);
+    test(S("acb"), SV("abc"), true);
+    test(S("aaa"), SV("cba"), false);
+    test(S("cba"), SV("aaa"), true);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp

test(SV lhs, const S& rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(SV("abc"), S("acb"), false);
+    test(SV("acb"), S("abc"), true);
+    test(SV("aaa"), S("cba"), false);
+    test(SV("cba"), S("aaa"), true);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp

 {
     assert((lhs >= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test("abc", S("acb"), false);
+    test("acb", S("abc"), true);
+    test("aaa", S("cba"), false);
+    test("cba", S("aaa"), true);
+    }
+    {
+    typedef std::string S;
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp

 {
     assert((lhs >= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), "acb", false);
+    test(S("acb"), "abc", true);
+    test(S("aaa"), "cba", false);
+    test(S("cba"), "aaa", true);
+    }
+    {
+    typedef std::string S;
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp

 {
     assert((lhs >= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), S("acb"), false);
+    test(S("acb"), S("abc"), true);
+    test(S("aaa"), S("cba"), false);
+    test(S("cba"), S("aaa"), true);
+    }
+    {
+    typedef std::string S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp

test(const S& lhs, SV rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(S("abc"), SV("acb"), false);
+    test(S("acb"), SV("abc"), true);
+    test(S("aaa"), SV("cba"), false);
+    test(S("cba"), SV("aaa"), true);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp

test(SV lhs, const S& rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(SV("abc"), S("acb"), false);
+    test(SV("acb"), S("abc"), true);
+    test(SV("aaa"), S("cba"), false);
+    test(SV("cba"), S("aaa"), true);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp

 {
     assert((lhs < rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test("abc", S("acb"), true);
+    test("acb", S("abc"), false);
+    test("aaa", S("cba"), true);
+    test("cba", S("aaa"), false);
+    }
+    {
+    typedef std::string S;
     test("", S(""), false);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp

 {
     assert((lhs < rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), "acb", true);
+    test(S("acb"), "abc", false);
+    test(S("aaa"), "cba", true);
+    test(S("cba"), "aaa", false);
+    }
+    {
+    typedef std::string S;
     test(S(""), "", false);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp

 {
     assert((lhs < rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), S("acb"), true);
+    test(S("acb"), S("abc"), false);
+    test(S("aaa"), S("cba"), true);
+    test(S("cba"), S("aaa"), false);
+    }
+    {
+    typedef std::string S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp

test(const S& lhs, SV rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(S("abc"), SV("acb"), true);
+    test(S("acb"), SV("abc"), false);
+    test(S("aaa"), SV("cba"), true);
+    test(S("cba"), SV("aaa"), false);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp

test(SV lhs, const S& rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(SV("abc"), S("acb"), true);
+    test(SV("acb"), S("abc"), false);
+    test(SV("aaa"), S("cba"), true);
+    test(SV("cba"), S("aaa"), false);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp

 {
     assert((lhs <= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test("abc", S("acb"), true);
+    test("acb", S("abc"), false);
+    test("aaa", S("cba"), true);
+    test("cba", S("aaa"), false);
+    }
+    {
+    typedef std::string S;
     test("", S(""), true);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp

 {
     assert((lhs <= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), "acb", true);
+    test(S("acb"), "abc", false);
+    test(S("aaa"), "cba", true);
+    test(S("cba"), "aaa", false);
+    }
+    {
+    typedef std::string S;
     test(S(""), "", true);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp

 {
     assert((lhs <= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
+    test(S("abc"), S("acb"), true);
+    test(S("acb"), S("abc"), false);
+    test(S("aaa"), S("cba"), true);
+    test(S("cba"), S("aaa"), false);
+    }
+    {
+    typedef std::string S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp

test(const S& lhs, SV rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(SV("abc"), "acb", true);
+    test(SV("acb"), "abc", false);
+    test(SV("aaa"), "cba", true);
+    test(SV("cba"), "aaa", false);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp

test(SV lhs, const S& rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
+    test(SV("abc"), S("acb"), true);
+    test(SV("acb"), S("abc"), false);
+    test(SV("aaa"), S("cba"), true);
+    test(SV("cba"), S("aaa"), false);
+    }
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);