1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
10
11// <flat_set>
12
13// flat_multiset iterators should be C++20 random access iterators
14
15#include <compare>
16#include <concepts>
17#include <deque>
18#include <flat_set>
19#include <functional>
20#include <vector>
21
22#include "MinSequenceContainer.h"
23#include "test_macros.h"
24#include "min_allocator.h"
25
26template <class KeyContainer>
27void test_one() {
28 using Key = typename KeyContainer::value_type;
29 using M = std::flat_multiset<Key, std::less<Key>, KeyContainer>;
30 using I = M::iterator;
31 using CI = M::const_iterator;
32 using RI = M::reverse_iterator;
33 using CRI = M::const_reverse_iterator;
34
35 static_assert(std::equality_comparable<I>);
36 static_assert(std::equality_comparable<CI>);
37 static_assert(std::equality_comparable<RI>);
38 static_assert(std::equality_comparable<CRI>);
39
40 static_assert(std::totally_ordered<I>);
41 static_assert(std::totally_ordered<CI>);
42 static_assert(std::totally_ordered<RI>);
43 static_assert(std::totally_ordered<CRI>);
44
45 M m = {1, 1, 3, 4};
46
47 I i1 = m.begin();
48 I i2 = m.begin() + 1;
49
50 assert(i1 == i1);
51 assert(!(i1 != i1));
52 assert(i1 != i2);
53 assert(!(i1 == i2));
54 assert(i1 < i2);
55 assert(!(i1 < i1));
56 assert(i1 <= i1);
57 assert(i1 <= i2);
58 assert(!(i2 <= i1));
59 assert(i2 > i1);
60 assert(!(i2 > i2));
61 assert(i2 >= i1);
62 assert(i2 >= i2);
63 assert(!(i1 >= i2));
64
65 CI ci1 = m.cbegin();
66 CI ci2 = m.cbegin() + 1;
67 assert(ci1 == ci1);
68 assert(!(ci1 != ci1));
69 assert(ci1 != ci2);
70 assert(!(ci1 == ci2));
71 assert(ci1 < ci2);
72 assert(!(ci1 < ci1));
73 assert(ci1 <= ci1);
74 assert(ci1 <= ci2);
75 assert(!(ci2 <= ci1));
76 assert(ci2 > ci1);
77 assert(!(ci2 > ci2));
78 assert(ci2 >= ci1);
79 assert(ci2 >= ci2);
80 assert(!(ci1 >= ci2));
81
82 RI ri1 = m.rbegin();
83 RI ri2 = m.rbegin() + 1;
84 assert(ri1 == ri1);
85 assert(!(ri1 != ri1));
86 assert(ri1 != ri2);
87 assert(!(ri1 == ri2));
88 assert(ri1 < ri2);
89 assert(!(ri1 < ri1));
90 assert(ri1 <= ri1);
91 assert(ri1 <= ri2);
92 assert(!(ri2 <= ri1));
93 assert(ri2 > ri1);
94 assert(!(ri2 > ri2));
95 assert(ri2 >= ri1);
96 assert(ri2 >= ri2);
97 assert(!(ri1 >= ri2));
98
99 CRI cri1 = m.crbegin();
100 CRI cri2 = m.crbegin() + 1;
101 assert(cri1 == cri1);
102 assert(!(cri1 != cri1));
103 assert(cri1 != cri2);
104 assert(!(cri1 == cri2));
105 assert(cri1 < cri2);
106 assert(!(cri1 < cri1));
107 assert(cri1 <= cri1);
108 assert(cri1 <= cri2);
109 assert(!(cri2 <= cri1));
110 assert(cri2 > cri1);
111 assert(!(cri2 > cri2));
112 assert(cri2 >= cri1);
113 assert(cri2 >= cri2);
114 assert(!(cri1 >= cri2));
115
116 static_assert(std::three_way_comparable<I>); // ...of course the wrapped iterators still support <=>.
117 static_assert(std::three_way_comparable<CI>);
118 static_assert(std::three_way_comparable<RI>);
119 static_assert(std::three_way_comparable<CRI>);
120 static_assert(std::same_as<decltype(I() <=> I()), std::strong_ordering>);
121 static_assert(std::same_as<decltype(I() <=> CI()), std::strong_ordering>);
122 static_assert(std::same_as<decltype(CI() <=> CI()), std::strong_ordering>);
123 static_assert(std::same_as<decltype(RI() <=> RI()), std::strong_ordering>);
124 static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
125 static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
126
127 assert(i1 <=> i1 == std::strong_ordering::equivalent);
128 assert(i1 <=> i2 == std::strong_ordering::less);
129 assert(i2 <=> i1 == std::strong_ordering::greater);
130
131 assert(ci1 <=> ci1 == std::strong_ordering::equivalent);
132 assert(ci1 <=> ci2 == std::strong_ordering::less);
133 assert(ci2 <=> ci1 == std::strong_ordering::greater);
134
135 assert(ri1 <=> ri1 == std::strong_ordering::equivalent);
136 assert(ri1 <=> ri2 == std::strong_ordering::less);
137 assert(ri2 <=> ri1 == std::strong_ordering::greater);
138
139 assert(cri1 <=> cri1 == std::strong_ordering::equivalent);
140 assert(cri1 <=> cri2 == std::strong_ordering::less);
141 assert(cri2 <=> cri1 == std::strong_ordering::greater);
142}
143
144void test() {
145 test_one<std::vector<int>>();
146 test_one<std::deque<int>>();
147 test_one<MinSequenceContainer<int>>();
148 test_one<std::vector<int, min_allocator<int>>>();
149}
150
151int main(int, char**) {
152 test();
153
154 return 0;
155}
156

source code of libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_comparison.pass.cpp