Skip to content

Commit 901a0ea

Browse files
changkhothuychungchangkhothuychung
committed
clang format
1 parent d9807b7 commit 901a0ea

File tree

1 file changed

+110
-109
lines changed

1 file changed

+110
-109
lines changed

‎libcxx/test/libcxx/ranges/range.adaptors/range.concat/iterator.valueless_by_exception.pass.cpp‎

Lines changed: 110 additions & 109 deletions
Original file line numberDiff line numberDiff line change
@@ -22,133 +22,150 @@ int val[] = {1, 2, 3};
2222

2323
bool flag = false;
2424

25-
template<std::size_t N> struct Iter;
25+
template <std::size_t N>
26+
struct Iter;
2627

27-
template<std::size_t N>
28+
template <std::size_t N>
2829
struct Iter {
29-
using value_type = int;
30-
using difference_type = std::ptrdiff_t;
31-
using reference = int&;
32-
using pointer = int*;
33-
using iterator_category = std::random_access_iterator_tag;
34-
using iterator_concept = std::random_access_iterator_tag;
30+
using value_type = int;
31+
using difference_type = std::ptrdiff_t;
32+
using reference = int&;
33+
using pointer = int*;
34+
using iterator_category = std::random_access_iterator_tag;
35+
using iterator_concept = std::random_access_iterator_tag;
3536

3637
private:
37-
int* ptr_ = nullptr;
38+
int* ptr_ = nullptr;
3839

39-
template<std::size_t M> friend struct Iter;
40+
template <std::size_t M>
41+
friend struct Iter;
4042

4143
public:
42-
Iter() = default;
43-
Iter(int* ptr) : ptr_(ptr) {}
44-
Iter(const Iter&) = default;
45-
Iter(Iter&& other) noexcept : ptr_(other.ptr_) {}
46-
47-
template<std::size_t M>
48-
Iter(const Iter<M>& other) : ptr_(other.ptr_) {}
49-
50-
Iter& operator=(const Iter&) = default;
51-
Iter& operator=(Iter&& other) noexcept {
52-
ptr_ = other.ptr_;
53-
return *this;
54-
}
44+
Iter() = default;
45+
Iter(int* ptr) : ptr_(ptr) {}
46+
Iter(const Iter&) = default;
47+
Iter(Iter&& other) noexcept : ptr_(other.ptr_) {}
48+
49+
template <std::size_t M>
50+
Iter(const Iter<M>& other) : ptr_(other.ptr_) {}
51+
52+
Iter& operator=(const Iter&) = default;
53+
Iter& operator=(Iter&& other) noexcept {
54+
ptr_ = other.ptr_;
55+
return *this;
56+
}
5557

56-
reference operator*() const { return *ptr_; }
57-
pointer operator->() const { return ptr_; }
58-
reference operator[](difference_type n) const { return ptr_[n]; }
58+
reference operator*() const { return *ptr_; }
59+
pointer operator->() const { return ptr_; }
60+
reference operator[](difference_type n) const { return ptr_[n]; }
5961

60-
Iter& operator++() { ++ptr_; return *this; }
61-
Iter operator++(int) { auto tmp = *this; ++*this; return tmp; }
62-
Iter& operator--() { --ptr_; return *this; }
63-
Iter operator--(int) { auto tmp = *this; --*this; return tmp; }
62+
Iter& operator++() {
63+
++ptr_;
64+
return *this;
65+
}
66+
Iter operator++(int) {
67+
auto tmp = *this;
68+
++*this;
69+
return tmp;
70+
}
71+
Iter& operator--() {
72+
--ptr_;
73+
return *this;
74+
}
75+
Iter operator--(int) {
76+
auto tmp = *this;
77+
--*this;
78+
return tmp;
79+
}
6480

65-
Iter& operator+=(difference_type n) { ptr_ += n; return *this; }
66-
Iter& operator-=(difference_type n) { ptr_ -= n; return *this; }
81+
Iter& operator+=(difference_type n) {
82+
ptr_ += n;
83+
return *this;
84+
}
85+
Iter& operator-=(difference_type n) {
86+
ptr_ -= n;
87+
return *this;
88+
}
6789

68-
template<std::size_t X>
69-
friend Iter<X> operator+(Iter<X> it, difference_type n);
90+
template <std::size_t X>
91+
friend Iter<X> operator+(Iter<X> it, difference_type n);
7092

71-
template<std::size_t X>
72-
friend Iter<X> operator+(difference_type n, Iter<X> it);
93+
template <std::size_t X>
94+
friend Iter<X> operator+(difference_type n, Iter<X> it);
7395

74-
template<std::size_t X>
75-
friend Iter<X> operator-(Iter<X> it, difference_type n);
96+
template <std::size_t X>
97+
friend Iter<X> operator-(Iter<X> it, difference_type n);
7698

77-
template<std::size_t X, std::size_t Y>
78-
friend difference_type operator-(Iter<X> a, Iter<Y> b);
99+
template <std::size_t X, std::size_t Y>
100+
friend difference_type operator-(Iter<X> a, Iter<Y> b);
79101

80-
friend bool operator==(Iter a, Iter b) = default;
81-
friend bool operator<(Iter a, Iter b) { return a.ptr_ < b.ptr_; }
82-
friend bool operator>(Iter a, Iter b) { return a.ptr_ > b.ptr_; }
83-
friend bool operator<=(Iter a, Iter b) { return a.ptr_ <= b.ptr_; }
84-
friend bool operator>=(Iter a, Iter b) { return a.ptr_ >= b.ptr_; }
102+
friend bool operator==(Iter a, Iter b) = default;
103+
friend bool operator<(Iter a, Iter b) { return a.ptr_ < b.ptr_; }
104+
friend bool operator>(Iter a, Iter b) { return a.ptr_ > b.ptr_; }
105+
friend bool operator<=(Iter a, Iter b) { return a.ptr_ <= b.ptr_; }
106+
friend bool operator>=(Iter a, Iter b) { return a.ptr_ >= b.ptr_; }
85107
};
86108

87-
template<std::size_t X>
109+
template <std::size_t X>
88110
inline Iter<X> operator+(Iter<X> it, std::ptrdiff_t n) {
89-
return Iter<X>(it.ptr_ + n);
111+
return Iter<X>(it.ptr_ + n);
90112
}
91113

92-
template<std::size_t X>
114+
template <std::size_t X>
93115
inline Iter<X> operator+(std::ptrdiff_t n, Iter<X> it) {
94-
return Iter<X>(it.ptr_ + n);
116+
return Iter<X>(it.ptr_ + n);
95117
}
96118

97-
template<std::size_t X>
119+
template <std::size_t X>
98120
inline Iter<X> operator-(Iter<X> it, std::ptrdiff_t n) {
99-
return Iter<X>(it.ptr_ - n);
121+
return Iter<X>(it.ptr_ - n);
100122
}
101123

102-
template<std::size_t X, std::size_t Y>
124+
template <std::size_t X, std::size_t Y>
103125
inline std::ptrdiff_t operator-(Iter<X> a, Iter<Y> b) {
104-
return a.ptr_ - b.ptr_;
126+
return a.ptr_ - b.ptr_;
105127
}
106128

107-
template<std::size_t N>
129+
template <std::size_t N>
108130
struct Range : std::ranges::view_base {
109-
using iterator = Iter<N>;
110-
using const_iterator = Iter<N>;
131+
using iterator = Iter<N>;
132+
using const_iterator = Iter<N>;
111133

112-
int* data_;
113-
std::size_t size_;
134+
int* data_;
135+
std::size_t size_;
114136

115-
Range() : data_(val), size_(4) {}
137+
Range() : data_(val), size_(4) {}
116138

117-
Range(int* data, std::size_t size) : data_(data), size_(size) {}
139+
Range(int* data, std::size_t size) : data_(data), size_(size) {}
118140

119-
iterator begin() { return iterator(data_); }
120-
iterator end() { return iterator(data_ + size_); }
141+
iterator begin() { return iterator(data_); }
142+
iterator end() { return iterator(data_ + size_); }
121143

122-
const_iterator begin() const { return const_iterator(data_); }
123-
const_iterator end() const { return const_iterator(data_ + size_); }
144+
const_iterator begin() const { return const_iterator(data_); }
145+
const_iterator end() const { return const_iterator(data_ + size_); }
124146

125-
std::size_t size() const { return size_; }
147+
std::size_t size() const { return size_; }
126148
};
127149

128150
static_assert(std::ranges::range<Range<0>>);
129151
static_assert(std::ranges::sized_range<Range<0>>);
130152

131153
int main() {
132-
133154
{
134155
//valueless by exception test operator*
135156
Range<0> r1;
136157
Range<1> r2;
137158

138-
auto cv = std::views::concat(r1, r2);
159+
auto cv = std::views::concat(r1, r2);
139160
auto iter1 = cv.begin();
140161
auto iter2 = std::ranges::next(cv.begin(), 4);
141-
flag = true;
162+
flag = true;
142163
try {
143-
iter1 = std::move(iter2);
164+
iter1 = std::move(iter2);
144165
} catch (...) {
145166
auto f = std::ranges::distance(r1);
146167
(void)f;
147-
TEST_LIBCPP_ASSERT_FAILURE(
148-
[=] {
149-
*iter1;
150-
}(),
151-
"valueless by exception");
168+
TEST_LIBCPP_ASSERT_FAILURE([=] { *iter1; }(), "valueless by exception");
152169
}
153170
}
154171

@@ -158,19 +175,15 @@ int main() {
158175
Range<0> r1;
159176
Range<1> r2;
160177

161-
auto cv = std::views::concat(r1, r2);
178+
auto cv = std::views::concat(r1, r2);
162179
auto iter1 = cv.begin();
163180
auto iter2 = std::ranges::next(cv.begin(), 4);
164181
auto iter3 = cv.begin();
165-
flag = true;
182+
flag = true;
166183
try {
167-
iter1 = std::move(iter2);
184+
iter1 = std::move(iter2);
168185
} catch (...) {
169-
TEST_LIBCPP_ASSERT_FAILURE(
170-
[=] {
171-
(void)(iter1 == iter3);
172-
}(),
173-
"valueless by exception");
186+
TEST_LIBCPP_ASSERT_FAILURE([=] { (void)(iter1 == iter3); }(), "valueless by exception");
174187
}
175188
}
176189

@@ -180,19 +193,15 @@ int main() {
180193
Range<0> r1;
181194
Range<1> r2;
182195

183-
auto cv = std::views::concat(r1, r2);
196+
auto cv = std::views::concat(r1, r2);
184197
auto iter1 = cv.begin();
185198
auto iter2 = std::ranges::next(cv.begin(), 4);
186-
flag = true;
199+
flag = true;
187200
try {
188-
iter1 = std::move(iter2);
201+
iter1 = std::move(iter2);
189202
} catch (...) {
190203
//ASSERT_SAME_TYPE(decltype(iter1), int);
191-
TEST_LIBCPP_ASSERT_FAILURE(
192-
[&] {
193-
iter1--;
194-
}(),
195-
"valueless by exception");
204+
TEST_LIBCPP_ASSERT_FAILURE([&] { iter1--; }(), "valueless by exception");
196205
}
197206
}
198207

@@ -202,18 +211,14 @@ int main() {
202211
Range<0> r1;
203212
Range<1> r2;
204213

205-
auto cv = std::views::concat(r1, r2);
214+
auto cv = std::views::concat(r1, r2);
206215
auto iter1 = cv.begin();
207216
auto iter2 = std::ranges::next(cv.begin(), 4);
208-
flag = true;
217+
flag = true;
209218
try {
210-
iter1 = std::move(iter2);
219+
iter1 = std::move(iter2);
211220
} catch (...) {
212-
TEST_LIBCPP_ASSERT_FAILURE(
213-
[&] {
214-
++iter1;
215-
}(),
216-
"valueless by exception");
221+
TEST_LIBCPP_ASSERT_FAILURE([&] { ++iter1; }(), "valueless by exception");
217222
}
218223
}
219224

@@ -223,18 +228,14 @@ int main() {
223228
Range<0> r1;
224229
Range<1> r2;
225230

226-
auto cv = std::views::concat(r1, r2);
231+
auto cv = std::views::concat(r1, r2);
227232
auto iter1 = cv.begin();
228233
auto iter2 = std::ranges::next(cv.begin(), 4);
229-
flag = true;
234+
flag = true;
230235
try {
231-
iter1 = std::move(iter2);
236+
iter1 = std::move(iter2);
232237
} catch (...) {
233-
TEST_LIBCPP_ASSERT_FAILURE(
234-
[&] {
235-
iter1 += 1;
236-
}(),
237-
"valueless by exception");
238+
TEST_LIBCPP_ASSERT_FAILURE([&] { iter1 += 1; }(), "valueless by exception");
238239
}
239240
}
240241

@@ -244,12 +245,12 @@ int main() {
244245
Range<0> r1;
245246
Range<1> r2;
246247

247-
auto cv = std::views::concat(r1, r2);
248+
auto cv = std::views::concat(r1, r2);
248249
auto iter1 = cv.begin();
249250
auto iter2 = std::ranges::next(cv.begin(), 4);
250-
flag = true;
251+
flag = true;
251252
try {
252-
iter1 = std::move(iter2);
253+
iter1 = std::move(iter2);
253254
} catch (...) {
254255
TEST_LIBCPP_ASSERT_FAILURE(
255256
[&] {

0 commit comments

Comments
 (0)