Introduce rtc::ArrayView<T>, which keeps track of an array that it doesn't own

webrtc/base/array_view_unittest.cc

Index: webrtc/base/array_view_unittest.cc
diff --git a/webrtc/base/array_view_unittest.cc b/webrtc/base/array_view_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0d1bff03d11de11ec3efccf91502b9d4d0ad6416
--- /dev/null
+++ b/webrtc/base/array_view_unittest.cc
@@ -0,0 +1,217 @@
+/*
+ *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/array_view.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/gunit.h"
+
+namespace rtc {
+
+namespace {
+template <typename T>
+void Call(ArrayView<T>) {}
+}  // namespace
+
+TEST(ArrayViewTest, TestConstructFromPtrAndArray) {
+  char arr[] = "Arrr!";
+  const char carr[] = "Carrr!";
+  Call<const char>(arr);
+  Call<const char>(carr);
+  Call<char>(arr);
+  // Call<char>(carr);  // Compile error, because can't drop const.
+  // Call<int>(arr);  // Compile error, because incompatible types.
+  ArrayView<int*> x;
+  EXPECT_EQ(0u, x.size());
+  EXPECT_EQ(nullptr, x.data());
+  ArrayView<char> y = arr;
+  EXPECT_EQ(6u, y.size());
+  EXPECT_EQ(arr, y.data());
+  ArrayView<const char> z(arr + 1, 3);
+  EXPECT_EQ(3u, z.size());
+  EXPECT_EQ(arr + 1, z.data());
+  ArrayView<const char> w(arr, 2);
+  EXPECT_EQ(2u, w.size());
+  EXPECT_EQ(arr, w.data());
+  ArrayView<char> q(arr, 0);
+  EXPECT_EQ(0u, q.size());
+  EXPECT_EQ(nullptr, q.data());
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+  // DCHECK error (nullptr with nonzero size).
+  EXPECT_DEATH(ArrayView<int>(static_cast<int*>(nullptr), 5), "");
+#endif
+  // These are compile errors, because incompatible types.
+  // ArrayView<int> m = arr;
+  // ArrayView<float> n(arr + 2, 2);
+}
+
+TEST(ArrayViewTest, TestCopyConstructor) {
+  char arr[] = "Arrr!";
+  ArrayView<char> x = arr;
+  EXPECT_EQ(6u, x.size());
+  EXPECT_EQ(arr, x.data());
+  ArrayView<char> y = x;  // Copy non-const -> non-const.
+  EXPECT_EQ(6u, y.size());
+  EXPECT_EQ(arr, y.data());
+  ArrayView<const char> z = x;  // Copy non-const -> const.
+  EXPECT_EQ(6u, z.size());
+  EXPECT_EQ(arr, z.data());
+  ArrayView<const char> w = z;  // Copy const -> const.
+  EXPECT_EQ(6u, w.size());
+  EXPECT_EQ(arr, w.data());
+  // ArrayView<char> v = z;  // Compile error, because can't drop const.
+}
+
+TEST(ArrayViewTest, TestCopyAssignment) {
+  char arr[] = "Arrr!";
+  ArrayView<char> x(arr);
+  EXPECT_EQ(6u, x.size());
+  EXPECT_EQ(arr, x.data());
+  ArrayView<char> y;
+  y = x;  // Copy non-const -> non-const.
+  EXPECT_EQ(6u, y.size());
+  EXPECT_EQ(arr, y.data());
+  ArrayView<const char> z;
+  z = x;  // Copy non-const -> const.
+  EXPECT_EQ(6u, z.size());
+  EXPECT_EQ(arr, z.data());
+  ArrayView<const char> w;
+  w = z;  // Copy const -> const.
+  EXPECT_EQ(6u, w.size());
+  EXPECT_EQ(arr, w.data());
+  // ArrayView<char> v;
+  // v = z;  // Compile error, because can't drop const.
+}
+
+TEST(ArrayViewTest, TestStdVector) {
+  std::vector<int> v;
+  v.push_back(3);
+  v.push_back(11);
+  Call<const int>(v);
+  Call<int>(v);
+  // Call<unsigned int>(v);  // Compile error, because incompatible types.
+  ArrayView<int> x = v;
+  EXPECT_EQ(2u, x.size());
+  EXPECT_EQ(v.data(), x.data());
+  ArrayView<const int> y;
+  y = v;
+  EXPECT_EQ(2u, y.size());
+  EXPECT_EQ(v.data(), y.data());
+  // ArrayView<double> d = v;  // Compile error, because incompatible types.
+  const std::vector<int> cv;
+  Call<const int>(cv);
+  // Call<int>(cv);  // Compile error, because can't drop const.
+  ArrayView<const int> z = cv;
+  EXPECT_EQ(0u, z.size());
+  EXPECT_EQ(nullptr, z.data());
+  // ArrayView<int> w = cv;  // Compile error, because can't drop const.
+}
+
+TEST(ArrayViewTest, TestRtcBuffer) {
+  rtc::Buffer b = "so buffer";
+  Call<const uint8_t>(b);
+  Call<uint8_t>(b);
+  // Call<int8_t>(b);  // Compile error, because incompatible types.
+  ArrayView<uint8_t> x = b;
+  EXPECT_EQ(10u, x.size());
+  EXPECT_EQ(b.data(), x.data());
+  ArrayView<const uint8_t> y;
+  y = b;
+  EXPECT_EQ(10u, y.size());
+  EXPECT_EQ(b.data(), y.data());
+  // ArrayView<char> d = b;  // Compile error, because incompatible types.
+  const rtc::Buffer cb = "very const";
+  Call<const uint8_t>(cb);
+  // Call<uint8_t>(cb);  // Compile error, because can't drop const.
+  ArrayView<const uint8_t> z = cb;
+  EXPECT_EQ(11u, z.size());
+  EXPECT_EQ(cb.data(), z.data());
+  // ArrayView<uint8_t> w = cb;  // Compile error, because can't drop const.
+}
+
+TEST(ArrayViewTest, TestSwap) {
+  const char arr[] = "Arrr!";
+  const char aye[] = "Aye, Cap'n!";
+  ArrayView<const char> x(arr);
+  EXPECT_EQ(6u, x.size());
+  EXPECT_EQ(arr, x.data());
+  ArrayView<const char> y(aye);
+  EXPECT_EQ(12u, y.size());
+  EXPECT_EQ(aye, y.data());
+  using std::swap;
+  swap(x, y);
+  EXPECT_EQ(12u, x.size());
+  EXPECT_EQ(aye, x.data());
+  EXPECT_EQ(6u, y.size());
+  EXPECT_EQ(arr, y.data());
+  // ArrayView<char> z;
+  // swap(x, z);  // Compile error, because can't drop const.
+}
+
+TEST(ArrayViewTest, TestIndexing) {
+  char arr[] = "abcdefg";
+  ArrayView<char> x(arr);
+  const ArrayView<char> y(arr);
+  ArrayView<const char> z(arr);
+  EXPECT_EQ(8u, x.size());
+  EXPECT_EQ(8u, y.size());
+  EXPECT_EQ(8u, z.size());
+  EXPECT_EQ('b', x[1]);
+  EXPECT_EQ('c', y[2]);
+  EXPECT_EQ('d', z[3]);
+  x[3] = 'X';
+  y[2] = 'Y';
+  // z[1] = 'Z';  // Compile error, because z's element type is const char.
+  EXPECT_EQ('b', x[1]);
+  EXPECT_EQ('Y', y[2]);
+  EXPECT_EQ('X', z[3]);
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+  EXPECT_DEATH(z[8], "");  // DCHECK error (index out of bounds).
+#endif
+}
+
+TEST(ArrayViewTest, TestIterationEmpty) {
+  ArrayView<std::vector<std::vector<std::vector<std::string>>>> av;
+  EXPECT_FALSE(av.begin());
+  EXPECT_FALSE(av.cbegin());
+  EXPECT_FALSE(av.end());
+  EXPECT_FALSE(av.cend());
+  for (auto& e : av) {
+    EXPECT_TRUE(false);
+    EXPECT_EQ(42u, e.size());  // Dummy use of e to prevent unused var warning.
+  }
+}
+
+TEST(ArrayViewTest, TestIteration) {
+  char arr[] = "Arrr!";
+  ArrayView<char> av(arr);
+  EXPECT_EQ('A', *av.begin());
+  EXPECT_EQ('A', *av.cbegin());
+  EXPECT_EQ('\0', *(av.end() - 1));
+  EXPECT_EQ('\0', *(av.cend() - 1));
+  char i = 0;
+  for (auto& e : av) {
+    EXPECT_EQ(arr + i, &e);
+    e = 's' + i;
+    ++i;
+  }
+  i = 0;
+  for (auto& e : ArrayView<const char>(av)) {
+    EXPECT_EQ(arr + i, &e);
+    // e = 'q' + i;  // Compile error, because e is a const char&.
+    ++i;
+  }
+}
+
+}  // namespace rtc