Thanks to visit codestin.com
Credit goes to webrtc.googlesource.com

Google Git
Sign in
webrtc / src / refs/heads/lkgr / . / api / array_view_unittest.cc
blob: f424cd2ff6ce5ceae016f8456f66c04117005d27 [file] [log] [blame]
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]1/*
2 * Copyright 2015 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Jonas Olssona4d87372019-07-05 17:08:33[diff] [blame]11#include "api/array_view.h"
12
Alessio Bazzica858c4d72018-05-14 14:33:58[diff] [blame]13#include <array>
Dor Henaefed552024-06-18 13:20:35[diff] [blame]14#include <cstddef>
Philipp Hanckeb2ea9362025-07-18 17:47:39[diff] [blame]15#include <cstdint>
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]16#include <string>
kwiberg529662a2017-09-04 12:43:17[diff] [blame]17#include <utility>
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]18#include <vector>
19
Mirko Bonadei92ea95e2017-09-15 04:47:31[diff] [blame]20#include "rtc_base/buffer.h"
21#include "rtc_base/checks.h"
Mirko Bonadei92ea95e2017-09-15 04:47:31[diff] [blame]22#include "test/gmock.h"
Dor Henaefed552024-06-18 13:20:35[diff] [blame]23#include "test/gtest.h"
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]24
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]25namespace webrtc {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]26
27namespace {
kwibergbd431722016-09-05 11:20:54[diff] [blame]28
danilchapa28780e2016-11-18 09:46:23[diff] [blame]29using ::testing::ElementsAre;
30using ::testing::IsEmpty;
31
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]32template <typename T>
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]33size_t Call(ArrayView<T> av) {
34 return av.size();
35}
36
37template <typename T, size_t N>
Dor Hen6d58a432024-10-22 09:27:35[diff] [blame]38void CallFixed(ArrayView<T, N> /* av */) {}
kwibergbd431722016-09-05 11:20:54[diff] [blame]39
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]40} // namespace
41
Tommi909f3a52020-05-18 14:47:56[diff] [blame]42TEST(ArrayViewDeathTest, TestConstructFromPtrAndArray) {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]43 char arr[] = "Arrr!";
44 const char carr[] = "Carrr!";
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]45 EXPECT_EQ(6u, Call<const char>(arr));
46 EXPECT_EQ(7u, Call<const char>(carr));
47 EXPECT_EQ(6u, Call<char>(arr));
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]48 // Call<char>(carr); // Compile error, because can't drop const.
49 // Call<int>(arr); // Compile error, because incompatible types.
50 ArrayView<int*> x;
51 EXPECT_EQ(0u, x.size());
52 EXPECT_EQ(nullptr, x.data());
53 ArrayView<char> y = arr;
54 EXPECT_EQ(6u, y.size());
55 EXPECT_EQ(arr, y.data());
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]56 ArrayView<char, 6> yf = arr;
57 static_assert(yf.size() == 6, "");
58 EXPECT_EQ(arr, yf.data());
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]59 ArrayView<const char> z(arr + 1, 3);
60 EXPECT_EQ(3u, z.size());
61 EXPECT_EQ(arr + 1, z.data());
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]62 ArrayView<const char, 3> zf(arr + 1, 3);
63 static_assert(zf.size() == 3, "");
64 EXPECT_EQ(arr + 1, zf.data());
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]65 ArrayView<const char> w(arr, 2);
66 EXPECT_EQ(2u, w.size());
67 EXPECT_EQ(arr, w.data());
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]68 ArrayView<const char, 2> wf(arr, 2);
69 static_assert(wf.size() == 2, "");
70 EXPECT_EQ(arr, wf.data());
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]71 ArrayView<char> q(arr, 0);
72 EXPECT_EQ(0u, q.size());
73 EXPECT_EQ(nullptr, q.data());
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]74 ArrayView<char, 0> qf(arr, 0);
75 static_assert(qf.size() == 0, "");
76 EXPECT_EQ(nullptr, qf.data());
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]77#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
78 // DCHECK error (nullptr with nonzero size).
79 EXPECT_DEATH(ArrayView<int>(static_cast<int*>(nullptr), 5), "");
80#endif
81 // These are compile errors, because incompatible types.
82 // ArrayView<int> m = arr;
83 // ArrayView<float> n(arr + 2, 2);
84}
85
Karl Wibergc62e4c52020-02-27 21:23:06[diff] [blame]86TEST(ArrayViewTest, TestCopyConstructorVariableLvalue) {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]87 char arr[] = "Arrr!";
88 ArrayView<char> x = arr;
89 EXPECT_EQ(6u, x.size());
90 EXPECT_EQ(arr, x.data());
91 ArrayView<char> y = x; // Copy non-const -> non-const.
92 EXPECT_EQ(6u, y.size());
93 EXPECT_EQ(arr, y.data());
94 ArrayView<const char> z = x; // Copy non-const -> const.
95 EXPECT_EQ(6u, z.size());
96 EXPECT_EQ(arr, z.data());
97 ArrayView<const char> w = z; // Copy const -> const.
98 EXPECT_EQ(6u, w.size());
99 EXPECT_EQ(arr, w.data());
100 // ArrayView<char> v = z; // Compile error, because can't drop const.
101}
102
Karl Wibergc62e4c52020-02-27 21:23:06[diff] [blame]103TEST(ArrayViewTest, TestCopyConstructorVariableRvalue) {
104 char arr[] = "Arrr!";
105 ArrayView<char> x = arr;
106 EXPECT_EQ(6u, x.size());
107 EXPECT_EQ(arr, x.data());
108 ArrayView<char> y = std::move(x); // Copy non-const -> non-const.
109 EXPECT_EQ(6u, y.size());
110 EXPECT_EQ(arr, y.data());
111 ArrayView<const char> z = std::move(x); // Copy non-const -> const.
112 EXPECT_EQ(6u, z.size());
113 EXPECT_EQ(arr, z.data());
114 ArrayView<const char> w = std::move(z); // Copy const -> const.
115 EXPECT_EQ(6u, w.size());
116 EXPECT_EQ(arr, w.data());
117 // ArrayView<char> v = std::move(z); // Error, because can't drop const.
118}
119
Karl Wibergff61f3a2020-02-28 09:01:18[diff] [blame]120TEST(ArrayViewTest, TestCopyConstructorFixedLvalue) {
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]121 char arr[] = "Arrr!";
122 ArrayView<char, 6> x = arr;
123 static_assert(x.size() == 6, "");
124 EXPECT_EQ(arr, x.data());
125
126 // Copy fixed -> fixed.
127 ArrayView<char, 6> y = x; // Copy non-const -> non-const.
128 static_assert(y.size() == 6, "");
129 EXPECT_EQ(arr, y.data());
130 ArrayView<const char, 6> z = x; // Copy non-const -> const.
131 static_assert(z.size() == 6, "");
132 EXPECT_EQ(arr, z.data());
133 ArrayView<const char, 6> w = z; // Copy const -> const.
134 static_assert(w.size() == 6, "");
135 EXPECT_EQ(arr, w.data());
136 // ArrayView<char, 6> v = z; // Compile error, because can't drop const.
137
138 // Copy fixed -> variable.
139 ArrayView<char> yv = x; // Copy non-const -> non-const.
140 EXPECT_EQ(6u, yv.size());
141 EXPECT_EQ(arr, yv.data());
142 ArrayView<const char> zv = x; // Copy non-const -> const.
143 EXPECT_EQ(6u, zv.size());
144 EXPECT_EQ(arr, zv.data());
145 ArrayView<const char> wv = z; // Copy const -> const.
146 EXPECT_EQ(6u, wv.size());
147 EXPECT_EQ(arr, wv.data());
148 // ArrayView<char> vv = z; // Compile error, because can't drop const.
149}
150
Karl Wibergff61f3a2020-02-28 09:01:18[diff] [blame]151TEST(ArrayViewTest, TestCopyConstructorFixedRvalue) {
152 char arr[] = "Arrr!";
153 ArrayView<char, 6> x = arr;
154 static_assert(x.size() == 6, "");
155 EXPECT_EQ(arr, x.data());
156
157 // Copy fixed -> fixed.
158 ArrayView<char, 6> y = std::move(x); // Copy non-const -> non-const.
159 static_assert(y.size() == 6, "");
160 EXPECT_EQ(arr, y.data());
161 ArrayView<const char, 6> z = std::move(x); // Copy non-const -> const.
162 static_assert(z.size() == 6, "");
163 EXPECT_EQ(arr, z.data());
164 ArrayView<const char, 6> w = std::move(z); // Copy const -> const.
165 static_assert(w.size() == 6, "");
166 EXPECT_EQ(arr, w.data());
167 // ArrayView<char, 6> v = std::move(z); // Error, because can't drop const.
168
169 // Copy fixed -> variable.
170 ArrayView<char> yv = std::move(x); // Copy non-const -> non-const.
171 EXPECT_EQ(6u, yv.size());
172 EXPECT_EQ(arr, yv.data());
173 ArrayView<const char> zv = std::move(x); // Copy non-const -> const.
174 EXPECT_EQ(6u, zv.size());
175 EXPECT_EQ(arr, zv.data());
176 ArrayView<const char> wv = std::move(z); // Copy const -> const.
177 EXPECT_EQ(6u, wv.size());
178 EXPECT_EQ(arr, wv.data());
179 // ArrayView<char> vv = std::move(z); // Error, because can't drop const.
180}
181
Karl Wibergc62e4c52020-02-27 21:23:06[diff] [blame]182TEST(ArrayViewTest, TestCopyAssignmentVariableLvalue) {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]183 char arr[] = "Arrr!";
184 ArrayView<char> x(arr);
185 EXPECT_EQ(6u, x.size());
186 EXPECT_EQ(arr, x.data());
187 ArrayView<char> y;
188 y = x; // Copy non-const -> non-const.
189 EXPECT_EQ(6u, y.size());
190 EXPECT_EQ(arr, y.data());
191 ArrayView<const char> z;
192 z = x; // Copy non-const -> const.
193 EXPECT_EQ(6u, z.size());
194 EXPECT_EQ(arr, z.data());
195 ArrayView<const char> w;
196 w = z; // Copy const -> const.
197 EXPECT_EQ(6u, w.size());
198 EXPECT_EQ(arr, w.data());
199 // ArrayView<char> v;
200 // v = z; // Compile error, because can't drop const.
201}
202
Karl Wibergc62e4c52020-02-27 21:23:06[diff] [blame]203TEST(ArrayViewTest, TestCopyAssignmentVariableRvalue) {
204 char arr[] = "Arrr!";
205 ArrayView<char> x(arr);
206 EXPECT_EQ(6u, x.size());
207 EXPECT_EQ(arr, x.data());
208 ArrayView<char> y;
209 y = std::move(x); // Copy non-const -> non-const.
210 EXPECT_EQ(6u, y.size());
211 EXPECT_EQ(arr, y.data());
212 ArrayView<const char> z;
213 z = std::move(x); // Copy non-const -> const.
214 EXPECT_EQ(6u, z.size());
215 EXPECT_EQ(arr, z.data());
216 ArrayView<const char> w;
217 w = std::move(z); // Copy const -> const.
218 EXPECT_EQ(6u, w.size());
219 EXPECT_EQ(arr, w.data());
220 // ArrayView<char> v;
221 // v = std::move(z); // Compile error, because can't drop const.
222}
223
Karl Wibergff61f3a2020-02-28 09:01:18[diff] [blame]224TEST(ArrayViewTest, TestCopyAssignmentFixedLvalue) {
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]225 char arr[] = "Arrr!";
226 char init[] = "Init!";
227 ArrayView<char, 6> x(arr);
228 EXPECT_EQ(arr, x.data());
229
230 // Copy fixed -> fixed.
231 ArrayView<char, 6> y(init);
232 y = x; // Copy non-const -> non-const.
233 EXPECT_EQ(arr, y.data());
234 ArrayView<const char, 6> z(init);
235 z = x; // Copy non-const -> const.
236 EXPECT_EQ(arr, z.data());
237 ArrayView<const char, 6> w(init);
238 w = z; // Copy const -> const.
239 EXPECT_EQ(arr, w.data());
240 // ArrayView<char, 6> v(init);
241 // v = z; // Compile error, because can't drop const.
242
243 // Copy fixed -> variable.
244 ArrayView<char> yv;
245 yv = x; // Copy non-const -> non-const.
246 EXPECT_EQ(6u, yv.size());
247 EXPECT_EQ(arr, yv.data());
248 ArrayView<const char> zv;
249 zv = x; // Copy non-const -> const.
250 EXPECT_EQ(6u, zv.size());
251 EXPECT_EQ(arr, zv.data());
252 ArrayView<const char> wv;
253 wv = z; // Copy const -> const.
254 EXPECT_EQ(6u, wv.size());
255 EXPECT_EQ(arr, wv.data());
256 // ArrayView<char> v;
257 // v = z; // Compile error, because can't drop const.
258}
259
Karl Wibergff61f3a2020-02-28 09:01:18[diff] [blame]260TEST(ArrayViewTest, TestCopyAssignmentFixedRvalue) {
261 char arr[] = "Arrr!";
262 char init[] = "Init!";
263 ArrayView<char, 6> x(arr);
264 EXPECT_EQ(arr, x.data());
265
266 // Copy fixed -> fixed.
267 ArrayView<char, 6> y(init);
268 y = std::move(x); // Copy non-const -> non-const.
269 EXPECT_EQ(arr, y.data());
270 ArrayView<const char, 6> z(init);
271 z = std::move(x); // Copy non-const -> const.
272 EXPECT_EQ(arr, z.data());
273 ArrayView<const char, 6> w(init);
274 w = std::move(z); // Copy const -> const.
275 EXPECT_EQ(arr, w.data());
276 // ArrayView<char, 6> v(init);
277 // v = std::move(z); // Compile error, because can't drop const.
278
279 // Copy fixed -> variable.
280 ArrayView<char> yv;
281 yv = std::move(x); // Copy non-const -> non-const.
282 EXPECT_EQ(6u, yv.size());
283 EXPECT_EQ(arr, yv.data());
284 ArrayView<const char> zv;
285 zv = std::move(x); // Copy non-const -> const.
286 EXPECT_EQ(6u, zv.size());
287 EXPECT_EQ(arr, zv.data());
288 ArrayView<const char> wv;
289 wv = std::move(z); // Copy const -> const.
290 EXPECT_EQ(6u, wv.size());
291 EXPECT_EQ(arr, wv.data());
292 // ArrayView<char> v;
293 // v = std::move(z); // Compile error, because can't drop const.
294}
295
Alessio Bazzica858c4d72018-05-14 14:33:58[diff] [blame]296TEST(ArrayViewTest, TestStdArray) {
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]297 EXPECT_EQ(4u, Call<const int>(std::array<int, 4>{1, 2, 3, 4}));
298 CallFixed<const int, 3>(std::array<int, 3>{2, 3, 4});
Alessio Bazzica858c4d72018-05-14 14:33:58[diff] [blame]299 constexpr size_t size = 5;
300 std::array<float, size> arr{};
301 // Fixed size view.
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]302 ArrayView<float, size> arr_view_fixed(arr);
Alessio Bazzica858c4d72018-05-14 14:33:58[diff] [blame]303 EXPECT_EQ(arr.data(), arr_view_fixed.data());
304 static_assert(size == arr_view_fixed.size(), "");
305 // Variable size view.
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]306 ArrayView<float> arr_view(arr);
Alessio Bazzica858c4d72018-05-14 14:33:58[diff] [blame]307 EXPECT_EQ(arr.data(), arr_view.data());
308 EXPECT_EQ(size, arr_view.size());
309}
310
Alessio Bazzica28a325b2018-05-15 12:57:51[diff] [blame]311TEST(ArrayViewTest, TestConstStdArray) {
312 constexpr size_t size = 5;
313
314 constexpr std::array<float, size> constexpr_arr{};
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]315 ArrayView<const float, size> constexpr_arr_view(constexpr_arr);
Alessio Bazzica28a325b2018-05-15 12:57:51[diff] [blame]316 EXPECT_EQ(constexpr_arr.data(), constexpr_arr_view.data());
317 static_assert(constexpr_arr.size() == constexpr_arr_view.size(), "");
318
319 const std::array<float, size> const_arr{};
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]320 ArrayView<const float, size> const_arr_view(const_arr);
Alessio Bazzica28a325b2018-05-15 12:57:51[diff] [blame]321 EXPECT_EQ(const_arr.data(), const_arr_view.data());
322 static_assert(const_arr.size() == const_arr_view.size(), "");
323
324 std::array<float, size> non_const_arr{};
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]325 ArrayView<const float, size> non_const_arr_view(non_const_arr);
Alessio Bazzica28a325b2018-05-15 12:57:51[diff] [blame]326 EXPECT_EQ(non_const_arr.data(), non_const_arr_view.data());
327 static_assert(non_const_arr.size() == non_const_arr_view.size(), "");
328}
329
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]330TEST(ArrayViewTest, TestStdVector) {
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]331 EXPECT_EQ(3u, Call<const int>(std::vector<int>{4, 5, 6}));
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]332 std::vector<int> v;
333 v.push_back(3);
334 v.push_back(11);
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]335 EXPECT_EQ(2u, Call<const int>(v));
336 EXPECT_EQ(2u, Call<int>(v));
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]337 // Call<unsigned int>(v); // Compile error, because incompatible types.
338 ArrayView<int> x = v;
339 EXPECT_EQ(2u, x.size());
340 EXPECT_EQ(v.data(), x.data());
341 ArrayView<const int> y;
342 y = v;
343 EXPECT_EQ(2u, y.size());
344 EXPECT_EQ(v.data(), y.data());
345 // ArrayView<double> d = v; // Compile error, because incompatible types.
346 const std::vector<int> cv;
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]347 EXPECT_EQ(0u, Call<const int>(cv));
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]348 // Call<int>(cv); // Compile error, because can't drop const.
349 ArrayView<const int> z = cv;
350 EXPECT_EQ(0u, z.size());
351 EXPECT_EQ(nullptr, z.data());
352 // ArrayView<int> w = cv; // Compile error, because can't drop const.
353}
354
355TEST(ArrayViewTest, TestRtcBuffer) {
Evan Shrubsoleee5ab342025-04-15 14:49:46[diff] [blame]356 Buffer b = "so buffer";
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]357 EXPECT_EQ(10u, Call<const uint8_t>(b));
358 EXPECT_EQ(10u, Call<uint8_t>(b));
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]359 // Call<int8_t>(b); // Compile error, because incompatible types.
360 ArrayView<uint8_t> x = b;
361 EXPECT_EQ(10u, x.size());
362 EXPECT_EQ(b.data(), x.data());
363 ArrayView<const uint8_t> y;
364 y = b;
365 EXPECT_EQ(10u, y.size());
366 EXPECT_EQ(b.data(), y.data());
367 // ArrayView<char> d = b; // Compile error, because incompatible types.
Evan Shrubsoleee5ab342025-04-15 14:49:46[diff] [blame]368 const Buffer cb = "very const";
Karl Wiberg30abc362019-02-04 12:07:18[diff] [blame]369 EXPECT_EQ(11u, Call<const uint8_t>(cb));
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]370 // Call<uint8_t>(cb); // Compile error, because can't drop const.
371 ArrayView<const uint8_t> z = cb;
372 EXPECT_EQ(11u, z.size());
373 EXPECT_EQ(cb.data(), z.data());
374 // ArrayView<uint8_t> w = cb; // Compile error, because can't drop const.
375}
376
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]377TEST(ArrayViewTest, TestSwapVariable) {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]378 const char arr[] = "Arrr!";
379 const char aye[] = "Aye, Cap'n!";
380 ArrayView<const char> x(arr);
381 EXPECT_EQ(6u, x.size());
382 EXPECT_EQ(arr, x.data());
383 ArrayView<const char> y(aye);
384 EXPECT_EQ(12u, y.size());
385 EXPECT_EQ(aye, y.data());
386 using std::swap;
387 swap(x, y);
388 EXPECT_EQ(12u, x.size());
389 EXPECT_EQ(aye, x.data());
390 EXPECT_EQ(6u, y.size());
391 EXPECT_EQ(arr, y.data());
392 // ArrayView<char> z;
393 // swap(x, z); // Compile error, because can't drop const.
394}
395
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]396TEST(FixArrayViewTest, TestSwapFixed) {
397 const char arr[] = "Arr!";
398 char aye[] = "Aye!";
399 ArrayView<const char, 5> x(arr);
400 EXPECT_EQ(arr, x.data());
401 ArrayView<const char, 5> y(aye);
402 EXPECT_EQ(aye, y.data());
403 using std::swap;
404 swap(x, y);
405 EXPECT_EQ(aye, x.data());
406 EXPECT_EQ(arr, y.data());
407 // ArrayView<char, 5> z(aye);
408 // swap(x, z); // Compile error, because can't drop const.
409 // ArrayView<const char, 4> w(aye, 4);
410 // swap(x, w); // Compile error, because different sizes.
411}
412
Tommi909f3a52020-05-18 14:47:56[diff] [blame]413TEST(ArrayViewDeathTest, TestIndexing) {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]414 char arr[] = "abcdefg";
415 ArrayView<char> x(arr);
416 const ArrayView<char> y(arr);
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]417 ArrayView<const char, 8> z(arr);
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]418 EXPECT_EQ(8u, x.size());
419 EXPECT_EQ(8u, y.size());
420 EXPECT_EQ(8u, z.size());
421 EXPECT_EQ('b', x[1]);
422 EXPECT_EQ('c', y[2]);
423 EXPECT_EQ('d', z[3]);
424 x[3] = 'X';
425 y[2] = 'Y';
426 // z[1] = 'Z'; // Compile error, because z's element type is const char.
427 EXPECT_EQ('b', x[1]);
428 EXPECT_EQ('Y', y[2]);
429 EXPECT_EQ('X', z[3]);
430#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
431 EXPECT_DEATH(z[8], ""); // DCHECK error (index out of bounds).
432#endif
433}
434
435TEST(ArrayViewTest, TestIterationEmpty) {
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]436 // Variable-size.
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]437 ArrayView<std::vector<std::vector<std::vector<std::string>>>> av;
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]438 EXPECT_EQ(av.begin(), av.end());
439 EXPECT_EQ(av.cbegin(), av.cend());
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]440 for (auto& e : av) {
441 EXPECT_TRUE(false);
442 EXPECT_EQ(42u, e.size()); // Dummy use of e to prevent unused var warning.
443 }
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]444
445 // Fixed-size.
446 ArrayView<std::vector<std::vector<std::vector<std::string>>>, 0> af;
447 EXPECT_EQ(af.begin(), af.end());
448 EXPECT_EQ(af.cbegin(), af.cend());
449 for (auto& e : af) {
450 EXPECT_TRUE(false);
451 EXPECT_EQ(42u, e.size()); // Dummy use of e to prevent unused var warning.
452 }
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]453}
454
Alessio Bazzicae2c54852020-10-20 15:24:55[diff] [blame]455TEST(ArrayViewTest, TestReverseIterationEmpty) {
456 // Variable-size.
457 ArrayView<std::vector<std::vector<std::vector<std::string>>>> av;
458 EXPECT_EQ(av.rbegin(), av.rend());
459 EXPECT_EQ(av.crbegin(), av.crend());
460 EXPECT_TRUE(av.empty());
461
462 // Fixed-size.
463 ArrayView<std::vector<std::vector<std::vector<std::string>>>, 0> af;
464 EXPECT_EQ(af.begin(), af.end());
465 EXPECT_EQ(af.cbegin(), af.cend());
466 EXPECT_TRUE(af.empty());
467}
468
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]469TEST(ArrayViewTest, TestIterationVariable) {
Karl Wiberge2a83ee2015-10-26 18:51:29[diff] [blame]470 char arr[] = "Arrr!";
471 ArrayView<char> av(arr);
472 EXPECT_EQ('A', *av.begin());
473 EXPECT_EQ('A', *av.cbegin());
474 EXPECT_EQ('\0', *(av.end() - 1));
475 EXPECT_EQ('\0', *(av.cend() - 1));
476 char i = 0;
477 for (auto& e : av) {
478 EXPECT_EQ(arr + i, &e);
479 e = 's' + i;
480 ++i;
481 }
482 i = 0;
483 for (auto& e : ArrayView<const char>(av)) {
484 EXPECT_EQ(arr + i, &e);
485 // e = 'q' + i; // Compile error, because e is a const char&.
486 ++i;
487 }
488}
489
Alessio Bazzicae2c54852020-10-20 15:24:55[diff] [blame]490TEST(ArrayViewTest, TestReverseIterationVariable) {
491 char arr[] = "Arrr!";
492 ArrayView<char> av(arr);
493 EXPECT_EQ('\0', *av.rbegin());
494 EXPECT_EQ('\0', *av.crbegin());
495 EXPECT_EQ('A', *(av.rend() - 1));
496 EXPECT_EQ('A', *(av.crend() - 1));
497
498 const char* cit = av.cend() - 1;
499 for (auto crit = av.crbegin(); crit != av.crend(); ++crit, --cit) {
500 EXPECT_EQ(*cit, *crit);
501 }
502
503 char* it = av.end() - 1;
504 for (auto rit = av.rbegin(); rit != av.rend(); ++rit, --it) {
505 EXPECT_EQ(*it, *rit);
506 }
507}
508
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]509TEST(ArrayViewTest, TestIterationFixed) {
510 char arr[] = "Arrr!";
511 ArrayView<char, 6> av(arr);
512 EXPECT_EQ('A', *av.begin());
513 EXPECT_EQ('A', *av.cbegin());
514 EXPECT_EQ('\0', *(av.end() - 1));
515 EXPECT_EQ('\0', *(av.cend() - 1));
516 char i = 0;
517 for (auto& e : av) {
518 EXPECT_EQ(arr + i, &e);
519 e = 's' + i;
520 ++i;
521 }
522 i = 0;
523 for (auto& e : ArrayView<const char, 6>(av)) {
524 EXPECT_EQ(arr + i, &e);
525 // e = 'q' + i; // Compile error, because e is a const char&.
526 ++i;
527 }
528}
529
Alessio Bazzicae2c54852020-10-20 15:24:55[diff] [blame]530TEST(ArrayViewTest, TestReverseIterationFixed) {
531 char arr[] = "Arrr!";
532 ArrayView<char, 6> av(arr);
533 EXPECT_EQ('\0', *av.rbegin());
534 EXPECT_EQ('\0', *av.crbegin());
535 EXPECT_EQ('A', *(av.rend() - 1));
536 EXPECT_EQ('A', *(av.crend() - 1));
537
538 const char* cit = av.cend() - 1;
539 for (auto crit = av.crbegin(); crit != av.crend(); ++crit, --cit) {
540 EXPECT_EQ(*cit, *crit);
541 }
542
543 char* it = av.end() - 1;
544 for (auto rit = av.rbegin(); rit != av.rend(); ++rit, --it) {
545 EXPECT_EQ(*it, *rit);
546 }
547}
548
kwiberg288886b2015-11-06 09:21:35[diff] [blame]549TEST(ArrayViewTest, TestEmpty) {
550 EXPECT_TRUE(ArrayView<int>().empty());
551 const int a[] = {1, 2, 3};
552 EXPECT_FALSE(ArrayView<const int>(a).empty());
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]553
554 static_assert(ArrayView<int, 0>::empty(), "");
555 static_assert(!ArrayView<int, 3>::empty(), "");
kwiberg288886b2015-11-06 09:21:35[diff] [blame]556}
557
558TEST(ArrayViewTest, TestCompare) {
559 int a[] = {1, 2, 3};
560 int b[] = {1, 2, 3};
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]561
kwiberg288886b2015-11-06 09:21:35[diff] [blame]562 EXPECT_EQ(ArrayView<int>(a), ArrayView<int>(a));
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]563 EXPECT_EQ((ArrayView<int, 3>(a)), (ArrayView<int, 3>(a)));
564 EXPECT_EQ(ArrayView<int>(a), (ArrayView<int, 3>(a)));
kwiberg288886b2015-11-06 09:21:35[diff] [blame]565 EXPECT_EQ(ArrayView<int>(), ArrayView<int>());
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]566 EXPECT_EQ(ArrayView<int>(), ArrayView<int>(a, 0));
567 EXPECT_EQ(ArrayView<int>(a, 0), ArrayView<int>(b, 0));
568 EXPECT_EQ((ArrayView<int, 0>(a, 0)), ArrayView<int>());
569
kwiberg288886b2015-11-06 09:21:35[diff] [blame]570 EXPECT_NE(ArrayView<int>(a), ArrayView<int>(b));
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]571 EXPECT_NE((ArrayView<int, 3>(a)), (ArrayView<int, 3>(b)));
572 EXPECT_NE((ArrayView<int, 3>(a)), ArrayView<int>(b));
kwiberg288886b2015-11-06 09:21:35[diff] [blame]573 EXPECT_NE(ArrayView<int>(a), ArrayView<int>());
574 EXPECT_NE(ArrayView<int>(a), ArrayView<int>(a, 2));
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]575 EXPECT_NE((ArrayView<int, 3>(a)), (ArrayView<int, 2>(a, 2)));
kwiberg288886b2015-11-06 09:21:35[diff] [blame]576}
577
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]578TEST(ArrayViewTest, TestSubViewVariable) {
danilchapa28780e2016-11-18 09:46:23[diff] [blame]579 int a[] = {1, 2, 3};
580 ArrayView<int> av(a);
581
582 EXPECT_EQ(av.subview(0), av);
583
584 EXPECT_THAT(av.subview(1), ElementsAre(2, 3));
585 EXPECT_THAT(av.subview(2), ElementsAre(3));
586 EXPECT_THAT(av.subview(3), IsEmpty());
587 EXPECT_THAT(av.subview(4), IsEmpty());
588
589 EXPECT_THAT(av.subview(1, 0), IsEmpty());
590 EXPECT_THAT(av.subview(1, 1), ElementsAre(2));
591 EXPECT_THAT(av.subview(1, 2), ElementsAre(2, 3));
592 EXPECT_THAT(av.subview(1, 3), ElementsAre(2, 3));
593}
594
kwibergbfc7f022017-03-02 20:33:50[diff] [blame]595TEST(ArrayViewTest, TestSubViewFixed) {
596 int a[] = {1, 2, 3};
597 ArrayView<int, 3> av(a);
598
599 EXPECT_EQ(av.subview(0), av);
600
601 EXPECT_THAT(av.subview(1), ElementsAre(2, 3));
602 EXPECT_THAT(av.subview(2), ElementsAre(3));
603 EXPECT_THAT(av.subview(3), IsEmpty());
604 EXPECT_THAT(av.subview(4), IsEmpty());
605
606 EXPECT_THAT(av.subview(1, 0), IsEmpty());
607 EXPECT_THAT(av.subview(1, 1), ElementsAre(2));
608 EXPECT_THAT(av.subview(1, 2), ElementsAre(2, 3));
609 EXPECT_THAT(av.subview(1, 3), ElementsAre(2, 3));
610}
611
Amit Hilbuche155dd02019-03-22 17:16:07[diff] [blame]612TEST(ArrayViewTest, TestReinterpretCastFixedSize) {
613 uint8_t bytes[] = {1, 2, 3};
614 ArrayView<uint8_t, 3> uint8_av(bytes);
615 ArrayView<int8_t, 3> int8_av = reinterpret_array_view<int8_t>(uint8_av);
616 EXPECT_EQ(int8_av.size(), uint8_av.size());
617 EXPECT_EQ(int8_av[0], 1);
618 EXPECT_EQ(int8_av[1], 2);
619 EXPECT_EQ(int8_av[2], 3);
620}
621
622TEST(ArrayViewTest, TestReinterpretCastVariableSize) {
623 std::vector<int8_t> v = {1, 2, 3};
624 ArrayView<int8_t> int8_av(v);
625 ArrayView<uint8_t> uint8_av = reinterpret_array_view<uint8_t>(int8_av);
626 EXPECT_EQ(int8_av.size(), uint8_av.size());
627 EXPECT_EQ(uint8_av[0], 1);
628 EXPECT_EQ(uint8_av[1], 2);
629 EXPECT_EQ(uint8_av[2], 3);
630}
Evan Shrubsolefe5bdd72025-02-07 13:24:05[diff] [blame]631} // namespace webrtc