[libc++][NFC] Rename helper function for testing spaceship

[ldionne]

Summary

The helper is mis-named, since it won't work as-is on ordered containers
like set and map, because they rely on being able to store keys that are
partial_ordering::unordered, and that's UB for an ordered container.

This was most likely a typo or an unintended naming mistake, since
the function is only used with sequence containers anyway.

[H-G-Hristov]

@ldionne Thank you for pointing this out and fixing it. LGTM

Some of the tests are also misplaced and I have a patch to correct that https://reviews.llvm.org/D146902. I suppose I need to wait for you to commit these changes, so I can rebase and commit my fix to avoid conflicts.

[ldionne]

In D146991#4226534, @H-G-Hristov wrote:

@ldionne Thank you for pointing this out and fixing it. LGTM

Some of the tests are also misplaced and I have a patch to correct that https://reviews.llvm.org/D146902. I suppose I need to wait for you to commit these changes, so I can rebase and commit my fix to avoid conflicts.

Ok, let's do that! I wasn't aware of D146902, otherwise I would have held off with this change.

libcxx/test/libcxx/containers/sequences/deque/compare.three_way.pass.cpp

 //                                         const deque<T, Allocator>& y);
 
 #include <cassert>
 #include <deque>
 
 #include "test_container_comparisons.h"
 
 int main(int, char**) {
-  assert(test_ordered_container_spaceship<std::deque>());
+  assert(test_sequence_container_spaceship<std::deque>());
   // `std::deque` is not constexpr, so no `static_assert` test here.
   return 0;
 }

libcxx/test/libcxx/containers/sequences/forwardlist/compare.three_way.pass.cpp

 //                                         const forward_list<T, Allocator>& y);
 
 #include <cassert>
 #include <forward_list>
 
 #include "test_container_comparisons.h"
 
 int main(int, char**) {
-  assert(test_ordered_container_spaceship<std::forward_list>());
+  assert(test_sequence_container_spaceship<std::forward_list>());
   // `std::forward_list` is not constexpr, so no `static_assert` test here.
   return 0;
 }

libcxx/test/std/containers/sequences/list/compare.three_way.pass.cpp

 //     operator<=>(const list<T, Allocator>& x, const list<T, Allocator>& y);
 
 #include <list>
 #include <cassert>
 
 #include "test_container_comparisons.h"
 
 int main(int, char**) {
-  assert(test_ordered_container_spaceship<std::list>());
+  assert(test_sequence_container_spaceship<std::list>());
   // `std::list` is not constexpr, so no `static_assert` test here.
   return 0;
 }

libcxx/test/support/test_container_comparisons.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
 //
 //===----------------------------------------------------------------------===//
 //  Utility functions to test comparisons on containers.
 
 #ifndef TEST_CONTAINER_COMPARISONS
 #define TEST_CONTAINER_COMPARISONS
 
 #include "test_comparisons.h"
 
-// Implementation detail of `test_ordered_container_spaceship`
+// Implementation detail of `test_sequence_container_spaceship`
 template <template <typename...> typename Container, typename Elem, typename Order>
-constexpr void test_ordered_container_spaceship_with_type() {
+constexpr void test_sequence_container_spaceship_with_type() {
   // Empty containers
   {
     Container<Elem> l1;
     Container<Elem> l2;
     assert(testOrder(l1, l2, Order::equivalent));
   }
   // Identical contents
   {
constexpr void test_sequence_container_spaceship_with_type() {
   // Unordered
   if constexpr (std::is_same_v<Elem, PartialOrder>) {
     Container<Elem> l1{1, std::numeric_limits<int>::min()};
     Container<Elem> l2{1, 2};
     assert(testOrder(l1, l2, Order::unordered));
   }
 }
 
-// Tests the `operator<=>` on ordered containers
+// Tests the `operator<=>` on sequence containers
 template <template <typename...> typename Container>
-constexpr bool test_ordered_container_spaceship() {
+constexpr bool test_sequence_container_spaceship() {
   // The container should fulfil `std::three_way_comparable`
   static_assert(std::three_way_comparable<Container<int>>);
 
   // Test different comparison categories
-  test_ordered_container_spaceship_with_type<Container, int, std::strong_ordering>();
-  test_ordered_container_spaceship_with_type<Container, StrongOrder, std::strong_ordering>();
-  test_ordered_container_spaceship_with_type<Container, WeakOrder, std::weak_ordering>();
-  test_ordered_container_spaceship_with_type<Container, PartialOrder, std::partial_ordering>();
+  test_sequence_container_spaceship_with_type<Container, int, std::strong_ordering>();
+  test_sequence_container_spaceship_with_type<Container, StrongOrder, std::strong_ordering>();
+  test_sequence_container_spaceship_with_type<Container, WeakOrder, std::weak_ordering>();
+  test_sequence_container_spaceship_with_type<Container, PartialOrder, std::partial_ordering>();
 
   // `LessAndEqComp` does not have `operator<=>`. ordering is sythesized based on `operator<`
-  test_ordered_container_spaceship_with_type<Container, LessAndEqComp, std::weak_ordering>();
+  test_sequence_container_spaceship_with_type<Container, LessAndEqComp, std::weak_ordering>();
 
   // Thanks to SFINAE, the following is not a compiler error but returns `false`
   struct NonComparable {};
   static_assert(!std::three_way_comparable<Container<NonComparable>>);
 
   return true;
 }