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_map>
12
13// flat_multimap iterators should be C++20 random access iterators
14
15#include <compare>
16#include <concepts>
17#include <deque>
18#include <flat_map>
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, class ValueContainer>
27void test() {
28 using Key = typename KeyContainer::value_type;
29 using Value = typename ValueContainer::value_type;
30 using M = std::flat_multimap<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
31 using I = M::iterator;
32 using CI = M::const_iterator;
33 using RI = M::reverse_iterator;
34 using CRI = M::const_reverse_iterator;
35
36 static_assert(std::equality_comparable<I>);
37 static_assert(std::equality_comparable<CI>);
38 static_assert(std::equality_comparable<RI>);
39 static_assert(std::equality_comparable<CRI>);
40
41 static_assert(std::totally_ordered<I>);
42 static_assert(std::totally_ordered<CI>);
43 static_assert(std::totally_ordered<RI>);
44 static_assert(std::totally_ordered<CRI>);
45
46 M m = {{1, 'a'}, {2, 'b'}, {2, 'e'}, {3, 'z'}, {3, 'y'}, {3, 'c'}, {4, 'd'}};
47
48 I i1 = m.begin();
49 I i2 = m.begin() + 1;
50
51 assert(i1 == i1);
52 assert(!(i1 != i1));
53 assert(i1 != i2);
54 assert(!(i1 == i2));
55 assert(i1 < i2);
56 assert(!(i1 < i1));
57 assert(i1 <= i1);
58 assert(i1 <= i2);
59 assert(!(i2 <= i1));
60 assert(i2 > i1);
61 assert(!(i2 > i2));
62 assert(i2 >= i1);
63 assert(i2 >= i2);
64 assert(!(i1 >= i2));
65
66 CI ci1 = m.cbegin();
67 CI ci2 = m.cbegin() + 1;
68 assert(ci1 == ci1);
69 assert(!(ci1 != ci1));
70 assert(ci1 != ci2);
71 assert(!(ci1 == ci2));
72 assert(ci1 < ci2);
73 assert(!(ci1 < ci1));
74 assert(ci1 <= ci1);
75 assert(ci1 <= ci2);
76 assert(!(ci2 <= ci1));
77 assert(ci2 > ci1);
78 assert(!(ci2 > ci2));
79 assert(ci2 >= ci1);
80 assert(ci2 >= ci2);
81 assert(!(ci1 >= ci2));
82
83 RI ri1 = m.rbegin();
84 RI ri2 = m.rbegin() + 1;
85 assert(ri1 == ri1);
86 assert(!(ri1 != ri1));
87 assert(ri1 != ri2);
88 assert(!(ri1 == ri2));
89 assert(ri1 < ri2);
90 assert(!(ri1 < ri1));
91 assert(ri1 <= ri1);
92 assert(ri1 <= ri2);
93 assert(!(ri2 <= ri1));
94 assert(ri2 > ri1);
95 assert(!(ri2 > ri2));
96 assert(ri2 >= ri1);
97 assert(ri2 >= ri2);
98 assert(!(ri1 >= ri2));
99
100 CRI cri1 = m.crbegin();
101 CRI cri2 = m.crbegin() + 1;
102 assert(cri1 == cri1);
103 assert(!(cri1 != cri1));
104 assert(cri1 != cri2);
105 assert(!(cri1 == cri2));
106 assert(cri1 < cri2);
107 assert(!(cri1 < cri1));
108 assert(cri1 <= cri1);
109 assert(cri1 <= cri2);
110 assert(!(cri2 <= cri1));
111 assert(cri2 > cri1);
112 assert(!(cri2 > cri2));
113 assert(cri2 >= cri1);
114 assert(cri2 >= cri2);
115 assert(!(cri1 >= cri2));
116
117 static_assert(std::three_way_comparable<I>); // ...of course the wrapped iterators still support <=>.
118 static_assert(std::three_way_comparable<CI>);
119 static_assert(std::three_way_comparable<RI>);
120 static_assert(std::three_way_comparable<CRI>);
121 static_assert(std::same_as<decltype(I() <=> I()), std::strong_ordering>);
122 static_assert(std::same_as<decltype(I() <=> CI()), std::strong_ordering>);
123 static_assert(std::same_as<decltype(CI() <=> CI()), std::strong_ordering>);
124 static_assert(std::same_as<decltype(RI() <=> RI()), std::strong_ordering>);
125 static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
126 static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
127
128 assert(i1 <=> i1 == std::strong_ordering::equivalent);
129 assert(i1 <=> i2 == std::strong_ordering::less);
130 assert(i2 <=> i1 == std::strong_ordering::greater);
131
132 assert(ci1 <=> ci1 == std::strong_ordering::equivalent);
133 assert(ci1 <=> ci2 == std::strong_ordering::less);
134 assert(ci2 <=> ci1 == std::strong_ordering::greater);
135
136 assert(ri1 <=> ri1 == std::strong_ordering::equivalent);
137 assert(ri1 <=> ri2 == std::strong_ordering::less);
138 assert(ri2 <=> ri1 == std::strong_ordering::greater);
139
140 assert(cri1 <=> cri1 == std::strong_ordering::equivalent);
141 assert(cri1 <=> cri2 == std::strong_ordering::less);
142 assert(cri2 <=> cri1 == std::strong_ordering::greater);
143}
144
145int main(int, char**) {
146 test<std::vector<int>, std::vector<char>>();
147 test<std::deque<int>, std::vector<char>>();
148 test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
149 test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
150
151 return 0;
152}
153

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