OLD | NEW |
(Empty) | |
| 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 <algorithm> |
| 12 #include <string> |
| 13 #include <vector> |
| 14 |
| 15 #include "webrtc/base/array_view.h" |
| 16 #include "webrtc/base/buffer.h" |
| 17 #include "webrtc/base/checks.h" |
| 18 #include "webrtc/base/gunit.h" |
| 19 |
| 20 namespace rtc { |
| 21 |
| 22 namespace { |
| 23 template <typename T> |
| 24 void Call(ArrayView<T>) {} |
| 25 } // namespace |
| 26 |
| 27 TEST(ArrayViewTest, TestConstructFromPtrAndArray) { |
| 28 char arr[] = "Arrr!"; |
| 29 const char carr[] = "Carrr!"; |
| 30 Call<const char>(arr); |
| 31 Call<const char>(carr); |
| 32 Call<char>(arr); |
| 33 // Call<char>(carr); // Compile error, because can't drop const. |
| 34 // Call<int>(arr); // Compile error, because incompatible types. |
| 35 ArrayView<int*> x; |
| 36 EXPECT_EQ(0u, x.size()); |
| 37 EXPECT_EQ(nullptr, x.data()); |
| 38 ArrayView<char> y = arr; |
| 39 EXPECT_EQ(6u, y.size()); |
| 40 EXPECT_EQ(arr, y.data()); |
| 41 ArrayView<const char> z(arr + 1, 3); |
| 42 EXPECT_EQ(3u, z.size()); |
| 43 EXPECT_EQ(arr + 1, z.data()); |
| 44 ArrayView<const char> w(arr, 2); |
| 45 EXPECT_EQ(2u, w.size()); |
| 46 EXPECT_EQ(arr, w.data()); |
| 47 ArrayView<char> q(arr, 0); |
| 48 EXPECT_EQ(0u, q.size()); |
| 49 EXPECT_EQ(nullptr, q.data()); |
| 50 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 51 // DCHECK error (nullptr with nonzero size). |
| 52 EXPECT_DEATH(ArrayView<int>(static_cast<int*>(nullptr), 5), ""); |
| 53 #endif |
| 54 // These are compile errors, because incompatible types. |
| 55 // ArrayView<int> m = arr; |
| 56 // ArrayView<float> n(arr + 2, 2); |
| 57 } |
| 58 |
| 59 TEST(ArrayViewTest, TestCopyConstructor) { |
| 60 char arr[] = "Arrr!"; |
| 61 ArrayView<char> x = arr; |
| 62 EXPECT_EQ(6u, x.size()); |
| 63 EXPECT_EQ(arr, x.data()); |
| 64 ArrayView<char> y = x; // Copy non-const -> non-const. |
| 65 EXPECT_EQ(6u, y.size()); |
| 66 EXPECT_EQ(arr, y.data()); |
| 67 ArrayView<const char> z = x; // Copy non-const -> const. |
| 68 EXPECT_EQ(6u, z.size()); |
| 69 EXPECT_EQ(arr, z.data()); |
| 70 ArrayView<const char> w = z; // Copy const -> const. |
| 71 EXPECT_EQ(6u, w.size()); |
| 72 EXPECT_EQ(arr, w.data()); |
| 73 // ArrayView<char> v = z; // Compile error, because can't drop const. |
| 74 } |
| 75 |
| 76 TEST(ArrayViewTest, TestCopyAssignment) { |
| 77 char arr[] = "Arrr!"; |
| 78 ArrayView<char> x(arr); |
| 79 EXPECT_EQ(6u, x.size()); |
| 80 EXPECT_EQ(arr, x.data()); |
| 81 ArrayView<char> y; |
| 82 y = x; // Copy non-const -> non-const. |
| 83 EXPECT_EQ(6u, y.size()); |
| 84 EXPECT_EQ(arr, y.data()); |
| 85 ArrayView<const char> z; |
| 86 z = x; // Copy non-const -> const. |
| 87 EXPECT_EQ(6u, z.size()); |
| 88 EXPECT_EQ(arr, z.data()); |
| 89 ArrayView<const char> w; |
| 90 w = z; // Copy const -> const. |
| 91 EXPECT_EQ(6u, w.size()); |
| 92 EXPECT_EQ(arr, w.data()); |
| 93 // ArrayView<char> v; |
| 94 // v = z; // Compile error, because can't drop const. |
| 95 } |
| 96 |
| 97 TEST(ArrayViewTest, TestStdVector) { |
| 98 std::vector<int> v; |
| 99 v.push_back(3); |
| 100 v.push_back(11); |
| 101 Call<const int>(v); |
| 102 Call<int>(v); |
| 103 // Call<unsigned int>(v); // Compile error, because incompatible types. |
| 104 ArrayView<int> x = v; |
| 105 EXPECT_EQ(2u, x.size()); |
| 106 EXPECT_EQ(v.data(), x.data()); |
| 107 ArrayView<const int> y; |
| 108 y = v; |
| 109 EXPECT_EQ(2u, y.size()); |
| 110 EXPECT_EQ(v.data(), y.data()); |
| 111 // ArrayView<double> d = v; // Compile error, because incompatible types. |
| 112 const std::vector<int> cv; |
| 113 Call<const int>(cv); |
| 114 // Call<int>(cv); // Compile error, because can't drop const. |
| 115 ArrayView<const int> z = cv; |
| 116 EXPECT_EQ(0u, z.size()); |
| 117 EXPECT_EQ(nullptr, z.data()); |
| 118 // ArrayView<int> w = cv; // Compile error, because can't drop const. |
| 119 } |
| 120 |
| 121 TEST(ArrayViewTest, TestRtcBuffer) { |
| 122 rtc::Buffer b = "so buffer"; |
| 123 Call<const uint8_t>(b); |
| 124 Call<uint8_t>(b); |
| 125 // Call<int8_t>(b); // Compile error, because incompatible types. |
| 126 ArrayView<uint8_t> x = b; |
| 127 EXPECT_EQ(10u, x.size()); |
| 128 EXPECT_EQ(b.data(), x.data()); |
| 129 ArrayView<const uint8_t> y; |
| 130 y = b; |
| 131 EXPECT_EQ(10u, y.size()); |
| 132 EXPECT_EQ(b.data(), y.data()); |
| 133 // ArrayView<char> d = b; // Compile error, because incompatible types. |
| 134 const rtc::Buffer cb = "very const"; |
| 135 Call<const uint8_t>(cb); |
| 136 // Call<uint8_t>(cb); // Compile error, because can't drop const. |
| 137 ArrayView<const uint8_t> z = cb; |
| 138 EXPECT_EQ(11u, z.size()); |
| 139 EXPECT_EQ(cb.data(), z.data()); |
| 140 // ArrayView<uint8_t> w = cb; // Compile error, because can't drop const. |
| 141 } |
| 142 |
| 143 TEST(ArrayViewTest, TestSwap) { |
| 144 const char arr[] = "Arrr!"; |
| 145 const char aye[] = "Aye, Cap'n!"; |
| 146 ArrayView<const char> x(arr); |
| 147 EXPECT_EQ(6u, x.size()); |
| 148 EXPECT_EQ(arr, x.data()); |
| 149 ArrayView<const char> y(aye); |
| 150 EXPECT_EQ(12u, y.size()); |
| 151 EXPECT_EQ(aye, y.data()); |
| 152 using std::swap; |
| 153 swap(x, y); |
| 154 EXPECT_EQ(12u, x.size()); |
| 155 EXPECT_EQ(aye, x.data()); |
| 156 EXPECT_EQ(6u, y.size()); |
| 157 EXPECT_EQ(arr, y.data()); |
| 158 // ArrayView<char> z; |
| 159 // swap(x, z); // Compile error, because can't drop const. |
| 160 } |
| 161 |
| 162 TEST(ArrayViewTest, TestIndexing) { |
| 163 char arr[] = "abcdefg"; |
| 164 ArrayView<char> x(arr); |
| 165 const ArrayView<char> y(arr); |
| 166 ArrayView<const char> z(arr); |
| 167 EXPECT_EQ(8u, x.size()); |
| 168 EXPECT_EQ(8u, y.size()); |
| 169 EXPECT_EQ(8u, z.size()); |
| 170 EXPECT_EQ('b', x[1]); |
| 171 EXPECT_EQ('c', y[2]); |
| 172 EXPECT_EQ('d', z[3]); |
| 173 x[3] = 'X'; |
| 174 y[2] = 'Y'; |
| 175 // z[1] = 'Z'; // Compile error, because z's element type is const char. |
| 176 EXPECT_EQ('b', x[1]); |
| 177 EXPECT_EQ('Y', y[2]); |
| 178 EXPECT_EQ('X', z[3]); |
| 179 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 180 EXPECT_DEATH(z[8], ""); // DCHECK error (index out of bounds). |
| 181 #endif |
| 182 } |
| 183 |
| 184 TEST(ArrayViewTest, TestIterationEmpty) { |
| 185 ArrayView<std::vector<std::vector<std::vector<std::string>>>> av; |
| 186 EXPECT_FALSE(av.begin()); |
| 187 EXPECT_FALSE(av.cbegin()); |
| 188 EXPECT_FALSE(av.end()); |
| 189 EXPECT_FALSE(av.cend()); |
| 190 for (auto& e : av) { |
| 191 EXPECT_TRUE(false); |
| 192 EXPECT_EQ(42u, e.size()); // Dummy use of e to prevent unused var warning. |
| 193 } |
| 194 } |
| 195 |
| 196 TEST(ArrayViewTest, TestIteration) { |
| 197 char arr[] = "Arrr!"; |
| 198 ArrayView<char> av(arr); |
| 199 EXPECT_EQ('A', *av.begin()); |
| 200 EXPECT_EQ('A', *av.cbegin()); |
| 201 EXPECT_EQ('\0', *(av.end() - 1)); |
| 202 EXPECT_EQ('\0', *(av.cend() - 1)); |
| 203 char i = 0; |
| 204 for (auto& e : av) { |
| 205 EXPECT_EQ(arr + i, &e); |
| 206 e = 's' + i; |
| 207 ++i; |
| 208 } |
| 209 i = 0; |
| 210 for (auto& e : ArrayView<const char>(av)) { |
| 211 EXPECT_EQ(arr + i, &e); |
| 212 // e = 'q' + i; // Compile error, because e is a const char&. |
| 213 ++i; |
| 214 } |
| 215 } |
| 216 |
| 217 } // namespace rtc |
OLD | NEW |