henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2004 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 "webrtc/base/buffer.h" |
| 12 | #include "webrtc/base/gunit.h" |
| 13 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 14 | #include <algorithm> // std::swap (pre-C++11) |
| 15 | #include <utility> // std::swap (C++11 and later) |
| 16 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 17 | namespace rtc { |
| 18 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 19 | namespace { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 20 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 21 | // clang-format off |
| 22 | const uint8_t kTestData[] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, |
| 23 | 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf}; |
| 24 | // clang-format on |
| 25 | |
| 26 | void TestBuf(const Buffer& b1, size_t size, size_t capacity) { |
| 27 | EXPECT_EQ(b1.size(), size); |
| 28 | EXPECT_EQ(b1.capacity(), capacity); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 29 | } |
| 30 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 31 | } // namespace |
| 32 | |
| 33 | TEST(BufferTest, TestConstructEmpty) { |
| 34 | TestBuf(Buffer(), 0, 0); |
| 35 | TestBuf(Buffer(Buffer()), 0, 0); |
| 36 | TestBuf(Buffer(0), 0, 0); |
| 37 | |
| 38 | // We can't use a literal 0 for the first argument, because C++ will allow |
| 39 | // that to be considered a null pointer, which makes the call ambiguous. |
| 40 | TestBuf(Buffer(0 + 0, 10), 0, 10); |
| 41 | |
| 42 | TestBuf(Buffer(kTestData, 0), 0, 0); |
| 43 | TestBuf(Buffer(kTestData, 0, 20), 0, 20); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 44 | } |
| 45 | |
| 46 | TEST(BufferTest, TestConstructData) { |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 47 | Buffer buf(kTestData, 7); |
| 48 | EXPECT_EQ(buf.size(), 7u); |
| 49 | EXPECT_EQ(buf.capacity(), 7u); |
| 50 | EXPECT_EQ(0, memcmp(buf.data(), kTestData, 7)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | TEST(BufferTest, TestConstructDataWithCapacity) { |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 54 | Buffer buf(kTestData, 7, 14); |
| 55 | EXPECT_EQ(buf.size(), 7u); |
| 56 | EXPECT_EQ(buf.capacity(), 14u); |
| 57 | EXPECT_EQ(0, memcmp(buf.data(), kTestData, 7)); |
| 58 | } |
| 59 | |
| 60 | TEST(BufferTest, TestConstructArray) { |
| 61 | Buffer buf(kTestData); |
| 62 | EXPECT_EQ(buf.size(), 16u); |
| 63 | EXPECT_EQ(buf.capacity(), 16u); |
| 64 | EXPECT_EQ(0, memcmp(buf.data(), kTestData, 16)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | TEST(BufferTest, TestConstructCopy) { |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 68 | Buffer buf1(kTestData), buf2(buf1); |
| 69 | EXPECT_EQ(buf2.size(), 16u); |
| 70 | EXPECT_EQ(buf2.capacity(), 16u); |
| 71 | EXPECT_EQ(0, memcmp(buf2.data(), kTestData, 16)); |
| 72 | EXPECT_NE(buf1.data(), buf2.data()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 73 | EXPECT_EQ(buf1, buf2); |
| 74 | } |
| 75 | |
| 76 | TEST(BufferTest, TestAssign) { |
| 77 | Buffer buf1, buf2(kTestData, sizeof(kTestData), 256); |
| 78 | EXPECT_NE(buf1, buf2); |
| 79 | buf1 = buf2; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 80 | EXPECT_EQ(buf1, buf2); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 81 | EXPECT_NE(buf1.data(), buf2.data()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | TEST(BufferTest, TestSetData) { |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 85 | Buffer buf(kTestData + 4, 7); |
| 86 | buf.SetData(kTestData, 9); |
| 87 | EXPECT_EQ(buf.size(), 9u); |
| 88 | EXPECT_EQ(buf.capacity(), 9u); |
| 89 | EXPECT_EQ(0, memcmp(buf.data(), kTestData, 9)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | TEST(BufferTest, TestAppendData) { |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 93 | Buffer buf(kTestData + 4, 3); |
| 94 | buf.AppendData(kTestData + 10, 2); |
| 95 | const int8_t exp[] = {0x4, 0x5, 0x6, 0xa, 0xb}; |
| 96 | EXPECT_EQ(buf, Buffer(exp)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 97 | } |
| 98 | |
kwiberg@webrtc.org | eebcab5 | 2015-03-24 09:19:06 +0000 | [diff] [blame] | 99 | TEST(BufferTest, TestSetSizeSmaller) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 100 | Buffer buf; |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 101 | buf.SetData(kTestData, 15); |
| 102 | buf.SetSize(10); |
| 103 | EXPECT_EQ(buf.size(), 10u); |
| 104 | EXPECT_EQ(buf.capacity(), 15u); // Hasn't shrunk. |
| 105 | EXPECT_EQ(buf, Buffer(kTestData, 10)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 106 | } |
| 107 | |
kwiberg@webrtc.org | eebcab5 | 2015-03-24 09:19:06 +0000 | [diff] [blame] | 108 | TEST(BufferTest, TestSetSizeLarger) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 109 | Buffer buf; |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 110 | buf.SetData(kTestData, 15); |
| 111 | EXPECT_EQ(buf.size(), 15u); |
| 112 | EXPECT_EQ(buf.capacity(), 15u); |
| 113 | buf.SetSize(20); |
| 114 | EXPECT_EQ(buf.size(), 20u); |
| 115 | EXPECT_EQ(buf.capacity(), 20u); // Has grown. |
| 116 | EXPECT_EQ(0, memcmp(buf.data(), kTestData, 15)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 117 | } |
| 118 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 119 | TEST(BufferTest, TestEnsureCapacitySmaller) { |
| 120 | Buffer buf(kTestData); |
| 121 | const char* data = buf.data<char>(); |
| 122 | buf.EnsureCapacity(4); |
| 123 | EXPECT_EQ(buf.capacity(), 16u); // Hasn't shrunk. |
| 124 | EXPECT_EQ(buf.data<char>(), data); // No reallocation. |
| 125 | EXPECT_EQ(buf, Buffer(kTestData)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 126 | } |
| 127 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 128 | TEST(BufferTest, TestEnsureCapacityLarger) { |
| 129 | Buffer buf(kTestData, 5); |
| 130 | buf.EnsureCapacity(10); |
| 131 | const int8_t* data = buf.data<int8_t>(); |
| 132 | EXPECT_EQ(buf.capacity(), 10u); |
| 133 | buf.AppendData(kTestData + 5, 5); |
| 134 | EXPECT_EQ(buf.data<int8_t>(), data); // No reallocation. |
| 135 | EXPECT_EQ(buf, Buffer(kTestData, 10)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 136 | } |
| 137 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 138 | TEST(BufferTest, TestMoveConstruct) { |
| 139 | Buffer buf1(kTestData, 3, 40); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 140 | const uint8_t* data = buf1.data(); |
kwiberg | 36220ae | 2016-01-12 07:24:19 -0800 | [diff] [blame] | 141 | Buffer buf2(buf1.DEPRECATED_Pass()); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 142 | EXPECT_EQ(buf2.size(), 3u); |
| 143 | EXPECT_EQ(buf2.capacity(), 40u); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 144 | EXPECT_EQ(buf2.data(), data); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 145 | buf1.Clear(); |
| 146 | EXPECT_EQ(buf1.size(), 0u); |
| 147 | EXPECT_EQ(buf1.capacity(), 0u); |
| 148 | EXPECT_EQ(buf1.data(), nullptr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 149 | } |
| 150 | |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 151 | TEST(BufferTest, TestMoveAssign) { |
| 152 | Buffer buf1(kTestData, 3, 40); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 153 | const uint8_t* data = buf1.data(); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 154 | Buffer buf2(kTestData); |
kwiberg | 36220ae | 2016-01-12 07:24:19 -0800 | [diff] [blame] | 155 | buf2 = buf1.DEPRECATED_Pass(); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 156 | EXPECT_EQ(buf2.size(), 3u); |
| 157 | EXPECT_EQ(buf2.capacity(), 40u); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 158 | EXPECT_EQ(buf2.data(), data); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 159 | buf1.Clear(); |
| 160 | EXPECT_EQ(buf1.size(), 0u); |
| 161 | EXPECT_EQ(buf1.capacity(), 0u); |
| 162 | EXPECT_EQ(buf1.data(), nullptr); |
| 163 | } |
| 164 | |
| 165 | TEST(BufferTest, TestSwap) { |
| 166 | Buffer buf1(kTestData, 3); |
| 167 | Buffer buf2(kTestData, 6, 40); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 168 | uint8_t* data1 = buf1.data(); |
| 169 | uint8_t* data2 = buf2.data(); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 170 | using std::swap; |
| 171 | swap(buf1, buf2); |
| 172 | EXPECT_EQ(buf1.size(), 6u); |
| 173 | EXPECT_EQ(buf1.capacity(), 40u); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 174 | EXPECT_EQ(buf1.data(), data2); |
Karl Wiberg | 9478437 | 2015-04-20 14:03:07 +0200 | [diff] [blame] | 175 | EXPECT_EQ(buf2.size(), 3u); |
| 176 | EXPECT_EQ(buf2.capacity(), 3u); |
Karl Wiberg | c56ac1e | 2015-05-04 14:54:55 +0200 | [diff] [blame] | 177 | EXPECT_EQ(buf2.data(), data1); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 178 | } |
| 179 | |
ossu | 728012e | 2016-02-19 02:38:32 -0800 | [diff] [blame] | 180 | TEST(BufferTest, TestClear) { |
| 181 | Buffer buf; |
| 182 | buf.SetData(kTestData, 15); |
| 183 | EXPECT_EQ(buf.size(), 15u); |
| 184 | EXPECT_EQ(buf.capacity(), 15u); |
| 185 | const char *data = buf.data<char>(); |
| 186 | buf.Clear(); |
| 187 | EXPECT_EQ(buf.size(), 0u); |
| 188 | EXPECT_EQ(buf.capacity(), 15u); // Hasn't shrunk. |
| 189 | EXPECT_EQ(buf.data<char>(), data); // No reallocation. |
| 190 | } |
| 191 | |
ossu | b01c781 | 2016-02-24 01:05:56 -0800 | [diff] [blame] | 192 | TEST(BufferTest, TestLambdaSetAppend) { |
| 193 | auto setter = [] (rtc::ArrayView<uint8_t> av) { |
| 194 | for (int i = 0; i != 15; ++i) |
| 195 | av[i] = kTestData[i]; |
| 196 | return 15; |
| 197 | }; |
| 198 | |
| 199 | Buffer buf1; |
| 200 | buf1.SetData(kTestData, 15); |
| 201 | buf1.AppendData(kTestData, 15); |
| 202 | |
| 203 | Buffer buf2; |
| 204 | EXPECT_EQ(buf2.SetData(15, setter), 15u); |
| 205 | EXPECT_EQ(buf2.AppendData(15, setter), 15u); |
| 206 | EXPECT_EQ(buf1, buf2); |
| 207 | EXPECT_EQ(buf1.capacity(), buf2.capacity()); |
| 208 | } |
| 209 | |
| 210 | TEST(BufferTest, TestLambdaSetAppendSigned) { |
| 211 | auto setter = [] (rtc::ArrayView<int8_t> av) { |
| 212 | for (int i = 0; i != 15; ++i) |
| 213 | av[i] = kTestData[i]; |
| 214 | return 15; |
| 215 | }; |
| 216 | |
| 217 | Buffer buf1; |
| 218 | buf1.SetData(kTestData, 15); |
| 219 | buf1.AppendData(kTestData, 15); |
| 220 | |
| 221 | Buffer buf2; |
| 222 | EXPECT_EQ(buf2.SetData<int8_t>(15, setter), 15u); |
| 223 | EXPECT_EQ(buf2.AppendData<int8_t>(15, setter), 15u); |
| 224 | EXPECT_EQ(buf1, buf2); |
| 225 | EXPECT_EQ(buf1.capacity(), buf2.capacity()); |
| 226 | } |
| 227 | |
| 228 | TEST(BufferTest, TestLambdaAppendEmpty) { |
| 229 | auto setter = [] (rtc::ArrayView<uint8_t> av) { |
| 230 | for (int i = 0; i != 15; ++i) |
| 231 | av[i] = kTestData[i]; |
| 232 | return 15; |
| 233 | }; |
| 234 | |
| 235 | Buffer buf1; |
| 236 | buf1.SetData(kTestData, 15); |
| 237 | |
| 238 | Buffer buf2; |
| 239 | EXPECT_EQ(buf2.AppendData(15, setter), 15u); |
| 240 | EXPECT_EQ(buf1, buf2); |
| 241 | EXPECT_EQ(buf1.capacity(), buf2.capacity()); |
| 242 | } |
| 243 | |
| 244 | TEST(BufferTest, TestLambdaAppendPartial) { |
| 245 | auto setter = [] (rtc::ArrayView<uint8_t> av) { |
| 246 | for (int i = 0; i != 7; ++i) |
| 247 | av[i] = kTestData[i]; |
| 248 | return 7; |
| 249 | }; |
| 250 | |
| 251 | Buffer buf; |
| 252 | EXPECT_EQ(buf.AppendData(15, setter), 7u); |
| 253 | EXPECT_EQ(buf.size(), 7u); // Size is exactly what we wrote. |
| 254 | EXPECT_GE(buf.capacity(), 7u); // Capacity is valid. |
| 255 | EXPECT_NE(buf.data<char>(), nullptr); // Data is actually stored. |
| 256 | } |
| 257 | |
| 258 | TEST(BufferTest, TestMutableLambdaSetAppend) { |
| 259 | uint8_t magic_number = 17; |
| 260 | auto setter = [magic_number] (rtc::ArrayView<uint8_t> av) mutable { |
| 261 | for (int i = 0; i != 15; ++i) { |
| 262 | av[i] = magic_number; |
| 263 | ++magic_number; |
| 264 | } |
| 265 | return 15; |
| 266 | }; |
| 267 | |
| 268 | EXPECT_EQ(magic_number, 17); |
| 269 | |
| 270 | Buffer buf; |
| 271 | EXPECT_EQ(buf.SetData(15, setter), 15u); |
| 272 | EXPECT_EQ(buf.AppendData(15, setter), 15u); |
| 273 | EXPECT_EQ(buf.size(), 30u); // Size is exactly what we wrote. |
| 274 | EXPECT_GE(buf.capacity(), 30u); // Capacity is valid. |
| 275 | EXPECT_NE(buf.data<char>(), nullptr); // Data is actually stored. |
| 276 | |
| 277 | for (uint8_t i = 0; i != buf.size(); ++i) { |
| 278 | EXPECT_EQ(buf.data()[i], magic_number + i); |
| 279 | } |
| 280 | } |
| 281 | |
ossu | b9338ac | 2016-02-29 09:36:37 -0800 | [diff] [blame^] | 282 | TEST(BufferTest, TestBracketRead) { |
| 283 | Buffer buf(kTestData, 7); |
| 284 | EXPECT_EQ(buf.size(), 7u); |
| 285 | EXPECT_EQ(buf.capacity(), 7u); |
| 286 | EXPECT_NE(buf.data(), nullptr); |
| 287 | |
| 288 | for (size_t i = 0; i != 7u; ++i) { |
| 289 | EXPECT_EQ(buf[i], kTestData[i]); |
| 290 | } |
| 291 | } |
| 292 | |
| 293 | TEST(BufferTest, TestBracketReadConst) { |
| 294 | Buffer buf(kTestData, 7); |
| 295 | EXPECT_EQ(buf.size(), 7u); |
| 296 | EXPECT_EQ(buf.capacity(), 7u); |
| 297 | EXPECT_NE(buf.data(), nullptr); |
| 298 | |
| 299 | const Buffer& cbuf = buf; |
| 300 | |
| 301 | for (size_t i = 0; i != 7u; ++i) { |
| 302 | EXPECT_EQ(cbuf[i], kTestData[i]); |
| 303 | } |
| 304 | } |
| 305 | |
| 306 | TEST(BufferTest, TestBracketWrite) { |
| 307 | Buffer buf(7); |
| 308 | EXPECT_EQ(buf.size(), 7u); |
| 309 | EXPECT_EQ(buf.capacity(), 7u); |
| 310 | EXPECT_NE(buf.data(), nullptr); |
| 311 | |
| 312 | for (size_t i = 0; i != 7u; ++i) { |
| 313 | buf[i] = kTestData[i]; |
| 314 | } |
| 315 | |
| 316 | for (size_t i = 0; i != 7u; ++i) { |
| 317 | EXPECT_EQ(buf[i], kTestData[i]); |
| 318 | } |
| 319 | } |
| 320 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 321 | } // namespace rtc |