| // Copyright 2019 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "util/big_endian.h" |
| |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| |
| namespace openscreen { |
| namespace { |
| |
| // Tests that ReadBigEndian() correctly imports values from various offsets in |
| // memory. |
| TEST(BigEndianTest, ReadValues) { |
| const uint8_t kInput[] = { |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, |
| 0xb, 0xc, 0xd, 0xe, 0xf, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, |
| 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, |
| }; |
| |
| EXPECT_EQ(UINT8_C(0x05), ReadBigEndian<uint8_t>(kInput + 5)); |
| EXPECT_EQ(UINT8_C(0xff), ReadBigEndian<uint8_t>(kInput + 16)); |
| EXPECT_EQ(7, ReadBigEndian<int8_t>(kInput + 7)); |
| EXPECT_EQ(-1, ReadBigEndian<int8_t>(kInput + 17)); |
| |
| EXPECT_EQ(UINT16_C(0x0001), ReadBigEndian<uint16_t>(kInput)); |
| EXPECT_EQ(UINT16_C(0x0102), ReadBigEndian<uint16_t>(kInput + 1)); |
| EXPECT_EQ(UINT16_C(0x0203), ReadBigEndian<uint16_t>(kInput + 2)); |
| EXPECT_EQ(-1, ReadBigEndian<int16_t>(kInput + 16)); |
| EXPECT_EQ(-2, ReadBigEndian<int16_t>(kInput + 17)); |
| |
| EXPECT_EQ(UINT32_C(0x03040506), ReadBigEndian<uint32_t>(kInput + 3)); |
| EXPECT_EQ(UINT32_C(0x04050607), ReadBigEndian<uint32_t>(kInput + 4)); |
| EXPECT_EQ(UINT32_C(0x05060708), ReadBigEndian<uint32_t>(kInput + 5)); |
| EXPECT_EQ(-1, ReadBigEndian<int32_t>(kInput + 19)); |
| EXPECT_EQ(-2, ReadBigEndian<int32_t>(kInput + 20)); |
| |
| EXPECT_EQ(UINT64_C(0x0001020304050607), ReadBigEndian<uint64_t>(kInput)); |
| EXPECT_EQ(UINT64_C(0x0102030405060708), ReadBigEndian<uint64_t>(kInput + 1)); |
| EXPECT_EQ(UINT64_C(0x0203040506070809), ReadBigEndian<uint64_t>(kInput + 2)); |
| EXPECT_EQ(-1, ReadBigEndian<int64_t>(kInput + 24)); |
| EXPECT_EQ(-2, ReadBigEndian<int64_t>(kInput + 25)); |
| } |
| |
| // Tests that WriteBigEndian() correctly writes-out values to various offsets in |
| // memory. This test assumes ReadBigEndian() is working, using it to verify that |
| // WriteBigEndian() is working. |
| TEST(BigEndianTest, WriteValues) { |
| uint8_t scratch[16]; |
| |
| WriteBigEndian<uint8_t>(0x07, scratch); |
| EXPECT_EQ(UINT8_C(0x07), ReadBigEndian<uint8_t>(scratch)); |
| WriteBigEndian<uint8_t>(0xf0, scratch + 1); |
| EXPECT_EQ(UINT8_C(0xf0), ReadBigEndian<uint8_t>(scratch + 1)); |
| WriteBigEndian<int8_t>(23, scratch + 2); |
| EXPECT_EQ(23, ReadBigEndian<int8_t>(scratch + 2)); |
| WriteBigEndian<int8_t>(-25, scratch + 3); |
| EXPECT_EQ(-25, ReadBigEndian<int8_t>(scratch + 3)); |
| |
| WriteBigEndian<uint16_t>(0x0102, scratch); |
| EXPECT_EQ(UINT16_C(0x0102), ReadBigEndian<uint16_t>(scratch)); |
| WriteBigEndian<uint16_t>(0x0304, scratch + 1); |
| EXPECT_EQ(UINT16_C(0x0304), ReadBigEndian<uint16_t>(scratch + 1)); |
| WriteBigEndian<uint16_t>(0x0506, scratch + 2); |
| EXPECT_EQ(UINT16_C(0x0506), ReadBigEndian<uint16_t>(scratch + 2)); |
| WriteBigEndian<int16_t>(42, scratch + 3); |
| EXPECT_EQ(42, ReadBigEndian<int16_t>(scratch + 3)); |
| WriteBigEndian<int16_t>(-1, scratch + 4); |
| EXPECT_EQ(-1, ReadBigEndian<int16_t>(scratch + 4)); |
| WriteBigEndian<int16_t>(-2, scratch + 5); |
| EXPECT_EQ(-2, ReadBigEndian<int16_t>(scratch + 5)); |
| |
| WriteBigEndian<uint32_t>(UINT32_C(0x03040506), scratch); |
| EXPECT_EQ(UINT32_C(0x03040506), ReadBigEndian<uint32_t>(scratch)); |
| WriteBigEndian<uint32_t>(UINT32_C(0x0708090a), scratch + 1); |
| EXPECT_EQ(UINT32_C(0x0708090a), ReadBigEndian<uint32_t>(scratch + 1)); |
| WriteBigEndian<uint32_t>(UINT32_C(0x0b0c0d0e), scratch + 2); |
| EXPECT_EQ(UINT32_C(0x0b0c0d0e), ReadBigEndian<uint32_t>(scratch + 2)); |
| WriteBigEndian<int32_t>(42, scratch + 3); |
| EXPECT_EQ(42, ReadBigEndian<int32_t>(scratch + 3)); |
| WriteBigEndian<int32_t>(-1, scratch + 4); |
| EXPECT_EQ(-1, ReadBigEndian<int32_t>(scratch + 4)); |
| WriteBigEndian<int32_t>(-2, scratch + 5); |
| EXPECT_EQ(-2, ReadBigEndian<int32_t>(scratch + 5)); |
| |
| WriteBigEndian<uint64_t>(UINT64_C(0x0f0e0d0c0b0a0908), scratch); |
| EXPECT_EQ(UINT64_C(0x0f0e0d0c0b0a0908), ReadBigEndian<uint64_t>(scratch)); |
| WriteBigEndian<uint64_t>(UINT64_C(0x0708090a0b0c0d0e), scratch + 1); |
| EXPECT_EQ(UINT64_C(0x0708090a0b0c0d0e), ReadBigEndian<uint64_t>(scratch + 1)); |
| WriteBigEndian<uint64_t>(UINT64_C(0x99aa88bb77cc66dd), scratch + 2); |
| EXPECT_EQ(UINT64_C(0x99aa88bb77cc66dd), ReadBigEndian<uint64_t>(scratch + 2)); |
| WriteBigEndian<int64_t>(42, scratch + 3); |
| EXPECT_EQ(42, ReadBigEndian<int64_t>(scratch + 3)); |
| WriteBigEndian<int64_t>(-1, scratch + 4); |
| EXPECT_EQ(-1, ReadBigEndian<int64_t>(scratch + 4)); |
| WriteBigEndian<int64_t>(-2, scratch + 5); |
| EXPECT_EQ(-2, ReadBigEndian<int64_t>(scratch + 5)); |
| } |
| |
| TEST(BigEndianReaderTest, ConstructWithValidBuffer) { |
| uint8_t data[64]; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data); |
| EXPECT_EQ(reader.end(), data + 64); |
| EXPECT_EQ(reader.offset(), 0u); |
| EXPECT_EQ(reader.remaining(), 64u); |
| EXPECT_EQ(reader.length(), 64u); |
| } |
| |
| TEST(BigEndianReaderTest, SkipLessThanRemaining) { |
| uint8_t data[64]; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| EXPECT_TRUE(reader.Skip(16)); |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data + 16); |
| EXPECT_EQ(reader.end(), data + 64); |
| EXPECT_EQ(reader.offset(), 16u); |
| EXPECT_EQ(reader.remaining(), 48u); |
| EXPECT_EQ(reader.length(), 64u); |
| } |
| |
| TEST(BigEndianReaderTest, SkipMoreThanRemaining) { |
| uint8_t data[64]; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| EXPECT_TRUE(reader.Skip(16)); |
| EXPECT_FALSE(reader.Skip(64)); |
| |
| // Check that failed Skip does not modify any pointers or offsets. |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data + 16); |
| EXPECT_EQ(reader.end(), data + 64); |
| EXPECT_EQ(reader.offset(), 16u); |
| EXPECT_EQ(reader.remaining(), 48u); |
| EXPECT_EQ(reader.length(), 64u); |
| } |
| |
| TEST(BigEndianReaderTest, ConstructWithZeroLengthBuffer) { |
| uint8_t data[8]; |
| BigEndianReader reader(data, 0); |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data); |
| EXPECT_EQ(reader.end(), data); |
| EXPECT_EQ(reader.offset(), 0u); |
| EXPECT_EQ(reader.remaining(), 0u); |
| EXPECT_EQ(reader.length(), 0u); |
| |
| EXPECT_FALSE(reader.Skip(1)); |
| } |
| |
| TEST(BigEndianReaderTest, ReadValues) { |
| uint8_t data[17] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, |
| 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10}; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| uint8_t buffer[2]; |
| EXPECT_TRUE(reader.Read(sizeof(buffer), buffer)); |
| EXPECT_EQ(buffer[0], UINT8_C(0x0)); |
| EXPECT_EQ(buffer[1], UINT8_C(0x1)); |
| |
| uint8_t u8; |
| EXPECT_TRUE(reader.Read<uint8_t>(&u8)); |
| EXPECT_EQ(u8, UINT8_C(0x2)); |
| |
| uint16_t u16; |
| EXPECT_TRUE(reader.Read<uint16_t>(&u16)); |
| EXPECT_EQ(u16, UINT16_C(0x0304)); |
| |
| uint32_t u32; |
| EXPECT_TRUE(reader.Read<uint32_t>(&u32)); |
| EXPECT_EQ(u32, UINT32_C(0x05060708)); |
| |
| uint64_t u64; |
| EXPECT_TRUE(reader.Read<uint64_t>(&u64)); |
| EXPECT_EQ(u64, UINT64_C(0x090A0B0C0D0E0F10)); |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data + 17); |
| EXPECT_EQ(reader.end(), data + 17); |
| EXPECT_EQ(reader.offset(), 17u); |
| EXPECT_EQ(reader.remaining(), 0u); |
| EXPECT_EQ(reader.length(), 17u); |
| } |
| |
| TEST(BigEndianReaderTest, RespectLength) { |
| uint8_t data[8]; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| // 8 left |
| EXPECT_FALSE(reader.Skip(9)); |
| EXPECT_TRUE(reader.Skip(1)); |
| |
| // 7 left |
| uint64_t u64; |
| EXPECT_FALSE(reader.Read<uint64_t>(&u64)); |
| EXPECT_TRUE(reader.Skip(4)); |
| |
| // 3 left |
| uint32_t u32; |
| EXPECT_FALSE(reader.Read<uint32_t>(&u32)); |
| EXPECT_TRUE(reader.Skip(2)); |
| |
| // 1 left |
| uint16_t u16; |
| EXPECT_FALSE(reader.Read<uint16_t>(&u16)); |
| |
| uint8_t buffer[2]; |
| EXPECT_FALSE(reader.Read(2, buffer)); |
| EXPECT_TRUE(reader.Skip(1)); |
| |
| // 0 left |
| uint8_t u8; |
| EXPECT_FALSE(reader.Read<uint8_t>(&u8)); |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data + 8); |
| EXPECT_EQ(reader.end(), data + 8); |
| EXPECT_EQ(reader.offset(), 8u); |
| EXPECT_EQ(reader.remaining(), 0u); |
| EXPECT_EQ(reader.length(), 8u); |
| } |
| |
| TEST(BigEndianBufferCursorTest, CursorCommit) { |
| uint8_t data[16] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, |
| 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF}; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| { |
| BigEndianReader::Cursor cursor(&reader); |
| |
| uint8_t u8; |
| EXPECT_TRUE(reader.Read<uint8_t>(&u8)); |
| EXPECT_EQ(cursor.delta(), 1u); |
| |
| uint16_t u16; |
| EXPECT_TRUE(reader.Read<uint16_t>(&u16)); |
| EXPECT_EQ(cursor.delta(), 3u); |
| |
| uint32_t u32; |
| EXPECT_TRUE(reader.Read<uint32_t>(&u32)); |
| EXPECT_EQ(cursor.delta(), 7u); |
| |
| uint64_t u64; |
| EXPECT_TRUE(reader.Read<uint64_t>(&u64)); |
| EXPECT_EQ(cursor.delta(), 15u); |
| |
| EXPECT_FALSE(reader.Skip(2)); |
| EXPECT_EQ(cursor.delta(), 15u); |
| EXPECT_EQ(static_cast<size_t>(reader.current() - cursor.origin()), |
| cursor.delta()); |
| |
| cursor.Commit(); |
| } |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data + 15); |
| EXPECT_EQ(reader.end(), data + 16); |
| EXPECT_EQ(reader.offset(), 15u); |
| EXPECT_EQ(reader.remaining(), 1u); |
| EXPECT_EQ(reader.length(), 16u); |
| } |
| |
| TEST(BigEndianBufferCursorTest, CursorRollback) { |
| uint8_t data[16]; |
| BigEndianReader reader(data, sizeof(data)); |
| |
| { |
| BigEndianReader::Cursor cursor(&reader); |
| |
| EXPECT_TRUE(reader.Skip(4)); |
| EXPECT_EQ(cursor.delta(), 4u); |
| } |
| |
| EXPECT_EQ(reader.begin(), data); |
| EXPECT_EQ(reader.current(), data); |
| EXPECT_EQ(reader.end(), data + 16u); |
| EXPECT_EQ(reader.offset(), 0u); |
| EXPECT_EQ(reader.remaining(), 16u); |
| EXPECT_EQ(reader.length(), 16u); |
| } |
| |
| TEST(BigEndianWriterTest, ConstructWithValidBuffer) { |
| uint8_t data[64]; |
| BigEndianWriter writer(data, sizeof(data)); |
| |
| EXPECT_EQ(writer.begin(), data); |
| EXPECT_EQ(writer.current(), data); |
| EXPECT_EQ(writer.end(), data + 64u); |
| EXPECT_EQ(writer.offset(), 0u); |
| EXPECT_EQ(writer.remaining(), 64u); |
| EXPECT_EQ(writer.length(), 64u); |
| } |
| |
| TEST(BigEndianWriterTest, SkipLessThanRemaining) { |
| uint8_t data[64]; |
| BigEndianWriter writer(data, sizeof(data)); |
| |
| EXPECT_TRUE(writer.Skip(16)); |
| |
| EXPECT_EQ(writer.begin(), data); |
| EXPECT_EQ(writer.current(), data + 16u); |
| EXPECT_EQ(writer.end(), data + 64); |
| EXPECT_EQ(writer.offset(), 16u); |
| EXPECT_EQ(writer.remaining(), 48u); |
| EXPECT_EQ(writer.length(), 64u); |
| } |
| |
| TEST(BigEndianWriterTest, SkipMoreThanRemaining) { |
| uint8_t data[64]; |
| BigEndianWriter writer(data, sizeof(data)); |
| |
| EXPECT_TRUE(writer.Skip(16)); |
| EXPECT_FALSE(writer.Skip(64)); |
| |
| // Check that failed Skip does not modify any pointers or offsets. |
| EXPECT_EQ(writer.begin(), data); |
| EXPECT_EQ(writer.current(), data + 16u); |
| EXPECT_EQ(writer.end(), data + 64u); |
| EXPECT_EQ(writer.offset(), 16u); |
| EXPECT_EQ(writer.remaining(), 48u); |
| EXPECT_EQ(writer.length(), 64u); |
| } |
| |
| TEST(BigEndianWriterTest, ConstructWithZeroLengthBuffer) { |
| uint8_t data[8]; |
| BigEndianWriter writer(data, 0); |
| |
| EXPECT_EQ(writer.begin(), data); |
| EXPECT_EQ(writer.current(), data); |
| EXPECT_EQ(writer.end(), data); |
| EXPECT_EQ(writer.offset(), 0u); |
| EXPECT_EQ(writer.remaining(), 0u); |
| EXPECT_EQ(writer.length(), 0u); |
| |
| EXPECT_FALSE(writer.Skip(1)); |
| } |
| |
| TEST(BigEndianWriterTest, WriteValues) { |
| uint8_t expected[17] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, |
| 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10}; |
| |
| uint8_t data[17]; |
| memset(data, 0xFF, sizeof(data)); |
| BigEndianWriter writer(data, sizeof(data)); |
| |
| uint8_t buffer[] = {0x0, 0x1}; |
| EXPECT_TRUE(writer.Write(buffer, sizeof(buffer))); |
| EXPECT_TRUE(writer.Write<uint8_t>(UINT8_C(0x2))); |
| EXPECT_TRUE(writer.Write<uint16_t>(UINT16_C(0x0304))); |
| EXPECT_TRUE(writer.Write<uint32_t>(UINT32_C(0x05060708))); |
| EXPECT_TRUE(writer.Write<uint64_t>(UINT64_C(0x090A0B0C0D0E0F10))); |
| EXPECT_THAT(data, testing::ElementsAreArray(expected)); |
| |
| EXPECT_EQ(writer.begin(), data); |
| EXPECT_EQ(writer.current(), data + 17); |
| EXPECT_EQ(writer.end(), data + 17); |
| EXPECT_EQ(writer.offset(), 17u); |
| EXPECT_EQ(writer.remaining(), 0u); |
| EXPECT_EQ(writer.length(), 17u); |
| } |
| |
| TEST(BigEndianWriterTest, RespectLength) { |
| uint8_t data[8]; |
| BigEndianWriter writer(data, sizeof(data)); |
| |
| // 8 left |
| EXPECT_FALSE(writer.Skip(9)); |
| EXPECT_TRUE(writer.Skip(1)); |
| |
| // 7 left |
| EXPECT_FALSE(writer.Write<uint64_t>(0)); |
| EXPECT_TRUE(writer.Skip(4)); |
| |
| // 3 left |
| EXPECT_FALSE(writer.Write<uint32_t>(0)); |
| EXPECT_TRUE(writer.Skip(2)); |
| |
| // 1 left |
| EXPECT_FALSE(writer.Write<uint16_t>(0)); |
| |
| uint8_t buffer[2]; |
| EXPECT_FALSE(writer.Write(buffer, 2)); |
| EXPECT_TRUE(writer.Skip(1)); |
| |
| // 0 left |
| EXPECT_FALSE(writer.Write<uint8_t>(0)); |
| EXPECT_EQ(0u, writer.remaining()); |
| |
| EXPECT_EQ(writer.begin(), data); |
| EXPECT_EQ(writer.current(), data + 8); |
| EXPECT_EQ(writer.end(), data + 8); |
| EXPECT_EQ(writer.offset(), 8u); |
| EXPECT_EQ(writer.remaining(), 0u); |
| EXPECT_EQ(writer.length(), 8u); |
| } |
| |
| } // namespace |
| } // namespace openscreen |