a0c00ccd5f
Updates the implementation `std::reference_wrapper` - [P2944R3](https://wg21.link/P2944R3) as discussed in https://github.com/llvm/llvm-project/pull/117664#discussion_r1857826166 This PR also refactors the tests in preparation to implements the constrained comparisons for `optional`, `variant` etc. - Moves the test helpers (concepts and types) for testing constrained comparisons to `test_comparisons.h`. - Updates the `std::reference_wrapper` implementation to use the concept `__core_convertible_to<bool>` as per comments in #135759. Closes #138233 # References: - [refwrap.comparisons](https://wg21.link/refwrap.comparisons) --------- Co-authored-by: Hristo Hristov <zingam@outlook.com> Co-authored-by: Nikolas Klauser <nikolasklauser@berlin.de>
87 lines
2.9 KiB
C++
87 lines
2.9 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
|
|
|
// <array>
|
|
|
|
// template<class T, size_t N>
|
|
// constexpr synth-three-way-result<T>
|
|
// operator<=>(const array<T, N>& x, const array<T, N>& y);
|
|
|
|
#include <array>
|
|
#include <cassert>
|
|
|
|
#include "test_comparisons.h"
|
|
|
|
// SFINAE
|
|
|
|
constexpr std::size_t N{1};
|
|
|
|
// The container should fulfill `std::three_way_comparable`
|
|
static_assert(std::three_way_comparable<std::array<int, N>>);
|
|
|
|
// Thanks to SFINAE, the following is not a compiler error but returns `false`
|
|
static_assert(!std::three_way_comparable<std::array<NonComparable, N>>);
|
|
|
|
// Implementation detail of `test_sequence_container_array_spaceship`
|
|
template <typename Elem, typename Order>
|
|
constexpr void test_sequence_container_array_spaceship_with_type() {
|
|
// Empty containers
|
|
{
|
|
std::array<Elem, 0> l1 = {};
|
|
std::array<Elem, 0> l2 = {};
|
|
assert(testOrder(l1, l2, Order::equivalent));
|
|
}
|
|
// Identical contents
|
|
{
|
|
std::array l1{Elem{1}, Elem{1}};
|
|
std::array l2{Elem{1}, Elem{1}};
|
|
assert(testOrder(l1, l2, Order::equivalent));
|
|
}
|
|
// Less, due to contained values
|
|
{
|
|
std::array l1{Elem{1}, Elem{1}};
|
|
std::array l2{Elem{1}, Elem{2}};
|
|
assert(testOrder(l1, l2, Order::less));
|
|
}
|
|
// Greater, due to contained values
|
|
{
|
|
std::array l1{Elem{1}, Elem{3}};
|
|
std::array l2{Elem{1}, Elem{2}};
|
|
assert(testOrder(l1, l2, Order::greater));
|
|
}
|
|
// Shorter list - unsupported - containers must be of equal lengths
|
|
// Longer list - unsupported - containers must be of equal lengths
|
|
// Unordered
|
|
if constexpr (std::is_same_v<Elem, PartialOrder>) {
|
|
std::array l1{Elem{1}, Elem{std::numeric_limits<int>::min()}};
|
|
std::array l2{Elem{1}, Elem{2}};
|
|
assert(testOrder(l1, l2, Order::unordered));
|
|
}
|
|
}
|
|
|
|
// Tests the `operator<=>` on sequence containers `array`
|
|
constexpr bool test_sequence_container_array_spaceship() {
|
|
// Test different comparison categories
|
|
test_sequence_container_array_spaceship_with_type<int, std::strong_ordering>();
|
|
test_sequence_container_array_spaceship_with_type<StrongOrder, std::strong_ordering>();
|
|
test_sequence_container_array_spaceship_with_type<WeakOrder, std::weak_ordering>();
|
|
test_sequence_container_array_spaceship_with_type<PartialOrder, std::partial_ordering>();
|
|
|
|
// `LessAndEqComp` does not have `operator<=>`. Ordering is synthesized based on `operator<`
|
|
test_sequence_container_array_spaceship_with_type<LessAndEqComp, std::weak_ordering>();
|
|
|
|
return true;
|
|
}
|
|
|
|
int main(int, char**) {
|
|
assert(test_sequence_container_array_spaceship());
|
|
static_assert(test_sequence_container_array_spaceship());
|
|
return 0;
|
|
}
|