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// class flat_multimap
14
15// iterator erase(iterator position);
16// iterator erase(const_iterator position);
17
18#include <compare>
19#include <concepts>
20#include <deque>
21#include <flat_map>
22#include <functional>
23#include <utility>
24#include <vector>
25
26#include "MinSequenceContainer.h"
27#include "../helpers.h"
28#include "test_macros.h"
29#include "min_allocator.h"
30
31template <class KeyContainer, class ValueContainer>
32void test() {
33 using Key = typename KeyContainer::value_type;
34 using Value = typename ValueContainer::value_type;
35 using M = std::flat_multimap<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
36 using P = std::pair<Key, Value>;
37 using I = M::iterator;
38
39 P ar[] = {
40 P(1, 1.5),
41 P(2, 2.5),
42 P(2, 2.6),
43 P(3, 3.5),
44 P(4, 4.5),
45 P(4, 4.5),
46 P(4, 4.7),
47 P(5, 5.5),
48 P(6, 6.5),
49 P(7, 7.5),
50 P(8, 8.5),
51 };
52 M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
53 assert(m.size() == 11);
54 std::same_as<I> decltype(auto) i1 = m.erase(std::next(m.cbegin(), 2));
55 assert(m.size() == 10);
56 assert(i1 == std::next(m.begin(), 2));
57 assert(std::ranges::equal(
58 m,
59 std::vector<P>{
60 {1, 1.5}, {2, 2.5}, {3, 3.5}, {4, 4.5}, {4, 4.5}, {4, 4.7}, {5, 5.5}, {6, 6.5}, {7, 7.5}, {8, 8.5}}));
61
62 std::same_as<I> decltype(auto) i2 = m.erase(std::next(m.begin(), 0));
63 assert(m.size() == 9);
64 assert(i2 == m.begin());
65 assert(std::ranges::equal(
66 m, std::vector<P>{{2, 2.5}, {3, 3.5}, {4, 4.5}, {4, 4.5}, {4, 4.7}, {5, 5.5}, {6, 6.5}, {7, 7.5}, {8, 8.5}}));
67
68 std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 8));
69 assert(m.size() == 8);
70 assert(i3 == m.end());
71 assert(std::ranges::equal(
72 m, std::vector<P>{{2, 2.5}, {3, 3.5}, {4, 4.5}, {4, 4.5}, {4, 4.7}, {5, 5.5}, {6, 6.5}, {7, 7.5}}));
73
74 std::same_as<I> decltype(auto) i4 = m.erase(std::next(m.begin(), 1));
75 assert(m.size() == 7);
76 assert(i4 == std::next(m.begin()));
77 assert(std::ranges::equal(m, std::vector<P>{{2, 2.5}, {4, 4.5}, {4, 4.5}, {4, 4.7}, {5, 5.5}, {6, 6.5}, {7, 7.5}}));
78
79 std::same_as<I> decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2));
80 assert(m.size() == 6);
81 assert(i5 == std::next(m.begin(), 2));
82 assert(std::ranges::equal(m, std::vector<P>{{2, 2.5}, {4, 4.5}, {4, 4.7}, {5, 5.5}, {6, 6.5}, {7, 7.5}}));
83
84 std::same_as<I> decltype(auto) i6 = m.erase(std::next(m.begin(), 2));
85 assert(m.size() == 5);
86 assert(i6 == std::next(m.begin(), 2));
87 assert(std::ranges::equal(m, std::vector<P>{{2, 2.5}, {4, 4.5}, {5, 5.5}, {6, 6.5}, {7, 7.5}}));
88
89 std::same_as<I> decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0));
90 assert(m.size() == 4);
91 assert(i7 == std::next(m.begin(), 0));
92 assert(std::ranges::equal(m, std::vector<P>{{4, 4.5}, {5, 5.5}, {6, 6.5}, {7, 7.5}}));
93
94 std::same_as<I> decltype(auto) i8 = m.erase(std::next(m.cbegin(), 2));
95 assert(m.size() == 3);
96 assert(i8 == std::next(m.begin(), 2));
97 assert(std::ranges::equal(m, std::vector<P>{{4, 4.5}, {5, 5.5}, {7, 7.5}}));
98
99 std::same_as<I> decltype(auto) i9 = m.erase(std::next(m.cbegin(), 2));
100 assert(m.size() == 2);
101 assert(i9 == std::next(m.begin(), 2));
102 assert(std::ranges::equal(m, std::vector<P>{{4, 4.5}, {5, 5.5}}));
103
104 std::same_as<I> decltype(auto) i10 = m.erase(m.cbegin());
105 assert(m.size() == 1);
106 assert(i10 == m.cbegin());
107 assert(std::ranges::equal(m, std::vector<P>{{5, 5.5}}));
108
109 std::same_as<I> decltype(auto) i11 = m.erase(m.begin());
110 assert(m.size() == 0);
111 assert(i11 == m.begin());
112 assert(i11 == m.end());
113}
114
115int main(int, char**) {
116 test<std::vector<int>, std::vector<double>>();
117 test<std::deque<int>, std::vector<double>>();
118 test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
119 test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
120
121 {
122 auto erase_function = [](auto& m, auto) { m.erase(m.begin() + 2); };
123 test_erase_exception_guarantee(erase_function);
124 }
125
126 return 0;
127}
128

source code of libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_iter.pass.cpp