chromium/openscreen
0
Fork 0
Code Activity
Files
openscreen/util/big_endian_unittest.cc
mark a. foltz 3192a714bf [Open Screen] Bulk-update license headers. 
The license header presubmit check enforces the new license header
format which removes the string "All Rights Reserved."  Chromium was
updated but not our repo, so doing this now so that unrelated changes
aren't blocked on license headers.

To pass cpplint, this also fixes a number of IWYU issues and also
adds `noexcept` to move operators.

Bug: b/288403513
Change-Id: I90b2e58dcc2bdd1762129c7b5894e3a2730da51b
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/4638621
Commit-Queue: Mark Foltz <mfoltz@chromium.org>
Reviewed-by: Muyao Xu <muyaoxu@google.com>
2023-06-23 05:16:26 +00:00

405 lines
13 KiB
C++
Raw Permalink Blame History

// Copyright 2019 The Chromium Authors
// 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
View Git Blame Copy Permalink