1 // Copyright 2020 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_bytes/byte_builder.h"
16
17 #include <array>
18 #include <cstddef>
19
20 #include "pw_unit_test/framework.h"
21
22 using std::byte;
23
24 template <typename... Args>
MakeBytes(Args...args)25 constexpr std::array<byte, sizeof...(Args)> MakeBytes(Args... args) noexcept {
26 return {static_cast<byte>(args)...};
27 }
28
29 namespace pw {
30 namespace {
31
TEST(ByteBuilder,EmptyBuffer_SizeAndMaxSizeAreCorrect)32 TEST(ByteBuilder, EmptyBuffer_SizeAndMaxSizeAreCorrect) {
33 ByteBuilder bb(ByteSpan{});
34
35 EXPECT_TRUE(bb.empty());
36 EXPECT_EQ(0u, bb.size());
37 EXPECT_EQ(0u, bb.max_size());
38 }
39
TEST(ByteBuilder,NonEmptyBufferOfSize0_SizeAndMaxSizeAreCorrect)40 TEST(ByteBuilder, NonEmptyBufferOfSize0_SizeAndMaxSizeAreCorrect) {
41 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
42 ByteBuilder bb(buffer);
43
44 EXPECT_TRUE(bb.empty());
45 EXPECT_EQ(0u, bb.size());
46 EXPECT_EQ(3u, bb.max_size());
47 }
48
TEST(ByteBuilder,Constructor_InsertsEmptyBuffer)49 TEST(ByteBuilder, Constructor_InsertsEmptyBuffer) {
50 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
51 ByteBuilder bb(buffer);
52
53 EXPECT_TRUE(bb.empty());
54 }
55
TEST(ByteBuilder,EmptyBuffer_Append)56 TEST(ByteBuilder, EmptyBuffer_Append) {
57 ByteBuilder bb(ByteSpan{});
58 EXPECT_TRUE(bb.empty());
59
60 constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05);
61
62 EXPECT_FALSE(bb.append(kBytesTestLiteral.data(), 2).ok());
63 EXPECT_EQ(0u, bb.size());
64 EXPECT_EQ(0u, bb.max_size());
65 }
66
TEST(ByteBuilder,NonEmptyBufferOfSize0_Append)67 TEST(ByteBuilder, NonEmptyBufferOfSize0_Append) {
68 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
69 ByteBuilder bb(buffer);
70 EXPECT_TRUE(bb.empty());
71
72 constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05);
73
74 EXPECT_TRUE(bb.append(kBytesTestLiteral.data(), 2).ok());
75 EXPECT_EQ(byte{0x04}, bb.data()[0]);
76 EXPECT_EQ(byte{0x05}, bb.data()[1]);
77 }
78
TEST(ByteBuilder,NonEmptyBufferOfSize0_Append_Partial_NotResourceExhausted)79 TEST(ByteBuilder, NonEmptyBufferOfSize0_Append_Partial_NotResourceExhausted) {
80 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
81 ByteBuilder bb(buffer);
82
83 EXPECT_TRUE(bb.empty());
84
85 constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05, 0x06, 0x07);
86
87 EXPECT_TRUE(bb.append(kBytesTestLiteral.data(), 3).ok());
88 EXPECT_EQ(byte{0x04}, bb.data()[0]);
89 EXPECT_EQ(byte{0x05}, bb.data()[1]);
90 EXPECT_EQ(byte{0x06}, bb.data()[2]);
91 }
92
TEST(ByteBuilder,NonEmptyBufferOfSize0_Append_Partial_ResourceExhausted)93 TEST(ByteBuilder, NonEmptyBufferOfSize0_Append_Partial_ResourceExhausted) {
94 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
95 ByteBuilder bb(buffer);
96
97 EXPECT_TRUE(bb.empty());
98
99 constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05, 0x06, 0x07);
100
101 EXPECT_FALSE(bb.append(kBytesTestLiteral.data(), 4).ok());
102 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
103 EXPECT_EQ(0u, bb.size());
104 }
105
TEST(ByteBuilder,Append_RepeatedBytes)106 TEST(ByteBuilder, Append_RepeatedBytes) {
107 ByteBuffer<8> bb;
108 EXPECT_TRUE(bb.empty());
109
110 EXPECT_TRUE(bb.append(7, byte{0x04}).ok());
111
112 for (size_t i = 0; i < 7; i++) {
113 EXPECT_EQ(byte{0x04}, bb.data()[i]);
114 }
115 }
116
TEST(ByteBuilder,Append_Bytes_Full)117 TEST(ByteBuilder, Append_Bytes_Full) {
118 ByteBuffer<8> bb;
119
120 EXPECT_EQ(8u, bb.max_size() - bb.size());
121
122 EXPECT_TRUE(bb.append(8, byte{0x04}).ok());
123
124 for (size_t i = 0; i < 8; i++) {
125 EXPECT_EQ(byte{0x04}, bb.data()[i]);
126 }
127 }
128
TEST(ByteBuilder,Append_Bytes_Exhausted)129 TEST(ByteBuilder, Append_Bytes_Exhausted) {
130 ByteBuffer<8> bb;
131
132 EXPECT_EQ(Status::ResourceExhausted(), bb.append(9, byte{0x04}).status());
133 EXPECT_EQ(0u, bb.size());
134 }
135
TEST(ByteBuilder,Append_Partial)136 TEST(ByteBuilder, Append_Partial) {
137 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
138 ByteBuffer<12> bb;
139
140 EXPECT_TRUE(bb.append(buffer.data(), 2).ok());
141 EXPECT_EQ(2u, bb.size());
142 EXPECT_EQ(byte{0x01}, bb.data()[0]);
143 EXPECT_EQ(byte{0x02}, bb.data()[1]);
144 }
145
TEST(ByteBuilder,EmptyBuffer_Resize_WritesNothing)146 TEST(ByteBuilder, EmptyBuffer_Resize_WritesNothing) {
147 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
148 ByteBuilder bb(buffer);
149
150 bb.resize(0);
151 EXPECT_TRUE(bb.ok());
152 }
153
TEST(ByteBuilder,EmptyBuffer_Resize_Larger_Fails)154 TEST(ByteBuilder, EmptyBuffer_Resize_Larger_Fails) {
155 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
156 ByteBuilder bb(buffer);
157
158 bb.resize(1);
159 EXPECT_EQ(Status::OutOfRange(), bb.append(9, byte{0x04}).status());
160 }
161
TEST(ByteBuilder,Resize_Smaller)162 TEST(ByteBuilder, Resize_Smaller) {
163 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
164 ByteBuffer<8> bb;
165
166 EXPECT_TRUE(bb.append(buffer).ok());
167
168 bb.resize(1);
169 EXPECT_TRUE(bb.ok());
170 EXPECT_EQ(1u, bb.size());
171 EXPECT_EQ(byte{0x01}, bb.data()[0]);
172 }
173
TEST(ByteBuilder,Resize_Clear)174 TEST(ByteBuilder, Resize_Clear) {
175 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
176 ByteBuffer<8> bb;
177
178 EXPECT_TRUE(bb.append(buffer).ok());
179
180 bb.resize(0);
181 EXPECT_TRUE(bb.ok());
182 EXPECT_EQ(0u, bb.size());
183 EXPECT_TRUE(bb.empty());
184 }
185
TEST(ByteBuilder,Resize_Larger_Fails)186 TEST(ByteBuilder, Resize_Larger_Fails) {
187 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
188 ByteBuffer<8> bb;
189
190 EXPECT_TRUE(bb.append(buffer).ok());
191
192 EXPECT_EQ(3u, bb.size());
193 bb.resize(5);
194 EXPECT_EQ(3u, bb.size());
195 EXPECT_EQ(bb.status(), Status::OutOfRange());
196 }
197
TEST(ByteBuilder,Status_StartsOk)198 TEST(ByteBuilder, Status_StartsOk) {
199 ByteBuffer<16> bb;
200 EXPECT_EQ(OkStatus(), bb.status());
201 }
202
TEST(ByteBuilder,Status_StatusUpdate)203 TEST(ByteBuilder, Status_StatusUpdate) {
204 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
205 ByteBuffer<2> bb;
206
207 EXPECT_FALSE(bb.append(buffer).ok());
208 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
209
210 bb.resize(4);
211 EXPECT_EQ(Status::OutOfRange(), bb.status());
212
213 EXPECT_FALSE(bb.append(buffer.data(), 0).ok());
214 EXPECT_EQ(Status::OutOfRange(), bb.status());
215 }
216
TEST(ByteBuilder,Status_ClearStatus_SetsStatusToOk)217 TEST(ByteBuilder, Status_ClearStatus_SetsStatusToOk) {
218 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
219 ByteBuffer<2> bb;
220
221 EXPECT_FALSE(bb.append(buffer).ok());
222 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
223
224 bb.clear_status();
225 EXPECT_EQ(OkStatus(), bb.status());
226 }
227
TEST(ByteBuilder,PushBack)228 TEST(ByteBuilder, PushBack) {
229 ByteBuffer<12> bb;
230 bb.push_back(byte{0x01});
231 EXPECT_EQ(OkStatus(), bb.status());
232 EXPECT_EQ(1u, bb.size());
233 EXPECT_EQ(byte{0x01}, bb.data()[0]);
234 }
235
TEST(ByteBuilder,PushBack_Full)236 TEST(ByteBuilder, PushBack_Full) {
237 ByteBuffer<1> bb;
238 bb.push_back(byte{0x01});
239 EXPECT_EQ(OkStatus(), bb.status());
240 EXPECT_EQ(1u, bb.size());
241 }
242
TEST(ByteBuilder,PushBack_Full_ResourceExhausted)243 TEST(ByteBuilder, PushBack_Full_ResourceExhausted) {
244 ByteBuffer<1> bb;
245 bb.push_back(byte{0x01});
246 bb.push_back(byte{0x01});
247
248 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
249 EXPECT_EQ(1u, bb.size());
250 }
251
TEST(ByteBuilder,PopBack)252 TEST(ByteBuilder, PopBack) {
253 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
254 ByteBuffer<3> bb;
255
256 bb.append(buffer.data(), 3);
257
258 bb.pop_back();
259 EXPECT_EQ(OkStatus(), bb.status());
260 EXPECT_EQ(2u, bb.size());
261 EXPECT_EQ(byte{0x01}, bb.data()[0]);
262 EXPECT_EQ(byte{0x02}, bb.data()[1]);
263 }
264
TEST(ByteBuilder,PopBack_Empty)265 TEST(ByteBuilder, PopBack_Empty) {
266 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
267 ByteBuffer<3> bb;
268 bb.append(buffer.data(), 3);
269
270 bb.pop_back();
271 bb.pop_back();
272 bb.pop_back();
273 EXPECT_EQ(OkStatus(), bb.status());
274 EXPECT_EQ(0u, bb.size());
275 EXPECT_TRUE(bb.empty());
276 }
277
TEST(ByteBuffer,Assign)278 TEST(ByteBuffer, Assign) {
279 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
280 ByteBuffer<10> one;
281 ByteBuffer<10> two;
282
283 one.append(buffer.data(), 3);
284 EXPECT_EQ(byte{0x01}, one.data()[0]);
285 EXPECT_EQ(byte{0x02}, one.data()[1]);
286 EXPECT_EQ(byte{0x03}, one.data()[2]);
287
288 two = one;
289 EXPECT_EQ(byte{0x01}, two.data()[0]);
290 EXPECT_EQ(byte{0x02}, two.data()[1]);
291 EXPECT_EQ(byte{0x03}, two.data()[2]);
292
293 constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05, 0x06, 0x07);
294 one.append(kBytesTestLiteral.data(), 2);
295 two.append(kBytesTestLiteral.data(), 4);
296 EXPECT_EQ(5u, one.size());
297 EXPECT_EQ(7u, two.size());
298 EXPECT_EQ(byte{0x04}, one.data()[3]);
299 EXPECT_EQ(byte{0x05}, one.data()[4]);
300 EXPECT_EQ(byte{0x04}, two.data()[3]);
301 EXPECT_EQ(byte{0x05}, two.data()[4]);
302 EXPECT_EQ(byte{0x06}, two.data()[5]);
303 EXPECT_EQ(byte{0x07}, two.data()[6]);
304
305 two.push_back(byte{0x01});
306 two.push_back(byte{0x01});
307 two.push_back(byte{0x01});
308 two.push_back(byte{0x01});
309 ASSERT_EQ(Status::ResourceExhausted(), two.status());
310
311 one = two;
312 EXPECT_EQ(byte{0x01}, two.data()[7]);
313 EXPECT_EQ(byte{0x01}, two.data()[8]);
314 EXPECT_EQ(byte{0x01}, two.data()[9]);
315 EXPECT_EQ(Status::ResourceExhausted(), one.status());
316 }
317
TEST(ByteBuilder,ResizeError_NoDataAddedAfter)318 TEST(ByteBuilder, ResizeError_NoDataAddedAfter) {
319 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
320 ByteBuffer<8> bb;
321
322 EXPECT_TRUE(bb.append(buffer).ok());
323
324 EXPECT_EQ(3u, bb.size());
325 bb.resize(5);
326 EXPECT_EQ(3u, bb.size());
327 EXPECT_EQ(bb.status(), Status::OutOfRange());
328
329 bb.PutInt8(0xFE);
330 EXPECT_EQ(3u, bb.size());
331 EXPECT_EQ(bb.status(), Status::OutOfRange());
332 }
333
TEST(ByteBuilder,AddingNoBytesToZeroSizedByteBuffer)334 TEST(ByteBuilder, AddingNoBytesToZeroSizedByteBuffer) {
335 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
336 ByteBuffer<0> bb;
337
338 EXPECT_TRUE(bb.append(buffer.data(), 0).ok());
339 EXPECT_EQ(0u, bb.size());
340 }
341
TEST(ByteBuffer,Putting8ByteInts_Full)342 TEST(ByteBuffer, Putting8ByteInts_Full) {
343 ByteBuffer<2> bb;
344 bb.PutInt8(0xFE);
345 bb.PutUint8(0x02);
346
347 EXPECT_EQ(byte{0xFE}, bb.data()[0]);
348 EXPECT_EQ(byte{0x02}, bb.data()[1]);
349 EXPECT_EQ(OkStatus(), bb.status());
350 }
351
TEST(ByteBuffer,Putting8ByteInts_Exhausted)352 TEST(ByteBuffer, Putting8ByteInts_Exhausted) {
353 ByteBuffer<2> bb;
354 bb.PutInt8(0xFE);
355 bb.PutUint8(0x02);
356 bb.PutUint8(0x05);
357
358 EXPECT_EQ(byte{0xFE}, bb.data()[0]);
359 EXPECT_EQ(byte{0x02}, bb.data()[1]);
360 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
361 }
362
TEST(ByteBuffer,Putting16ByteInts_Full_kLittleEndian)363 TEST(ByteBuffer, Putting16ByteInts_Full_kLittleEndian) {
364 ByteBuffer<4> bb;
365 bb.PutInt16(0xFFF7);
366 bb.PutUint16(0x0008);
367
368 EXPECT_EQ(byte{0xF7}, bb.data()[0]);
369 EXPECT_EQ(byte{0xFF}, bb.data()[1]);
370 EXPECT_EQ(byte{0x08}, bb.data()[2]);
371 EXPECT_EQ(byte{0x00}, bb.data()[3]);
372
373 EXPECT_EQ(OkStatus(), bb.status());
374 }
375
TEST(ByteBuffer,Putting16ByteInts_Exhausted_kBigEndian)376 TEST(ByteBuffer, Putting16ByteInts_Exhausted_kBigEndian) {
377 ByteBuffer<5> bb;
378 bb.PutInt16(0xFFF7, endian::big);
379 bb.PutUint16(0x0008, endian::big);
380
381 EXPECT_EQ(byte{0xFF}, bb.data()[0]);
382 EXPECT_EQ(byte{0xF7}, bb.data()[1]);
383 EXPECT_EQ(byte{0x00}, bb.data()[2]);
384 EXPECT_EQ(byte{0x08}, bb.data()[3]);
385
386 bb.PutInt16(0xFAFA, endian::big);
387 EXPECT_EQ(4u, bb.size());
388 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
389 }
390
TEST(ByteBuffer,Putting32ByteInts_Full_kLittleEndian)391 TEST(ByteBuffer, Putting32ByteInts_Full_kLittleEndian) {
392 ByteBuffer<8> bb;
393 bb.PutInt32(0xFFFFFFF1);
394 bb.PutUint32(0x00000014);
395
396 EXPECT_EQ(byte{0xF1}, bb.data()[0]);
397 EXPECT_EQ(byte{0xFF}, bb.data()[1]);
398 EXPECT_EQ(byte{0xFF}, bb.data()[2]);
399 EXPECT_EQ(byte{0xFF}, bb.data()[3]);
400 EXPECT_EQ(byte{0x14}, bb.data()[4]);
401 EXPECT_EQ(byte{0x00}, bb.data()[5]);
402 EXPECT_EQ(byte{0x00}, bb.data()[6]);
403 EXPECT_EQ(byte{0x00}, bb.data()[7]);
404
405 EXPECT_EQ(OkStatus(), bb.status());
406 }
407
TEST(ByteBuffer,Putting32ByteInts_Exhausted_kBigEndian)408 TEST(ByteBuffer, Putting32ByteInts_Exhausted_kBigEndian) {
409 ByteBuffer<10> bb;
410 bb.PutInt32(0xF92927B2, endian::big);
411 bb.PutUint32(0x0C90739E, endian::big);
412
413 EXPECT_EQ(byte{0xF9}, bb.data()[0]);
414 EXPECT_EQ(byte{0x29}, bb.data()[1]);
415 EXPECT_EQ(byte{0x27}, bb.data()[2]);
416 EXPECT_EQ(byte{0xB2}, bb.data()[3]);
417 EXPECT_EQ(byte{0x0C}, bb.data()[4]);
418 EXPECT_EQ(byte{0x90}, bb.data()[5]);
419 EXPECT_EQ(byte{0x73}, bb.data()[6]);
420 EXPECT_EQ(byte{0x9E}, bb.data()[7]);
421
422 bb.PutInt32(-114743374, endian::big);
423 EXPECT_EQ(8u, bb.size());
424 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
425 }
426
TEST(ByteBuffer,Putting64ByteInts_Full_kLittleEndian)427 TEST(ByteBuffer, Putting64ByteInts_Full_kLittleEndian) {
428 ByteBuffer<16> bb;
429 bb.PutInt64(0x000001E8A7A0D569);
430 bb.PutUint64(0xFFFFFE17585F2A97);
431
432 EXPECT_EQ(byte{0x69}, bb.data()[0]);
433 EXPECT_EQ(byte{0xD5}, bb.data()[1]);
434 EXPECT_EQ(byte{0xA0}, bb.data()[2]);
435 EXPECT_EQ(byte{0xA7}, bb.data()[3]);
436 EXPECT_EQ(byte{0xE8}, bb.data()[4]);
437 EXPECT_EQ(byte{0x01}, bb.data()[5]);
438 EXPECT_EQ(byte{0x00}, bb.data()[6]);
439 EXPECT_EQ(byte{0x00}, bb.data()[7]);
440 EXPECT_EQ(byte{0x97}, bb.data()[8]);
441 EXPECT_EQ(byte{0x2A}, bb.data()[9]);
442 EXPECT_EQ(byte{0x5F}, bb.data()[10]);
443 EXPECT_EQ(byte{0x58}, bb.data()[11]);
444 EXPECT_EQ(byte{0x17}, bb.data()[12]);
445 EXPECT_EQ(byte{0xFE}, bb.data()[13]);
446 EXPECT_EQ(byte{0xFF}, bb.data()[14]);
447 EXPECT_EQ(byte{0xFF}, bb.data()[15]);
448
449 EXPECT_EQ(OkStatus(), bb.status());
450 }
451
TEST(ByteBuffer,Putting64ByteInts_Exhausted_kBigEndian)452 TEST(ByteBuffer, Putting64ByteInts_Exhausted_kBigEndian) {
453 ByteBuffer<20> bb;
454 bb.PutUint64(0x000001E8A7A0D569, endian::big);
455 bb.PutInt64(0xFFFFFE17585F2A97, endian::big);
456
457 EXPECT_EQ(byte{0x00}, bb.data()[0]);
458 EXPECT_EQ(byte{0x00}, bb.data()[1]);
459 EXPECT_EQ(byte{0x01}, bb.data()[2]);
460 EXPECT_EQ(byte{0xE8}, bb.data()[3]);
461 EXPECT_EQ(byte{0xA7}, bb.data()[4]);
462 EXPECT_EQ(byte{0xA0}, bb.data()[5]);
463 EXPECT_EQ(byte{0xD5}, bb.data()[6]);
464 EXPECT_EQ(byte{0x69}, bb.data()[7]);
465 EXPECT_EQ(byte{0xFF}, bb.data()[8]);
466 EXPECT_EQ(byte{0xFF}, bb.data()[9]);
467 EXPECT_EQ(byte{0xFE}, bb.data()[10]);
468 EXPECT_EQ(byte{0x17}, bb.data()[11]);
469 EXPECT_EQ(byte{0x58}, bb.data()[12]);
470 EXPECT_EQ(byte{0x5F}, bb.data()[13]);
471 EXPECT_EQ(byte{0x2A}, bb.data()[14]);
472 EXPECT_EQ(byte{0x97}, bb.data()[15]);
473
474 bb.PutInt64(-6099875637501324530, endian::big);
475 EXPECT_EQ(16u, bb.size());
476 EXPECT_EQ(Status::ResourceExhausted(), bb.status());
477 }
478
TEST(ByteBuffer,PuttingInts_MixedTypes_MixedEndian)479 TEST(ByteBuffer, PuttingInts_MixedTypes_MixedEndian) {
480 ByteBuffer<16> bb;
481 bb.PutUint8(0x03);
482 bb.PutInt16(0xFD6D, endian::big);
483 bb.PutUint32(0x482B3D9E);
484 bb.PutInt64(0x9A1C3641843DF317, endian::big);
485 bb.PutInt8(0xFB);
486
487 EXPECT_EQ(byte{0x03}, bb.data()[0]);
488 EXPECT_EQ(byte{0xFD}, bb.data()[1]);
489 EXPECT_EQ(byte{0x6D}, bb.data()[2]);
490 EXPECT_EQ(byte{0x9E}, bb.data()[3]);
491 EXPECT_EQ(byte{0x3D}, bb.data()[4]);
492 EXPECT_EQ(byte{0x2B}, bb.data()[5]);
493 EXPECT_EQ(byte{0x48}, bb.data()[6]);
494 EXPECT_EQ(byte{0x9A}, bb.data()[7]);
495 EXPECT_EQ(byte{0x1C}, bb.data()[8]);
496 EXPECT_EQ(byte{0x36}, bb.data()[9]);
497 EXPECT_EQ(byte{0x41}, bb.data()[10]);
498 EXPECT_EQ(byte{0x84}, bb.data()[11]);
499 EXPECT_EQ(byte{0x3D}, bb.data()[12]);
500 EXPECT_EQ(byte{0xF3}, bb.data()[13]);
501 EXPECT_EQ(byte{0x17}, bb.data()[14]);
502 EXPECT_EQ(byte{0xFB}, bb.data()[15]);
503
504 EXPECT_EQ(OkStatus(), bb.status());
505 }
506
TEST(ByteBuffer,Iterator)507 TEST(ByteBuffer, Iterator) {
508 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
509 ByteBuffer<8> bb;
510 EXPECT_TRUE(bb.append(buffer).ok());
511
512 auto it = bb.begin();
513 EXPECT_EQ(*it, byte{0x01});
514
515 ++it;
516 EXPECT_EQ(*it, byte{0x02});
517 EXPECT_EQ(it - bb.begin(), 1);
518
519 ++it;
520 EXPECT_EQ(*it, byte{0x03});
521 EXPECT_EQ(it - bb.begin(), 2);
522
523 ++it;
524 EXPECT_EQ(it, bb.end());
525 EXPECT_EQ(static_cast<size_t>(it - bb.begin()), bb.size());
526 }
527
TEST(ByteBuffer,Iterator_PreIncrement)528 TEST(ByteBuffer, Iterator_PreIncrement) {
529 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
530 ByteBuffer<8> bb;
531 EXPECT_TRUE(bb.append(buffer).ok());
532
533 auto it = bb.begin();
534 EXPECT_EQ(*(++it), byte{0x02});
535 }
536
TEST(ByteBuffer,Iterator_PostIncrement)537 TEST(ByteBuffer, Iterator_PostIncrement) {
538 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
539 ByteBuffer<8> bb;
540 EXPECT_TRUE(bb.append(buffer).ok());
541
542 auto it = bb.begin();
543 EXPECT_EQ(*(it++), byte{0x01});
544 EXPECT_EQ(*it, byte{0x02});
545 EXPECT_EQ(*(it++), byte{0x02});
546 EXPECT_EQ(*it, byte{0x03});
547 }
548
TEST(ByteBuffer,Iterator_PreDecrement)549 TEST(ByteBuffer, Iterator_PreDecrement) {
550 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
551 ByteBuffer<8> bb;
552 EXPECT_TRUE(bb.append(buffer).ok());
553 auto it = bb.begin();
554
555 EXPECT_EQ(*it, byte{0x01});
556 ++it;
557 EXPECT_EQ(*it, byte{0x02});
558 ++it;
559 EXPECT_EQ(*it, byte{0x03});
560 ++it;
561 EXPECT_EQ(it, bb.end());
562
563 --it;
564 EXPECT_EQ(*it, byte{0x03});
565 --it;
566 EXPECT_EQ(*it, byte{0x02});
567 --it;
568 EXPECT_EQ(*it, byte{0x01});
569 EXPECT_EQ(it, bb.begin());
570 }
571
TEST(ByteBuffer,Iterator_PostDecrement)572 TEST(ByteBuffer, Iterator_PostDecrement) {
573 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
574 ByteBuffer<8> bb;
575 EXPECT_TRUE(bb.append(buffer).ok());
576 auto it = bb.begin();
577
578 it += 2;
579 EXPECT_EQ(*it, byte{0x03});
580
581 EXPECT_EQ(*(it--), byte{0x03});
582 EXPECT_EQ(*it, byte{0x02});
583 EXPECT_EQ(*(it--), byte{0x02});
584 EXPECT_EQ(*it, byte{0x01});
585 }
586
TEST(ByteBuffer,Iterator_PlusEquals)587 TEST(ByteBuffer, Iterator_PlusEquals) {
588 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
589 ByteBuffer<8> bb;
590 EXPECT_TRUE(bb.append(buffer).ok());
591 auto it = bb.begin();
592
593 it += 2;
594 EXPECT_EQ(*it, byte{0x03});
595
596 it += -1;
597 EXPECT_EQ(*it, byte{0x02});
598
599 it += 1;
600 EXPECT_EQ(*it, byte{0x03});
601
602 it += -2;
603 EXPECT_EQ(*it, byte{0x01});
604 }
605
TEST(ByteBuffer,Iterator_MinusEquals)606 TEST(ByteBuffer, Iterator_MinusEquals) {
607 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
608 ByteBuffer<8> bb;
609 EXPECT_TRUE(bb.append(buffer).ok());
610 auto it = bb.begin();
611
612 it -= -2;
613 EXPECT_EQ(*it, byte{0x03});
614
615 it -= +1;
616 EXPECT_EQ(*it, byte{0x02});
617
618 it -= -1;
619 EXPECT_EQ(*it, byte{0x03});
620
621 it -= +2;
622 EXPECT_EQ(*it, byte{0x01});
623 }
624
TEST(ByteBuffer,Iterator_Plus)625 TEST(ByteBuffer, Iterator_Plus) {
626 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
627 ByteBuffer<8> bb;
628 EXPECT_TRUE(bb.append(buffer).ok());
629 auto it = bb.begin();
630
631 auto test = it + 2;
632 EXPECT_EQ(*test, byte{0x03});
633
634 test = test + -1;
635 EXPECT_EQ(*test, byte{0x02});
636
637 test = test + 1;
638 EXPECT_EQ(*test, byte{0x03});
639
640 test = test + (-2);
641 EXPECT_EQ(*test, byte{0x01});
642 }
643
TEST(ByteBuffer,Iterator_Minus)644 TEST(ByteBuffer, Iterator_Minus) {
645 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
646 ByteBuffer<8> bb;
647 EXPECT_TRUE(bb.append(buffer).ok());
648 auto it = bb.begin();
649
650 auto test = it - (-2);
651 EXPECT_EQ(*test, byte{0x03});
652
653 test = test - 1;
654 EXPECT_EQ(*test, byte{0x02});
655
656 test = test - (-1);
657 EXPECT_EQ(*test, byte{0x03});
658
659 test = test - 2;
660 EXPECT_EQ(*test, byte{0x01});
661 }
662
TEST(ByteBuffer,Iterator_LessThan)663 TEST(ByteBuffer, Iterator_LessThan) {
664 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
665 ByteBuffer<8> bb;
666 EXPECT_TRUE(bb.append(buffer).ok());
667
668 auto it_1 = bb.begin();
669 auto it_2 = it_1 + 2;
670 EXPECT_EQ(*it_1, byte{0x01});
671 EXPECT_EQ(*it_2, byte{0x03});
672 EXPECT_TRUE(it_1 < it_2);
673
674 it_1++;
675 it_2--;
676 EXPECT_EQ(*it_1, byte{0x02});
677 EXPECT_EQ(*it_2, byte{0x02});
678 EXPECT_FALSE(it_1 < it_2);
679
680 it_1++;
681 it_2--;
682 EXPECT_EQ(*it_1, byte{0x03});
683 EXPECT_EQ(*it_2, byte{0x01});
684 EXPECT_FALSE(it_1 < it_2);
685 EXPECT_TRUE(it_2 < it_1);
686 }
687
TEST(ByteBuffer,Iterator_GreaterThan)688 TEST(ByteBuffer, Iterator_GreaterThan) {
689 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
690 ByteBuffer<8> bb;
691 EXPECT_TRUE(bb.append(buffer).ok());
692
693 auto it_1 = bb.begin();
694 auto it_2 = it_1 + 2;
695 EXPECT_EQ(*it_1, byte{0x01});
696 EXPECT_EQ(*it_2, byte{0x03});
697 EXPECT_FALSE(it_1 > it_2);
698
699 it_1++;
700 it_2--;
701 EXPECT_EQ(*it_1, byte{0x02});
702 EXPECT_EQ(*it_2, byte{0x02});
703 EXPECT_FALSE(it_1 > it_2);
704
705 it_1++;
706 it_2--;
707 EXPECT_EQ(*it_1, byte{0x03});
708 EXPECT_EQ(*it_2, byte{0x01});
709 EXPECT_TRUE(it_1 > it_2);
710 EXPECT_FALSE(it_2 > it_1);
711 }
712
TEST(ByteBuffer,Iterator_LessThanEqual_GreaterThanEqual)713 TEST(ByteBuffer, Iterator_LessThanEqual_GreaterThanEqual) {
714 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
715 ByteBuffer<8> bb;
716 EXPECT_TRUE(bb.append(buffer).ok());
717
718 auto it_1 = bb.begin();
719 auto it_2 = it_1 + 2;
720 EXPECT_EQ(*it_1, byte{0x01});
721 EXPECT_EQ(*it_2, byte{0x03});
722 EXPECT_FALSE(it_1 >= it_2);
723 EXPECT_TRUE(it_1 <= it_2);
724
725 it_1++;
726 it_2--;
727 EXPECT_EQ(*it_1, byte{0x02});
728 EXPECT_EQ(*it_2, byte{0x02});
729 EXPECT_TRUE(it_1 >= it_2);
730 EXPECT_TRUE(it_1 <= it_2);
731
732 it_1++;
733 it_2--;
734 EXPECT_EQ(*it_1, byte{0x03});
735 EXPECT_EQ(*it_2, byte{0x01});
736 EXPECT_FALSE(it_1 <= it_2);
737 EXPECT_TRUE(it_1 >= it_2);
738 }
739
TEST(ByteBuffer,Iterator_Indexing)740 TEST(ByteBuffer, Iterator_Indexing) {
741 std::array<byte, 3> buffer = MakeBytes(0x01, 0x02, 0x03);
742 ByteBuffer<8> bb;
743 EXPECT_TRUE(bb.append(buffer).ok());
744
745 auto it = bb.begin();
746 EXPECT_EQ(it[0], byte{0x01});
747 EXPECT_EQ(it[1], byte{0x02});
748 EXPECT_EQ(it[2], byte{0x03});
749 }
750
TEST(ByteBuffer,Iterator_PeekValues_1Byte)751 TEST(ByteBuffer, Iterator_PeekValues_1Byte) {
752 ByteBuffer<3> bb;
753 bb.PutInt8(0xF2);
754 bb.PutUint8(0xE5);
755 bb.PutInt8(0x5F);
756
757 auto it = bb.begin();
758 EXPECT_EQ(it.PeekInt8(), int8_t(0xF2));
759 it = it + 1;
760 EXPECT_EQ(it.PeekUint8(), uint8_t(0xE5));
761 it = it + 1;
762 EXPECT_EQ(it.PeekInt8(), int8_t(0x5F));
763 }
764
TEST(ByteBuffer,Iterator_PeekValues_2Bytes)765 TEST(ByteBuffer, Iterator_PeekValues_2Bytes) {
766 ByteBuffer<4> bb;
767 bb.PutInt16(0xA7F1);
768 bb.PutUint16(0xF929, endian::big);
769
770 auto it = bb.begin();
771 EXPECT_EQ(it.PeekInt16(), int16_t(0xA7F1));
772 it = it + 2;
773 EXPECT_EQ(it.PeekUint16(endian::big), uint16_t(0xF929));
774 }
775
TEST(ByteBuffer,Iterator_PeekValues_4Bytes)776 TEST(ByteBuffer, Iterator_PeekValues_4Bytes) {
777 ByteBuffer<8> bb;
778 bb.PutInt32(0xFFFFFFF1);
779 bb.PutUint32(0xF92927B2, endian::big);
780
781 auto it = bb.begin();
782 EXPECT_EQ(it.PeekInt32(), int32_t(0xFFFFFFF1));
783 it = it + 4;
784 EXPECT_EQ(it.PeekUint32(endian::big), uint32_t(0xF92927B2));
785 }
786
TEST(ByteBuffer,Iterator_PeekValues_8Bytes)787 TEST(ByteBuffer, Iterator_PeekValues_8Bytes) {
788 ByteBuffer<16> bb;
789 bb.PutUint64(0x000001E8A7A0D569);
790 bb.PutInt64(0xFFFFFE17585F2A97, endian::big);
791
792 auto it = bb.begin();
793 EXPECT_EQ(it.PeekUint64(), uint64_t(0x000001E8A7A0D569));
794 it = it + 8;
795 EXPECT_EQ(it.PeekInt64(endian::big), int64_t(0xFFFFFE17585F2A97));
796 }
797
TEST(ByteBuffer,Iterator_ReadValues_1Byte)798 TEST(ByteBuffer, Iterator_ReadValues_1Byte) {
799 ByteBuffer<3> bb;
800 bb.PutInt8(0xF2);
801 bb.PutUint8(0xE5);
802 bb.PutInt8(0x5F);
803
804 auto it = bb.begin();
805 EXPECT_EQ(it.ReadInt8(), int8_t(0xF2));
806 EXPECT_EQ(it.ReadUint8(), uint8_t(0xE5));
807 EXPECT_EQ(it.ReadInt8(), int8_t(0x5F));
808 }
809
TEST(ByteBuffer,Iterator_ReadValues_2Bytes)810 TEST(ByteBuffer, Iterator_ReadValues_2Bytes) {
811 ByteBuffer<4> bb;
812 bb.PutInt16(0xA7F1);
813 bb.PutUint16(0xF929, endian::big);
814
815 auto it = bb.begin();
816 EXPECT_EQ(it.ReadInt16(), int16_t(0xA7F1));
817 EXPECT_EQ(it.ReadUint16(endian::big), uint16_t(0xF929));
818 }
819
TEST(ByteBuffer,Iterator_ReadValues_4Bytes)820 TEST(ByteBuffer, Iterator_ReadValues_4Bytes) {
821 ByteBuffer<8> bb;
822 bb.PutInt32(0xFFFFFFF1);
823 bb.PutUint32(0xF92927B2, endian::big);
824
825 auto it = bb.begin();
826 EXPECT_EQ(it.ReadInt32(), int32_t(0xFFFFFFF1));
827 EXPECT_EQ(it.ReadUint32(endian::big), uint32_t(0xF92927B2));
828 }
829
TEST(ByteBuffer,Iterator_ReadValues_8Bytes)830 TEST(ByteBuffer, Iterator_ReadValues_8Bytes) {
831 ByteBuffer<16> bb;
832 bb.PutUint64(0x000001E8A7A0D569);
833 bb.PutInt64(0xFFFFFE17585F2A97, endian::big);
834
835 auto it = bb.begin();
836 EXPECT_EQ(it.ReadUint64(), uint64_t(0x000001E8A7A0D569));
837 EXPECT_EQ(it.ReadInt64(endian::big), int64_t(0xFFFFFE17585F2A97));
838 }
839
TEST(ByteBuffer,ConvertsToSpan)840 TEST(ByteBuffer, ConvertsToSpan) {
841 ByteBuffer<16> bb;
842 bb.push_back(std::byte{210});
843
844 span<const std::byte> byte_span(bb);
845 EXPECT_EQ(byte_span.data(), bb.data());
846 EXPECT_EQ(byte_span.size(), bb.size());
847 EXPECT_EQ(byte_span[0], std::byte{210});
848 }
849
850 } // namespace
851 } // namespace pw
852