array_view_unittest.cc (19819B)
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 11 #include "api/array_view.h" 12 13 #include <array> 14 #include <cstddef> 15 #include <cstdint> 16 #include <string> 17 #include <utility> 18 #include <vector> 19 20 #include "rtc_base/buffer.h" 21 #include "rtc_base/checks.h" 22 #include "test/gmock.h" 23 #include "test/gtest.h" 24 25 namespace webrtc { 26 27 namespace { 28 29 using ::testing::ElementsAre; 30 using ::testing::IsEmpty; 31 32 template <typename T> 33 size_t Call(ArrayView<T> av) { 34 return av.size(); 35 } 36 37 template <typename T, size_t N> 38 void CallFixed(ArrayView<T, N> /* av */) {} 39 40 } // namespace 41 42 TEST(ArrayViewDeathTest, TestConstructFromPtrAndArray) { 43 char arr[] = "Arrr!"; 44 const char carr[] = "Carrr!"; 45 EXPECT_EQ(6u, Call<const char>(arr)); 46 EXPECT_EQ(7u, Call<const char>(carr)); 47 EXPECT_EQ(6u, Call<char>(arr)); 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()); 56 ArrayView<char, 6> yf = arr; 57 static_assert(yf.size() == 6, ""); 58 EXPECT_EQ(arr, yf.data()); 59 ArrayView<const char> z(arr + 1, 3); 60 EXPECT_EQ(3u, z.size()); 61 EXPECT_EQ(arr + 1, z.data()); 62 ArrayView<const char, 3> zf(arr + 1, 3); 63 static_assert(zf.size() == 3, ""); 64 EXPECT_EQ(arr + 1, zf.data()); 65 ArrayView<const char> w(arr, 2); 66 EXPECT_EQ(2u, w.size()); 67 EXPECT_EQ(arr, w.data()); 68 ArrayView<const char, 2> wf(arr, 2); 69 static_assert(wf.size() == 2, ""); 70 EXPECT_EQ(arr, wf.data()); 71 ArrayView<char> q(arr, 0); 72 EXPECT_EQ(0u, q.size()); 73 EXPECT_EQ(nullptr, q.data()); 74 ArrayView<char, 0> qf(arr, 0); 75 static_assert(qf.size() == 0, ""); 76 EXPECT_EQ(nullptr, qf.data()); 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 86 TEST(ArrayViewTest, TestCopyConstructorVariableLvalue) { 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 103 TEST(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 120 TEST(ArrayViewTest, TestCopyConstructorFixedLvalue) { 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 151 TEST(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 182 TEST(ArrayViewTest, TestCopyAssignmentVariableLvalue) { 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 203 TEST(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 224 TEST(ArrayViewTest, TestCopyAssignmentFixedLvalue) { 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 260 TEST(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 296 TEST(ArrayViewTest, TestStdArray) { 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}); 299 constexpr size_t size = 5; 300 std::array<float, size> arr{}; 301 // Fixed size view. 302 ArrayView<float, size> arr_view_fixed(arr); 303 EXPECT_EQ(arr.data(), arr_view_fixed.data()); 304 static_assert(size == arr_view_fixed.size(), ""); 305 // Variable size view. 306 ArrayView<float> arr_view(arr); 307 EXPECT_EQ(arr.data(), arr_view.data()); 308 EXPECT_EQ(size, arr_view.size()); 309 } 310 311 TEST(ArrayViewTest, TestConstStdArray) { 312 constexpr size_t size = 5; 313 314 constexpr std::array<float, size> constexpr_arr{}; 315 ArrayView<const float, size> constexpr_arr_view(constexpr_arr); 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{}; 320 ArrayView<const float, size> const_arr_view(const_arr); 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{}; 325 ArrayView<const float, size> non_const_arr_view(non_const_arr); 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 330 TEST(ArrayViewTest, TestStdVector) { 331 EXPECT_EQ(3u, Call<const int>(std::vector<int>{4, 5, 6})); 332 std::vector<int> v; 333 v.push_back(3); 334 v.push_back(11); 335 EXPECT_EQ(2u, Call<const int>(v)); 336 EXPECT_EQ(2u, Call<int>(v)); 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; 347 EXPECT_EQ(0u, Call<const int>(cv)); 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 355 TEST(ArrayViewTest, TestRtcBuffer) { 356 Buffer b = "so buffer"; 357 EXPECT_EQ(10u, Call<const uint8_t>(b)); 358 EXPECT_EQ(10u, Call<uint8_t>(b)); 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. 368 const Buffer cb = "very const"; 369 EXPECT_EQ(11u, Call<const uint8_t>(cb)); 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 377 TEST(ArrayViewTest, TestSwapVariable) { 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 396 TEST(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 413 TEST(ArrayViewDeathTest, TestIndexing) { 414 char arr[] = "abcdefg"; 415 ArrayView<char> x(arr); 416 const ArrayView<char> y(arr); 417 ArrayView<const char, 8> z(arr); 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 435 TEST(ArrayViewTest, TestIterationEmpty) { 436 // Variable-size. 437 ArrayView<std::vector<std::vector<std::vector<std::string>>>> av; 438 EXPECT_EQ(av.begin(), av.end()); 439 EXPECT_EQ(av.cbegin(), av.cend()); 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 } 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 } 453 } 454 455 TEST(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 469 TEST(ArrayViewTest, TestIterationVariable) { 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 490 TEST(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 509 TEST(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 530 TEST(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 549 TEST(ArrayViewTest, TestEmpty) { 550 EXPECT_TRUE(ArrayView<int>().empty()); 551 const int a[] = {1, 2, 3}; 552 EXPECT_FALSE(ArrayView<const int>(a).empty()); 553 554 static_assert(ArrayView<int, 0>::empty(), ""); 555 static_assert(!ArrayView<int, 3>::empty(), ""); 556 } 557 558 TEST(ArrayViewTest, TestCompare) { 559 int a[] = {1, 2, 3}; 560 int b[] = {1, 2, 3}; 561 562 EXPECT_EQ(ArrayView<int>(a), ArrayView<int>(a)); 563 EXPECT_EQ((ArrayView<int, 3>(a)), (ArrayView<int, 3>(a))); 564 EXPECT_EQ(ArrayView<int>(a), (ArrayView<int, 3>(a))); 565 EXPECT_EQ(ArrayView<int>(), ArrayView<int>()); 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 570 EXPECT_NE(ArrayView<int>(a), ArrayView<int>(b)); 571 EXPECT_NE((ArrayView<int, 3>(a)), (ArrayView<int, 3>(b))); 572 EXPECT_NE((ArrayView<int, 3>(a)), ArrayView<int>(b)); 573 EXPECT_NE(ArrayView<int>(a), ArrayView<int>()); 574 EXPECT_NE(ArrayView<int>(a), ArrayView<int>(a, 2)); 575 EXPECT_NE((ArrayView<int, 3>(a)), (ArrayView<int, 2>(a, 2))); 576 } 577 578 TEST(ArrayViewTest, TestSubViewVariable) { 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 595 TEST(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 612 TEST(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 622 TEST(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 } 631 } // namespace webrtc