1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
//===----------------------------------------------------------------------===//
//
// 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`
struct NonComparable {};
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;
}
|
