1 // Copyright 2019 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "util/big_endian.h"
6
7 #include "gmock/gmock.h"
8 #include "gtest/gtest.h"
9
10 namespace openscreen {
11 namespace {
12
13 // Tests that ReadBigEndian() correctly imports values from various offsets in
14 // memory.
TEST(BigEndianTest,ReadValues)15 TEST(BigEndianTest, ReadValues) {
16 const uint8_t kInput[] = {
17 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa,
18 0xb, 0xc, 0xd, 0xe, 0xf, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
19 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
20 };
21
22 EXPECT_EQ(UINT8_C(0x05), ReadBigEndian<uint8_t>(kInput + 5));
23 EXPECT_EQ(UINT8_C(0xff), ReadBigEndian<uint8_t>(kInput + 16));
24 EXPECT_EQ(7, ReadBigEndian<int8_t>(kInput + 7));
25 EXPECT_EQ(-1, ReadBigEndian<int8_t>(kInput + 17));
26
27 EXPECT_EQ(UINT16_C(0x0001), ReadBigEndian<uint16_t>(kInput));
28 EXPECT_EQ(UINT16_C(0x0102), ReadBigEndian<uint16_t>(kInput + 1));
29 EXPECT_EQ(UINT16_C(0x0203), ReadBigEndian<uint16_t>(kInput + 2));
30 EXPECT_EQ(-1, ReadBigEndian<int16_t>(kInput + 16));
31 EXPECT_EQ(-2, ReadBigEndian<int16_t>(kInput + 17));
32
33 EXPECT_EQ(UINT32_C(0x03040506), ReadBigEndian<uint32_t>(kInput + 3));
34 EXPECT_EQ(UINT32_C(0x04050607), ReadBigEndian<uint32_t>(kInput + 4));
35 EXPECT_EQ(UINT32_C(0x05060708), ReadBigEndian<uint32_t>(kInput + 5));
36 EXPECT_EQ(-1, ReadBigEndian<int32_t>(kInput + 19));
37 EXPECT_EQ(-2, ReadBigEndian<int32_t>(kInput + 20));
38
39 EXPECT_EQ(UINT64_C(0x0001020304050607), ReadBigEndian<uint64_t>(kInput));
40 EXPECT_EQ(UINT64_C(0x0102030405060708), ReadBigEndian<uint64_t>(kInput + 1));
41 EXPECT_EQ(UINT64_C(0x0203040506070809), ReadBigEndian<uint64_t>(kInput + 2));
42 EXPECT_EQ(-1, ReadBigEndian<int64_t>(kInput + 24));
43 EXPECT_EQ(-2, ReadBigEndian<int64_t>(kInput + 25));
44 }
45
46 // Tests that WriteBigEndian() correctly writes-out values to various offsets in
47 // memory. This test assumes ReadBigEndian() is working, using it to verify that
48 // WriteBigEndian() is working.
TEST(BigEndianTest,WriteValues)49 TEST(BigEndianTest, WriteValues) {
50 uint8_t scratch[16];
51
52 WriteBigEndian<uint8_t>(0x07, scratch);
53 EXPECT_EQ(UINT8_C(0x07), ReadBigEndian<uint8_t>(scratch));
54 WriteBigEndian<uint8_t>(0xf0, scratch + 1);
55 EXPECT_EQ(UINT8_C(0xf0), ReadBigEndian<uint8_t>(scratch + 1));
56 WriteBigEndian<int8_t>(23, scratch + 2);
57 EXPECT_EQ(23, ReadBigEndian<int8_t>(scratch + 2));
58 WriteBigEndian<int8_t>(-25, scratch + 3);
59 EXPECT_EQ(-25, ReadBigEndian<int8_t>(scratch + 3));
60
61 WriteBigEndian<uint16_t>(0x0102, scratch);
62 EXPECT_EQ(UINT16_C(0x0102), ReadBigEndian<uint16_t>(scratch));
63 WriteBigEndian<uint16_t>(0x0304, scratch + 1);
64 EXPECT_EQ(UINT16_C(0x0304), ReadBigEndian<uint16_t>(scratch + 1));
65 WriteBigEndian<uint16_t>(0x0506, scratch + 2);
66 EXPECT_EQ(UINT16_C(0x0506), ReadBigEndian<uint16_t>(scratch + 2));
67 WriteBigEndian<int16_t>(42, scratch + 3);
68 EXPECT_EQ(42, ReadBigEndian<int16_t>(scratch + 3));
69 WriteBigEndian<int16_t>(-1, scratch + 4);
70 EXPECT_EQ(-1, ReadBigEndian<int16_t>(scratch + 4));
71 WriteBigEndian<int16_t>(-2, scratch + 5);
72 EXPECT_EQ(-2, ReadBigEndian<int16_t>(scratch + 5));
73
74 WriteBigEndian<uint32_t>(UINT32_C(0x03040506), scratch);
75 EXPECT_EQ(UINT32_C(0x03040506), ReadBigEndian<uint32_t>(scratch));
76 WriteBigEndian<uint32_t>(UINT32_C(0x0708090a), scratch + 1);
77 EXPECT_EQ(UINT32_C(0x0708090a), ReadBigEndian<uint32_t>(scratch + 1));
78 WriteBigEndian<uint32_t>(UINT32_C(0x0b0c0d0e), scratch + 2);
79 EXPECT_EQ(UINT32_C(0x0b0c0d0e), ReadBigEndian<uint32_t>(scratch + 2));
80 WriteBigEndian<int32_t>(42, scratch + 3);
81 EXPECT_EQ(42, ReadBigEndian<int32_t>(scratch + 3));
82 WriteBigEndian<int32_t>(-1, scratch + 4);
83 EXPECT_EQ(-1, ReadBigEndian<int32_t>(scratch + 4));
84 WriteBigEndian<int32_t>(-2, scratch + 5);
85 EXPECT_EQ(-2, ReadBigEndian<int32_t>(scratch + 5));
86
87 WriteBigEndian<uint64_t>(UINT64_C(0x0f0e0d0c0b0a0908), scratch);
88 EXPECT_EQ(UINT64_C(0x0f0e0d0c0b0a0908), ReadBigEndian<uint64_t>(scratch));
89 WriteBigEndian<uint64_t>(UINT64_C(0x0708090a0b0c0d0e), scratch + 1);
90 EXPECT_EQ(UINT64_C(0x0708090a0b0c0d0e), ReadBigEndian<uint64_t>(scratch + 1));
91 WriteBigEndian<uint64_t>(UINT64_C(0x99aa88bb77cc66dd), scratch + 2);
92 EXPECT_EQ(UINT64_C(0x99aa88bb77cc66dd), ReadBigEndian<uint64_t>(scratch + 2));
93 WriteBigEndian<int64_t>(42, scratch + 3);
94 EXPECT_EQ(42, ReadBigEndian<int64_t>(scratch + 3));
95 WriteBigEndian<int64_t>(-1, scratch + 4);
96 EXPECT_EQ(-1, ReadBigEndian<int64_t>(scratch + 4));
97 WriteBigEndian<int64_t>(-2, scratch + 5);
98 EXPECT_EQ(-2, ReadBigEndian<int64_t>(scratch + 5));
99 }
100
TEST(BigEndianReaderTest,ConstructWithValidBuffer)101 TEST(BigEndianReaderTest, ConstructWithValidBuffer) {
102 uint8_t data[64];
103 BigEndianReader reader(data, sizeof(data));
104
105 EXPECT_EQ(reader.begin(), data);
106 EXPECT_EQ(reader.current(), data);
107 EXPECT_EQ(reader.end(), data + 64);
108 EXPECT_EQ(reader.offset(), 0u);
109 EXPECT_EQ(reader.remaining(), 64u);
110 EXPECT_EQ(reader.length(), 64u);
111 }
112
TEST(BigEndianReaderTest,SkipLessThanRemaining)113 TEST(BigEndianReaderTest, SkipLessThanRemaining) {
114 uint8_t data[64];
115 BigEndianReader reader(data, sizeof(data));
116
117 EXPECT_TRUE(reader.Skip(16));
118
119 EXPECT_EQ(reader.begin(), data);
120 EXPECT_EQ(reader.current(), data + 16);
121 EXPECT_EQ(reader.end(), data + 64);
122 EXPECT_EQ(reader.offset(), 16u);
123 EXPECT_EQ(reader.remaining(), 48u);
124 EXPECT_EQ(reader.length(), 64u);
125 }
126
TEST(BigEndianReaderTest,SkipMoreThanRemaining)127 TEST(BigEndianReaderTest, SkipMoreThanRemaining) {
128 uint8_t data[64];
129 BigEndianReader reader(data, sizeof(data));
130
131 EXPECT_TRUE(reader.Skip(16));
132 EXPECT_FALSE(reader.Skip(64));
133
134 // Check that failed Skip does not modify any pointers or offsets.
135 EXPECT_EQ(reader.begin(), data);
136 EXPECT_EQ(reader.current(), data + 16);
137 EXPECT_EQ(reader.end(), data + 64);
138 EXPECT_EQ(reader.offset(), 16u);
139 EXPECT_EQ(reader.remaining(), 48u);
140 EXPECT_EQ(reader.length(), 64u);
141 }
142
TEST(BigEndianReaderTest,ConstructWithZeroLengthBuffer)143 TEST(BigEndianReaderTest, ConstructWithZeroLengthBuffer) {
144 uint8_t data[8];
145 BigEndianReader reader(data, 0);
146
147 EXPECT_EQ(reader.begin(), data);
148 EXPECT_EQ(reader.current(), data);
149 EXPECT_EQ(reader.end(), data);
150 EXPECT_EQ(reader.offset(), 0u);
151 EXPECT_EQ(reader.remaining(), 0u);
152 EXPECT_EQ(reader.length(), 0u);
153
154 EXPECT_FALSE(reader.Skip(1));
155 }
156
TEST(BigEndianReaderTest,ReadValues)157 TEST(BigEndianReaderTest, ReadValues) {
158 uint8_t data[17] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
159 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10};
160 BigEndianReader reader(data, sizeof(data));
161
162 uint8_t buffer[2];
163 EXPECT_TRUE(reader.Read(sizeof(buffer), buffer));
164 EXPECT_EQ(buffer[0], UINT8_C(0x0));
165 EXPECT_EQ(buffer[1], UINT8_C(0x1));
166
167 uint8_t u8;
168 EXPECT_TRUE(reader.Read<uint8_t>(&u8));
169 EXPECT_EQ(u8, UINT8_C(0x2));
170
171 uint16_t u16;
172 EXPECT_TRUE(reader.Read<uint16_t>(&u16));
173 EXPECT_EQ(u16, UINT16_C(0x0304));
174
175 uint32_t u32;
176 EXPECT_TRUE(reader.Read<uint32_t>(&u32));
177 EXPECT_EQ(u32, UINT32_C(0x05060708));
178
179 uint64_t u64;
180 EXPECT_TRUE(reader.Read<uint64_t>(&u64));
181 EXPECT_EQ(u64, UINT64_C(0x090A0B0C0D0E0F10));
182
183 EXPECT_EQ(reader.begin(), data);
184 EXPECT_EQ(reader.current(), data + 17);
185 EXPECT_EQ(reader.end(), data + 17);
186 EXPECT_EQ(reader.offset(), 17u);
187 EXPECT_EQ(reader.remaining(), 0u);
188 EXPECT_EQ(reader.length(), 17u);
189 }
190
TEST(BigEndianReaderTest,RespectLength)191 TEST(BigEndianReaderTest, RespectLength) {
192 uint8_t data[8];
193 BigEndianReader reader(data, sizeof(data));
194
195 // 8 left
196 EXPECT_FALSE(reader.Skip(9));
197 EXPECT_TRUE(reader.Skip(1));
198
199 // 7 left
200 uint64_t u64;
201 EXPECT_FALSE(reader.Read<uint64_t>(&u64));
202 EXPECT_TRUE(reader.Skip(4));
203
204 // 3 left
205 uint32_t u32;
206 EXPECT_FALSE(reader.Read<uint32_t>(&u32));
207 EXPECT_TRUE(reader.Skip(2));
208
209 // 1 left
210 uint16_t u16;
211 EXPECT_FALSE(reader.Read<uint16_t>(&u16));
212
213 uint8_t buffer[2];
214 EXPECT_FALSE(reader.Read(2, buffer));
215 EXPECT_TRUE(reader.Skip(1));
216
217 // 0 left
218 uint8_t u8;
219 EXPECT_FALSE(reader.Read<uint8_t>(&u8));
220
221 EXPECT_EQ(reader.begin(), data);
222 EXPECT_EQ(reader.current(), data + 8);
223 EXPECT_EQ(reader.end(), data + 8);
224 EXPECT_EQ(reader.offset(), 8u);
225 EXPECT_EQ(reader.remaining(), 0u);
226 EXPECT_EQ(reader.length(), 8u);
227 }
228
TEST(BigEndianBufferCursorTest,CursorCommit)229 TEST(BigEndianBufferCursorTest, CursorCommit) {
230 uint8_t data[16] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
231 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
232 BigEndianReader reader(data, sizeof(data));
233
234 {
235 BigEndianReader::Cursor cursor(&reader);
236
237 uint8_t u8;
238 EXPECT_TRUE(reader.Read<uint8_t>(&u8));
239 EXPECT_EQ(cursor.delta(), 1u);
240
241 uint16_t u16;
242 EXPECT_TRUE(reader.Read<uint16_t>(&u16));
243 EXPECT_EQ(cursor.delta(), 3u);
244
245 uint32_t u32;
246 EXPECT_TRUE(reader.Read<uint32_t>(&u32));
247 EXPECT_EQ(cursor.delta(), 7u);
248
249 uint64_t u64;
250 EXPECT_TRUE(reader.Read<uint64_t>(&u64));
251 EXPECT_EQ(cursor.delta(), 15u);
252
253 EXPECT_FALSE(reader.Skip(2));
254 EXPECT_EQ(cursor.delta(), 15u);
255 EXPECT_EQ(static_cast<size_t>(reader.current() - cursor.origin()),
256 cursor.delta());
257
258 cursor.Commit();
259 }
260
261 EXPECT_EQ(reader.begin(), data);
262 EXPECT_EQ(reader.current(), data + 15);
263 EXPECT_EQ(reader.end(), data + 16);
264 EXPECT_EQ(reader.offset(), 15u);
265 EXPECT_EQ(reader.remaining(), 1u);
266 EXPECT_EQ(reader.length(), 16u);
267 }
268
TEST(BigEndianBufferCursorTest,CursorRollback)269 TEST(BigEndianBufferCursorTest, CursorRollback) {
270 uint8_t data[16];
271 BigEndianReader reader(data, sizeof(data));
272
273 {
274 BigEndianReader::Cursor cursor(&reader);
275
276 EXPECT_TRUE(reader.Skip(4));
277 EXPECT_EQ(cursor.delta(), 4u);
278 }
279
280 EXPECT_EQ(reader.begin(), data);
281 EXPECT_EQ(reader.current(), data);
282 EXPECT_EQ(reader.end(), data + 16u);
283 EXPECT_EQ(reader.offset(), 0u);
284 EXPECT_EQ(reader.remaining(), 16u);
285 EXPECT_EQ(reader.length(), 16u);
286 }
287
TEST(BigEndianWriterTest,ConstructWithValidBuffer)288 TEST(BigEndianWriterTest, ConstructWithValidBuffer) {
289 uint8_t data[64];
290 BigEndianWriter writer(data, sizeof(data));
291
292 EXPECT_EQ(writer.begin(), data);
293 EXPECT_EQ(writer.current(), data);
294 EXPECT_EQ(writer.end(), data + 64u);
295 EXPECT_EQ(writer.offset(), 0u);
296 EXPECT_EQ(writer.remaining(), 64u);
297 EXPECT_EQ(writer.length(), 64u);
298 }
299
TEST(BigEndianWriterTest,SkipLessThanRemaining)300 TEST(BigEndianWriterTest, SkipLessThanRemaining) {
301 uint8_t data[64];
302 BigEndianWriter writer(data, sizeof(data));
303
304 EXPECT_TRUE(writer.Skip(16));
305
306 EXPECT_EQ(writer.begin(), data);
307 EXPECT_EQ(writer.current(), data + 16u);
308 EXPECT_EQ(writer.end(), data + 64);
309 EXPECT_EQ(writer.offset(), 16u);
310 EXPECT_EQ(writer.remaining(), 48u);
311 EXPECT_EQ(writer.length(), 64u);
312 }
313
TEST(BigEndianWriterTest,SkipMoreThanRemaining)314 TEST(BigEndianWriterTest, SkipMoreThanRemaining) {
315 uint8_t data[64];
316 BigEndianWriter writer(data, sizeof(data));
317
318 EXPECT_TRUE(writer.Skip(16));
319 EXPECT_FALSE(writer.Skip(64));
320
321 // Check that failed Skip does not modify any pointers or offsets.
322 EXPECT_EQ(writer.begin(), data);
323 EXPECT_EQ(writer.current(), data + 16u);
324 EXPECT_EQ(writer.end(), data + 64u);
325 EXPECT_EQ(writer.offset(), 16u);
326 EXPECT_EQ(writer.remaining(), 48u);
327 EXPECT_EQ(writer.length(), 64u);
328 }
329
TEST(BigEndianWriterTest,ConstructWithZeroLengthBuffer)330 TEST(BigEndianWriterTest, ConstructWithZeroLengthBuffer) {
331 uint8_t data[8];
332 BigEndianWriter writer(data, 0);
333
334 EXPECT_EQ(writer.begin(), data);
335 EXPECT_EQ(writer.current(), data);
336 EXPECT_EQ(writer.end(), data);
337 EXPECT_EQ(writer.offset(), 0u);
338 EXPECT_EQ(writer.remaining(), 0u);
339 EXPECT_EQ(writer.length(), 0u);
340
341 EXPECT_FALSE(writer.Skip(1));
342 }
343
TEST(BigEndianWriterTest,WriteValues)344 TEST(BigEndianWriterTest, WriteValues) {
345 uint8_t expected[17] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
346 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10};
347
348 uint8_t data[17];
349 memset(data, 0xFF, sizeof(data));
350 BigEndianWriter writer(data, sizeof(data));
351
352 uint8_t buffer[] = {0x0, 0x1};
353 EXPECT_TRUE(writer.Write(buffer, sizeof(buffer)));
354 EXPECT_TRUE(writer.Write<uint8_t>(UINT8_C(0x2)));
355 EXPECT_TRUE(writer.Write<uint16_t>(UINT16_C(0x0304)));
356 EXPECT_TRUE(writer.Write<uint32_t>(UINT32_C(0x05060708)));
357 EXPECT_TRUE(writer.Write<uint64_t>(UINT64_C(0x090A0B0C0D0E0F10)));
358 EXPECT_THAT(data, testing::ElementsAreArray(expected));
359
360 EXPECT_EQ(writer.begin(), data);
361 EXPECT_EQ(writer.current(), data + 17);
362 EXPECT_EQ(writer.end(), data + 17);
363 EXPECT_EQ(writer.offset(), 17u);
364 EXPECT_EQ(writer.remaining(), 0u);
365 EXPECT_EQ(writer.length(), 17u);
366 }
367
TEST(BigEndianWriterTest,RespectLength)368 TEST(BigEndianWriterTest, RespectLength) {
369 uint8_t data[8];
370 BigEndianWriter writer(data, sizeof(data));
371
372 // 8 left
373 EXPECT_FALSE(writer.Skip(9));
374 EXPECT_TRUE(writer.Skip(1));
375
376 // 7 left
377 EXPECT_FALSE(writer.Write<uint64_t>(0));
378 EXPECT_TRUE(writer.Skip(4));
379
380 // 3 left
381 EXPECT_FALSE(writer.Write<uint32_t>(0));
382 EXPECT_TRUE(writer.Skip(2));
383
384 // 1 left
385 EXPECT_FALSE(writer.Write<uint16_t>(0));
386
387 uint8_t buffer[2];
388 EXPECT_FALSE(writer.Write(buffer, 2));
389 EXPECT_TRUE(writer.Skip(1));
390
391 // 0 left
392 EXPECT_FALSE(writer.Write<uint8_t>(0));
393 EXPECT_EQ(0u, writer.remaining());
394
395 EXPECT_EQ(writer.begin(), data);
396 EXPECT_EQ(writer.current(), data + 8);
397 EXPECT_EQ(writer.end(), data + 8);
398 EXPECT_EQ(writer.offset(), 8u);
399 EXPECT_EQ(writer.remaining(), 0u);
400 EXPECT_EQ(writer.length(), 8u);
401 }
402
403 } // namespace
404 } // namespace openscreen
405