234 lines
6.8 KiB
C++
234 lines
6.8 KiB
C++
/*
|
|
* 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;
|
|
}
|
|
}
|
|
|
|
TEST(ArrayViewTest, TestEmpty) {
|
|
EXPECT_TRUE(ArrayView<int>().empty());
|
|
const int a[] = {1, 2, 3};
|
|
EXPECT_FALSE(ArrayView<const int>(a).empty());
|
|
}
|
|
|
|
TEST(ArrayViewTest, TestCompare) {
|
|
int a[] = {1, 2, 3};
|
|
int b[] = {1, 2, 3};
|
|
EXPECT_EQ(ArrayView<int>(a), ArrayView<int>(a));
|
|
EXPECT_EQ(ArrayView<int>(), ArrayView<int>());
|
|
EXPECT_NE(ArrayView<int>(a), ArrayView<int>(b));
|
|
EXPECT_NE(ArrayView<int>(a), ArrayView<int>());
|
|
EXPECT_NE(ArrayView<int>(a), ArrayView<int>(a, 2));
|
|
}
|
|
|
|
} // namespace rtc
|