third_party/libwebrtc/api/array_view_unittest.cc

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