Skip to content

Commit 965f3a9

Browse files
ldionneldionne
committed
[libc++][NFC] Run clang-format on vector::erase test
Since I am about to make significant changes to this test, run clang-format on it before to avoid obscuring the review.
1 parent 5c3befb commit 965f3a9

File tree

1 file changed

+161
-146
lines changed

1 file changed

+161
-146
lines changed

‎libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp

Lines changed: 161 additions & 146 deletions
Original file line numberDiff line numberDiff line change
@@ -21,169 +21,184 @@
2121

2222
#ifndef TEST_HAS_NO_EXCEPTIONS
2323
struct Throws {
24-
Throws() : v_(0) {}
25-
Throws(int v) : v_(v) {}
26-
Throws(const Throws &rhs) : v_(rhs.v_) { if (sThrows) throw 1; }
27-
Throws( Throws &&rhs) : v_(rhs.v_) { if (sThrows) throw 1; }
28-
Throws& operator=(const Throws &rhs) { v_ = rhs.v_; return *this; }
29-
Throws& operator=( Throws &&rhs) { v_ = rhs.v_; return *this; }
30-
int v_;
31-
static bool sThrows;
32-
};
24+
Throws() : v_(0) {}
25+
Throws(int v) : v_(v) {}
26+
Throws(const Throws& rhs) : v_(rhs.v_) {
27+
if (sThrows)
28+
throw 1;
29+
}
30+
Throws(Throws&& rhs) : v_(rhs.v_) {
31+
if (sThrows)
32+
throw 1;
33+
}
34+
Throws& operator=(const Throws& rhs) {
35+
v_ = rhs.v_;
36+
return *this;
37+
}
38+
Throws& operator=(Throws&& rhs) {
39+
v_ = rhs.v_;
40+
return *this;
41+
}
42+
int v_;
43+
static bool sThrows;
44+
};
3345

3446
bool Throws::sThrows = false;
3547
#endif
3648

37-
TEST_CONSTEXPR_CXX20 bool tests()
38-
{
39-
int a1[] = {1, 2, 3};
49+
TEST_CONSTEXPR_CXX20 bool tests() {
50+
int a1[] = {1, 2, 3};
51+
{
52+
std::vector<int> l1(a1, a1 + 3);
53+
assert(is_contiguous_container_asan_correct(l1));
54+
std::vector<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
55+
assert(l1.size() == 3);
56+
assert(std::distance(l1.cbegin(), l1.cend()) == 3);
57+
assert(i == l1.begin());
58+
assert(is_contiguous_container_asan_correct(l1));
59+
}
60+
{
61+
std::vector<int> l1(a1, a1 + 3);
62+
assert(is_contiguous_container_asan_correct(l1));
63+
std::vector<int>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin()));
64+
assert(l1.size() == 2);
65+
assert(std::distance(l1.cbegin(), l1.cend()) == 2);
66+
assert(i == l1.begin());
67+
assert(l1 == std::vector<int>(a1 + 1, a1 + 3));
68+
assert(is_contiguous_container_asan_correct(l1));
69+
}
70+
{
71+
std::vector<int> l1(a1, a1 + 3);
72+
assert(is_contiguous_container_asan_correct(l1));
73+
std::vector<int>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 2));
74+
assert(l1.size() == 1);
75+
assert(std::distance(l1.cbegin(), l1.cend()) == 1);
76+
assert(i == l1.begin());
77+
assert(l1 == std::vector<int>(a1 + 2, a1 + 3));
78+
assert(is_contiguous_container_asan_correct(l1));
79+
}
80+
{
81+
std::vector<int> l1(a1, a1 + 3);
82+
assert(is_contiguous_container_asan_correct(l1));
83+
std::vector<int>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 3));
84+
assert(l1.size() == 0);
85+
assert(std::distance(l1.cbegin(), l1.cend()) == 0);
86+
assert(i == l1.begin());
87+
assert(is_contiguous_container_asan_correct(l1));
88+
}
89+
{
90+
std::vector<std::vector<int> > outer(2, std::vector<int>(1));
91+
assert(is_contiguous_container_asan_correct(outer));
92+
assert(is_contiguous_container_asan_correct(outer[0]));
93+
assert(is_contiguous_container_asan_correct(outer[1]));
94+
outer.erase(outer.begin(), outer.begin());
95+
assert(outer.size() == 2);
96+
assert(outer[0].size() == 1);
97+
assert(outer[1].size() == 1);
98+
assert(is_contiguous_container_asan_correct(outer));
99+
assert(is_contiguous_container_asan_correct(outer[0]));
100+
assert(is_contiguous_container_asan_correct(outer[1]));
101+
}
102+
// Make sure vector::erase works with move-only types
103+
{
104+
// When non-trivial
40105
{
41-
std::vector<int> l1(a1, a1+3);
42-
assert(is_contiguous_container_asan_correct(l1));
43-
std::vector<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
44-
assert(l1.size() == 3);
45-
assert(std::distance(l1.cbegin(), l1.cend()) == 3);
46-
assert(i == l1.begin());
47-
assert(is_contiguous_container_asan_correct(l1));
106+
std::vector<MoveOnly> v;
107+
v.emplace_back(1);
108+
v.emplace_back(2);
109+
v.emplace_back(3);
110+
v.erase(v.begin(), v.begin() + 2);
111+
assert(v.size() == 1);
112+
assert(v[0] == MoveOnly(3));
48113
}
114+
// When trivial
49115
{
50-
std::vector<int> l1(a1, a1+3);
51-
assert(is_contiguous_container_asan_correct(l1));
52-
std::vector<int>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin()));
53-
assert(l1.size() == 2);
54-
assert(std::distance(l1.cbegin(), l1.cend()) == 2);
55-
assert(i == l1.begin());
56-
assert(l1 == std::vector<int>(a1+1, a1+3));
57-
assert(is_contiguous_container_asan_correct(l1));
58-
}
59-
{
60-
std::vector<int> l1(a1, a1+3);
61-
assert(is_contiguous_container_asan_correct(l1));
62-
std::vector<int>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 2));
63-
assert(l1.size() == 1);
64-
assert(std::distance(l1.cbegin(), l1.cend()) == 1);
65-
assert(i == l1.begin());
66-
assert(l1 == std::vector<int>(a1+2, a1+3));
67-
assert(is_contiguous_container_asan_correct(l1));
68-
}
69-
{
70-
std::vector<int> l1(a1, a1+3);
71-
assert(is_contiguous_container_asan_correct(l1));
72-
std::vector<int>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 3));
73-
assert(l1.size() == 0);
74-
assert(std::distance(l1.cbegin(), l1.cend()) == 0);
75-
assert(i == l1.begin());
76-
assert(is_contiguous_container_asan_correct(l1));
77-
}
78-
{
79-
std::vector<std::vector<int> > outer(2, std::vector<int>(1));
80-
assert(is_contiguous_container_asan_correct(outer));
81-
assert(is_contiguous_container_asan_correct(outer[0]));
82-
assert(is_contiguous_container_asan_correct(outer[1]));
83-
outer.erase(outer.begin(), outer.begin());
84-
assert(outer.size() == 2);
85-
assert(outer[0].size() == 1);
86-
assert(outer[1].size() == 1);
87-
assert(is_contiguous_container_asan_correct(outer));
88-
assert(is_contiguous_container_asan_correct(outer[0]));
89-
assert(is_contiguous_container_asan_correct(outer[1]));
90-
}
91-
// Make sure vector::erase works with move-only types
92-
{
93-
// When non-trivial
94-
{
95-
std::vector<MoveOnly> v;
96-
v.emplace_back(1); v.emplace_back(2); v.emplace_back(3);
97-
v.erase(v.begin(), v.begin() + 2);
98-
assert(v.size() == 1);
99-
assert(v[0] == MoveOnly(3));
100-
}
101-
// When trivial
102-
{
103-
std::vector<TrivialMoveOnly> v;
104-
v.emplace_back(1); v.emplace_back(2); v.emplace_back(3);
105-
v.erase(v.begin(), v.begin() + 2);
106-
assert(v.size() == 1);
107-
assert(v[0] == TrivialMoveOnly(3));
108-
}
116+
std::vector<TrivialMoveOnly> v;
117+
v.emplace_back(1);
118+
v.emplace_back(2);
119+
v.emplace_back(3);
120+
v.erase(v.begin(), v.begin() + 2);
121+
assert(v.size() == 1);
122+
assert(v[0] == TrivialMoveOnly(3));
109123
}
124+
}
110125
#if TEST_STD_VER >= 11
111-
{
112-
std::vector<int, min_allocator<int>> l1(a1, a1+3);
113-
assert(is_contiguous_container_asan_correct(l1));
114-
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
115-
assert(l1.size() == 3);
116-
assert(std::distance(l1.cbegin(), l1.cend()) == 3);
117-
assert(i == l1.begin());
118-
assert(is_contiguous_container_asan_correct(l1));
119-
}
120-
{
121-
std::vector<int, min_allocator<int>> l1(a1, a1+3);
122-
assert(is_contiguous_container_asan_correct(l1));
123-
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin()));
124-
assert(l1.size() == 2);
125-
assert(std::distance(l1.cbegin(), l1.cend()) == 2);
126-
assert(i == l1.begin());
127-
assert((l1 == std::vector<int, min_allocator<int>>(a1+1, a1+3)));
128-
assert(is_contiguous_container_asan_correct(l1));
129-
}
130-
{
131-
std::vector<int, min_allocator<int>> l1(a1, a1+3);
132-
assert(is_contiguous_container_asan_correct(l1));
133-
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 2));
134-
assert(l1.size() == 1);
135-
assert(std::distance(l1.cbegin(), l1.cend()) == 1);
136-
assert(i == l1.begin());
137-
assert((l1 == std::vector<int, min_allocator<int>>(a1+2, a1+3)));
138-
assert(is_contiguous_container_asan_correct(l1));
139-
}
140-
{
141-
std::vector<int, min_allocator<int>> l1(a1, a1+3);
142-
assert(is_contiguous_container_asan_correct(l1));
143-
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 3));
144-
assert(l1.size() == 0);
145-
assert(std::distance(l1.cbegin(), l1.cend()) == 0);
146-
assert(i == l1.begin());
147-
assert(is_contiguous_container_asan_correct(l1));
148-
}
149-
{
150-
std::vector<std::vector<int, min_allocator<int>>, min_allocator<std::vector<int, min_allocator<int>>>> outer(2, std::vector<int, min_allocator<int>>(1));
151-
assert(is_contiguous_container_asan_correct(outer));
152-
assert(is_contiguous_container_asan_correct(outer[0]));
153-
assert(is_contiguous_container_asan_correct(outer[1]));
154-
outer.erase(outer.begin(), outer.begin());
155-
assert(outer.size() == 2);
156-
assert(outer[0].size() == 1);
157-
assert(outer[1].size() == 1);
158-
assert(is_contiguous_container_asan_correct(outer));
159-
assert(is_contiguous_container_asan_correct(outer[0]));
160-
assert(is_contiguous_container_asan_correct(outer[1]));
161-
}
126+
{
127+
std::vector<int, min_allocator<int>> l1(a1, a1 + 3);
128+
assert(is_contiguous_container_asan_correct(l1));
129+
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
130+
assert(l1.size() == 3);
131+
assert(std::distance(l1.cbegin(), l1.cend()) == 3);
132+
assert(i == l1.begin());
133+
assert(is_contiguous_container_asan_correct(l1));
134+
}
135+
{
136+
std::vector<int, min_allocator<int>> l1(a1, a1 + 3);
137+
assert(is_contiguous_container_asan_correct(l1));
138+
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin()));
139+
assert(l1.size() == 2);
140+
assert(std::distance(l1.cbegin(), l1.cend()) == 2);
141+
assert(i == l1.begin());
142+
assert((l1 == std::vector<int, min_allocator<int>>(a1 + 1, a1 + 3)));
143+
assert(is_contiguous_container_asan_correct(l1));
144+
}
145+
{
146+
std::vector<int, min_allocator<int>> l1(a1, a1 + 3);
147+
assert(is_contiguous_container_asan_correct(l1));
148+
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 2));
149+
assert(l1.size() == 1);
150+
assert(std::distance(l1.cbegin(), l1.cend()) == 1);
151+
assert(i == l1.begin());
152+
assert((l1 == std::vector<int, min_allocator<int>>(a1 + 2, a1 + 3)));
153+
assert(is_contiguous_container_asan_correct(l1));
154+
}
155+
{
156+
std::vector<int, min_allocator<int>> l1(a1, a1 + 3);
157+
assert(is_contiguous_container_asan_correct(l1));
158+
std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 3));
159+
assert(l1.size() == 0);
160+
assert(std::distance(l1.cbegin(), l1.cend()) == 0);
161+
assert(i == l1.begin());
162+
assert(is_contiguous_container_asan_correct(l1));
163+
}
164+
{
165+
std::vector<std::vector<int, min_allocator<int>>, min_allocator<std::vector<int, min_allocator<int>>>> outer(
166+
2, std::vector<int, min_allocator<int>>(1));
167+
assert(is_contiguous_container_asan_correct(outer));
168+
assert(is_contiguous_container_asan_correct(outer[0]));
169+
assert(is_contiguous_container_asan_correct(outer[1]));
170+
outer.erase(outer.begin(), outer.begin());
171+
assert(outer.size() == 2);
172+
assert(outer[0].size() == 1);
173+
assert(outer[1].size() == 1);
174+
assert(is_contiguous_container_asan_correct(outer));
175+
assert(is_contiguous_container_asan_correct(outer[0]));
176+
assert(is_contiguous_container_asan_correct(outer[1]));
177+
}
162178
#endif
163179

164-
return true;
180+
return true;
165181
}
166182

167-
int main(int, char**)
168-
{
169-
tests();
183+
int main(int, char**) {
184+
tests();
170185
#if TEST_STD_VER > 17
171-
static_assert(tests());
186+
static_assert(tests());
172187
#endif
173188

174189
#ifndef TEST_HAS_NO_EXCEPTIONS
175-
// Test for LWG2853:
176-
// Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
177-
{
178-
Throws arr[] = {1, 2, 3};
179-
std::vector<Throws> v(arr, arr+3);
180-
Throws::sThrows = true;
181-
v.erase(v.begin(), --v.end());
182-
assert(v.size() == 1);
183-
v.erase(v.begin(), v.end());
184-
assert(v.size() == 0);
185-
}
190+
// Test for LWG2853:
191+
// Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
192+
{
193+
Throws arr[] = {1, 2, 3};
194+
std::vector<Throws> v(arr, arr + 3);
195+
Throws::sThrows = true;
196+
v.erase(v.begin(), --v.end());
197+
assert(v.size() == 1);
198+
v.erase(v.begin(), v.end());
199+
assert(v.size() == 0);
200+
}
186201
#endif
187202

188-
return 0;
203+
return 0;
189204
}

0 commit comments

Comments
 (0)