blob: 3f98f9f41cbd4e9ad24558fc85bea838488abfd7 [file] [log] [blame]
henrike@webrtc.orgf0488722014-05-13 18:00:261/*
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
Steve Anton10542f22019-01-11 17:11:0011#include "rtc_base/byte_buffer.h"
Yves Gerey3e707812018-11-28 15:47:4912
13#include <string.h>
14
Per Kcf2e08b2023-11-17 09:05:3615#include <cstdint>
16
Mirko Bonadei92ea95e2017-09-15 04:47:3117#include "rtc_base/arraysize.h"
Steve Anton10542f22019-01-11 17:11:0018#include "rtc_base/byte_order.h"
Harald Alvestrand776fe6d2023-12-11 21:38:5119#include "test/gmock.h"
Yves Gerey3e707812018-11-28 15:47:4920#include "test/gtest.h"
henrike@webrtc.orgf0488722014-05-13 18:00:2621
22namespace rtc {
23
Harald Alvestrand776fe6d2023-12-11 21:38:5124using ::testing::ElementsAre;
Sergio Garcia Murillo37784ef2024-10-02 20:29:4525using ::testing::ElementsAreArray;
Harald Alvestrand776fe6d2023-12-11 21:38:5126
27TEST(ByteBufferTest, WriterAccessors) {
28 // To be changed into ByteBufferWriter when base type is converted.
29 ByteBufferWriterT<BufferT<uint8_t>> buffer;
30 buffer.WriteString("abc");
31 EXPECT_EQ(buffer.Length(), 3U);
32 EXPECT_THAT(buffer.DataView(), ElementsAre('a', 'b', 'c'));
33 EXPECT_EQ(absl::string_view("abc"), buffer.DataAsStringView());
34
35 buffer.WriteUInt8(0);
36 EXPECT_STREQ(buffer.DataAsCharPointer(), "abc");
37 EXPECT_STREQ(reinterpret_cast<const char*>(buffer.Data()), "abc");
38}
39
henrike@webrtc.orgf0488722014-05-13 18:00:2640TEST(ByteBufferTest, TestByteOrder) {
Peter Boström0c4e06b2015-10-07 10:23:2141 uint16_t n16 = 1;
42 uint32_t n32 = 1;
43 uint64_t n64 = 1;
henrike@webrtc.orgf0488722014-05-13 18:00:2644
45 EXPECT_EQ(n16, NetworkToHost16(HostToNetwork16(n16)));
46 EXPECT_EQ(n32, NetworkToHost32(HostToNetwork32(n32)));
47 EXPECT_EQ(n64, NetworkToHost64(HostToNetwork64(n64)));
48
49 if (IsHostBigEndian()) {
50 // The host is the network (big) endian.
51 EXPECT_EQ(n16, HostToNetwork16(n16));
52 EXPECT_EQ(n32, HostToNetwork32(n32));
53 EXPECT_EQ(n64, HostToNetwork64(n64));
54
55 // GetBE converts big endian to little endian here.
56 EXPECT_EQ(n16 >> 8, GetBE16(&n16));
57 EXPECT_EQ(n32 >> 24, GetBE32(&n32));
58 EXPECT_EQ(n64 >> 56, GetBE64(&n64));
59 } else {
60 // The host is little endian.
61 EXPECT_NE(n16, HostToNetwork16(n16));
62 EXPECT_NE(n32, HostToNetwork32(n32));
63 EXPECT_NE(n64, HostToNetwork64(n64));
64
65 // GetBE converts little endian to big endian here.
66 EXPECT_EQ(GetBE16(&n16), HostToNetwork16(n16));
67 EXPECT_EQ(GetBE32(&n32), HostToNetwork32(n32));
68 EXPECT_EQ(GetBE64(&n64), HostToNetwork64(n64));
69
70 // GetBE converts little endian to big endian here.
71 EXPECT_EQ(n16 << 8, GetBE16(&n16));
72 EXPECT_EQ(n32 << 24, GetBE32(&n32));
73 EXPECT_EQ(n64 << 56, GetBE64(&n64));
74 }
75}
76
77TEST(ByteBufferTest, TestBufferLength) {
jbauchf1f87202016-03-30 13:43:3778 ByteBufferWriter buffer;
henrike@webrtc.orgf0488722014-05-13 18:00:2679 size_t size = 0;
80 EXPECT_EQ(size, buffer.Length());
81
82 buffer.WriteUInt8(1);
83 ++size;
84 EXPECT_EQ(size, buffer.Length());
85
86 buffer.WriteUInt16(1);
87 size += 2;
88 EXPECT_EQ(size, buffer.Length());
89
90 buffer.WriteUInt24(1);
91 size += 3;
92 EXPECT_EQ(size, buffer.Length());
93
94 buffer.WriteUInt32(1);
95 size += 4;
96 EXPECT_EQ(size, buffer.Length());
97
98 buffer.WriteUInt64(1);
99 size += 8;
100 EXPECT_EQ(size, buffer.Length());
henrike@webrtc.orgf0488722014-05-13 18:00:26101}
102
103TEST(ByteBufferTest, TestReadWriteBuffer) {
Danil Chapovalov7b46e172019-11-14 16:40:23104 ByteBufferWriter buffer;
Harald Alvestrand572502c2023-11-22 10:19:06105 ByteBufferReader read_buf(rtc::ArrayView<const uint8_t>(nullptr, 0));
Danil Chapovalov7b46e172019-11-14 16:40:23106 uint8_t ru8;
107 EXPECT_FALSE(read_buf.ReadUInt8(&ru8));
henrike@webrtc.orgf0488722014-05-13 18:00:26108
Danil Chapovalov7b46e172019-11-14 16:40:23109 // Write and read uint8_t.
110 uint8_t wu8 = 1;
111 buffer.WriteUInt8(wu8);
Harald Alvestrand572502c2023-11-22 10:19:06112 ByteBufferReader read_buf1(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23113 EXPECT_TRUE(read_buf1.ReadUInt8(&ru8));
114 EXPECT_EQ(wu8, ru8);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45115 EXPECT_EQ(read_buf1.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23116 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26117
Danil Chapovalov7b46e172019-11-14 16:40:23118 // Write and read uint16_t.
119 uint16_t wu16 = (1 << 8) + 1;
120 buffer.WriteUInt16(wu16);
Harald Alvestrand572502c2023-11-22 10:19:06121 ByteBufferReader read_buf2(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23122 uint16_t ru16;
123 EXPECT_TRUE(read_buf2.ReadUInt16(&ru16));
124 EXPECT_EQ(wu16, ru16);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45125 EXPECT_EQ(read_buf2.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23126 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26127
Danil Chapovalov7b46e172019-11-14 16:40:23128 // Write and read uint24.
129 uint32_t wu24 = (3 << 16) + (2 << 8) + 1;
130 buffer.WriteUInt24(wu24);
Harald Alvestrand572502c2023-11-22 10:19:06131 ByteBufferReader read_buf3(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23132 uint32_t ru24;
133 EXPECT_TRUE(read_buf3.ReadUInt24(&ru24));
134 EXPECT_EQ(wu24, ru24);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45135 EXPECT_EQ(read_buf3.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23136 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26137
Danil Chapovalov7b46e172019-11-14 16:40:23138 // Write and read uint32_t.
139 uint32_t wu32 = (4 << 24) + (3 << 16) + (2 << 8) + 1;
140 buffer.WriteUInt32(wu32);
Harald Alvestrand572502c2023-11-22 10:19:06141 ByteBufferReader read_buf4(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23142 uint32_t ru32;
143 EXPECT_TRUE(read_buf4.ReadUInt32(&ru32));
144 EXPECT_EQ(wu32, ru32);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45145 EXPECT_EQ(read_buf3.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23146 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26147
Danil Chapovalov7b46e172019-11-14 16:40:23148 // Write and read uint64_t.
149 uint32_t another32 = (8 << 24) + (7 << 16) + (6 << 8) + 5;
150 uint64_t wu64 = (static_cast<uint64_t>(another32) << 32) + wu32;
151 buffer.WriteUInt64(wu64);
Harald Alvestrand572502c2023-11-22 10:19:06152 ByteBufferReader read_buf5(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23153 uint64_t ru64;
154 EXPECT_TRUE(read_buf5.ReadUInt64(&ru64));
155 EXPECT_EQ(wu64, ru64);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45156 EXPECT_EQ(read_buf5.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23157 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26158
Danil Chapovalov7b46e172019-11-14 16:40:23159 // Write and read string.
160 std::string write_string("hello");
161 buffer.WriteString(write_string);
Harald Alvestrand572502c2023-11-22 10:19:06162 ByteBufferReader read_buf6(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23163 std::string read_string;
164 EXPECT_TRUE(read_buf6.ReadString(&read_string, write_string.size()));
165 EXPECT_EQ(write_string, read_string);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45166 EXPECT_EQ(read_buf6.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23167 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26168
Danil Chapovalov7b46e172019-11-14 16:40:23169 // Write and read bytes
Sergio Garcia Murillo37784ef2024-10-02 20:29:45170 uint8_t write_bytes[] = {3, 2, 1};
Danil Chapovalov7b46e172019-11-14 16:40:23171 buffer.WriteBytes(write_bytes, 3);
Harald Alvestrand572502c2023-11-22 10:19:06172 ByteBufferReader read_buf7(buffer);
173 uint8_t read_bytes[3];
174 EXPECT_TRUE(read_buf7.ReadBytes(read_bytes));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45175 EXPECT_THAT(read_bytes, ElementsAreArray(write_bytes));
176 EXPECT_EQ(read_buf7.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23177 buffer.Clear();
178
179 // Write and read reserved buffer space
Harald Alvestrandf0ddae82023-12-12 12:05:20180 uint8_t* write_dst = buffer.ReserveWriteBuffer(3);
Danil Chapovalov7b46e172019-11-14 16:40:23181 memcpy(write_dst, write_bytes, 3);
Harald Alvestrand572502c2023-11-22 10:19:06182 ByteBufferReader read_buf8(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23183 memset(read_bytes, 0, 3);
Harald Alvestrand572502c2023-11-22 10:19:06184 EXPECT_TRUE(read_buf8.ReadBytes(read_bytes));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45185 EXPECT_THAT(read_bytes, ElementsAreArray(write_dst, 3));
186 EXPECT_EQ(read_buf8.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23187 buffer.Clear();
188
189 // Write and read in order.
190 buffer.WriteUInt8(wu8);
191 buffer.WriteUInt16(wu16);
192 buffer.WriteUInt24(wu24);
193 buffer.WriteUInt32(wu32);
194 buffer.WriteUInt64(wu64);
Harald Alvestrand572502c2023-11-22 10:19:06195 ByteBufferReader read_buf9(buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23196 EXPECT_TRUE(read_buf9.ReadUInt8(&ru8));
197 EXPECT_EQ(wu8, ru8);
198 EXPECT_TRUE(read_buf9.ReadUInt16(&ru16));
199 EXPECT_EQ(wu16, ru16);
200 EXPECT_TRUE(read_buf9.ReadUInt24(&ru24));
201 EXPECT_EQ(wu24, ru24);
202 EXPECT_TRUE(read_buf9.ReadUInt32(&ru32));
203 EXPECT_EQ(wu32, ru32);
204 EXPECT_TRUE(read_buf9.ReadUInt64(&ru64));
205 EXPECT_EQ(wu64, ru64);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45206 EXPECT_EQ(read_buf9.Length(), 0U);
Danil Chapovalov7b46e172019-11-14 16:40:23207 buffer.Clear();
henrike@webrtc.orgf0488722014-05-13 18:00:26208}
209
Sergio Garcia Murillo37784ef2024-10-02 20:29:45210TEST(ByteBufferTest, TestWriteCArray) {
211 // Write and read data
212 const uint8_t write_data[3] = {3, 2, 1};
213 ByteBufferWriter buffer;
214 buffer.Write(write_data);
215 EXPECT_EQ(buffer.Length(), 3U);
216 ByteBufferReader read_buf10(buffer);
217 uint8_t read_bytes[3] = {};
218 EXPECT_TRUE(read_buf10.ReadBytes(read_bytes));
219 EXPECT_THAT(read_bytes, ElementsAreArray(write_data));
220 EXPECT_EQ(read_buf10.Length(), 0U);
221}
222
223TEST(ByteBufferTest, TestWriteBuffer) {
224 const uint8_t write_data[3] = {3, 2, 1};
225 // Write and read buffer
226 Buffer write_buffer(write_data);
227 ByteBufferWriter buffer;
228 buffer.Write(write_buffer);
229 ByteBufferReader read_buf11(buffer);
230 uint8_t read_bytes[3] = {};
231 EXPECT_TRUE(read_buf11.ReadBytes(read_bytes));
232 EXPECT_THAT(read_bytes, ElementsAreArray(write_buffer));
233 EXPECT_EQ(read_buf11.Length(), 0U);
234}
235
236TEST(ByteBufferTest, TestWriteArrayView) {
237 const uint8_t write_data[3] = {3, 2, 1};
238 // Write and read arrayview
239 ArrayView<const uint8_t> write_view(write_data);
240 ByteBufferWriter buffer;
241 buffer.Write(write_view);
242 ByteBufferReader read_buf12(buffer);
243 uint8_t read_bytes[3] = {};
244 EXPECT_TRUE(read_buf12.ReadBytes(read_bytes));
245 EXPECT_THAT(read_bytes, ElementsAreArray(write_view));
246 EXPECT_EQ(read_buf12.Length(), 0U);
247}
248
249TEST(ByteBufferTest, TestWriteConsume) {
250 ByteBufferWriter writer;
251 // Write and read uint8_t.
252 uint8_t wu8 = 1;
253 writer.WriteUInt8(wu8);
254 Buffer consumed = std::move(writer).Extract();
255 EXPECT_THAT(consumed, ElementsAre(wu8));
256}
257
Tommieb4a3142024-01-15 20:06:05258TEST(ByteBufferTest, TestReadStringView) {
259 const absl::string_view tests[] = {"hello", " ", "string_view"};
260 std::string buffer;
261 for (const auto& test : tests)
262 buffer += test;
263
264 rtc::ArrayView<const uint8_t> bytes(
265 reinterpret_cast<const uint8_t*>(&buffer[0]), buffer.size());
266
267 ByteBufferReader read_buf(bytes);
268 size_t consumed = 0;
269 for (const auto& test : tests) {
270 absl::string_view sv;
271 EXPECT_TRUE(read_buf.ReadStringView(&sv, test.length()));
272 EXPECT_EQ(sv.compare(test), 0);
Sergio Garcia Murillo37784ef2024-10-02 20:29:45273 // The returned string view should point directly into the original
274 // string.
Tommieb4a3142024-01-15 20:06:05275 EXPECT_EQ(&sv[0], &buffer[0 + consumed]);
276 consumed += sv.size();
277 }
278}
279
mikescarlett9a20fa62016-04-11 23:11:38280TEST(ByteBufferTest, TestReadWriteUVarint) {
Danil Chapovalov7b46e172019-11-14 16:40:23281 ByteBufferWriter write_buffer;
282 size_t size = 0;
283 EXPECT_EQ(size, write_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38284
Danil Chapovalov7b46e172019-11-14 16:40:23285 write_buffer.WriteUVarint(1u);
286 ++size;
287 EXPECT_EQ(size, write_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38288
Danil Chapovalov7b46e172019-11-14 16:40:23289 write_buffer.WriteUVarint(2u);
290 ++size;
291 EXPECT_EQ(size, write_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38292
Danil Chapovalov7b46e172019-11-14 16:40:23293 write_buffer.WriteUVarint(27u);
294 ++size;
295 EXPECT_EQ(size, write_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38296
Danil Chapovalov7b46e172019-11-14 16:40:23297 write_buffer.WriteUVarint(149u);
298 size += 2;
299 EXPECT_EQ(size, write_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38300
Danil Chapovalov7b46e172019-11-14 16:40:23301 write_buffer.WriteUVarint(68719476736u);
302 size += 6;
303 EXPECT_EQ(size, write_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38304
Harald Alvestrand572502c2023-11-22 10:19:06305 ByteBufferReader read_buffer(write_buffer);
Danil Chapovalov7b46e172019-11-14 16:40:23306 EXPECT_EQ(size, read_buffer.Length());
307 uint64_t val1, val2, val3, val4, val5;
mikescarlett9a20fa62016-04-11 23:11:38308
Danil Chapovalov7b46e172019-11-14 16:40:23309 ASSERT_TRUE(read_buffer.ReadUVarint(&val1));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45310 EXPECT_EQ(val1, 1U);
Danil Chapovalov7b46e172019-11-14 16:40:23311 --size;
312 EXPECT_EQ(size, read_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38313
Danil Chapovalov7b46e172019-11-14 16:40:23314 ASSERT_TRUE(read_buffer.ReadUVarint(&val2));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45315 EXPECT_EQ(val2, 2U);
Danil Chapovalov7b46e172019-11-14 16:40:23316 --size;
317 EXPECT_EQ(size, read_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38318
Danil Chapovalov7b46e172019-11-14 16:40:23319 ASSERT_TRUE(read_buffer.ReadUVarint(&val3));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45320 EXPECT_EQ(val3, 27U);
Danil Chapovalov7b46e172019-11-14 16:40:23321 --size;
322 EXPECT_EQ(size, read_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38323
Danil Chapovalov7b46e172019-11-14 16:40:23324 ASSERT_TRUE(read_buffer.ReadUVarint(&val4));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45325 EXPECT_EQ(val4, 149U);
Danil Chapovalov7b46e172019-11-14 16:40:23326 size -= 2;
327 EXPECT_EQ(size, read_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38328
Danil Chapovalov7b46e172019-11-14 16:40:23329 ASSERT_TRUE(read_buffer.ReadUVarint(&val5));
Sergio Garcia Murillo37784ef2024-10-02 20:29:45330 EXPECT_EQ(val5, 68719476736U);
Danil Chapovalov7b46e172019-11-14 16:40:23331 size -= 6;
332 EXPECT_EQ(size, read_buffer.Length());
mikescarlett9a20fa62016-04-11 23:11:38333}
334
Per Kcf2e08b2023-11-17 09:05:36335TEST(ByteBufferTest, ReadFromArrayView) {
336 const uint8_t buf[] = {'a', 'b', 'c'};
337 ArrayView<const uint8_t> view(buf, 3);
338
339 ByteBufferReader read_buffer(view);
340 uint8_t val;
341 EXPECT_TRUE(read_buffer.ReadUInt8(&val));
342 EXPECT_EQ(val, 'a');
343 EXPECT_TRUE(read_buffer.ReadUInt8(&val));
344 EXPECT_EQ(val, 'b');
345 EXPECT_TRUE(read_buffer.ReadUInt8(&val));
346 EXPECT_EQ(val, 'c');
347 EXPECT_FALSE(read_buffer.ReadUInt8(&val));
348}
349
Harald Alvestrandf0907c62023-11-20 09:20:23350TEST(ByteBufferTest, ReadToArrayView) {
351 const uint8_t buf[] = {'a', 'b', 'c'};
352 ArrayView<const uint8_t> stored_view(buf, 3);
353 ByteBufferReader read_buffer(stored_view);
354 uint8_t result[] = {'1', '2', '3'};
Harald Alvestrand572502c2023-11-22 10:19:06355 EXPECT_TRUE(read_buffer.ReadBytes(rtc::MakeArrayView(result, 2)));
Harald Alvestrandf0907c62023-11-20 09:20:23356 EXPECT_EQ(result[0], 'a');
357 EXPECT_EQ(result[1], 'b');
358 EXPECT_EQ(result[2], '3');
Harald Alvestrand572502c2023-11-22 10:19:06359 EXPECT_TRUE(read_buffer.ReadBytes(rtc::MakeArrayView(&result[2], 1)));
Harald Alvestrandf0907c62023-11-20 09:20:23360 EXPECT_EQ(result[2], 'c');
Harald Alvestrand572502c2023-11-22 10:19:06361 EXPECT_FALSE(read_buffer.ReadBytes(rtc::MakeArrayView(result, 1)));
Harald Alvestrandf0907c62023-11-20 09:20:23362}
363
henrike@webrtc.orgf0488722014-05-13 18:00:26364} // namespace rtc