| //===-- DataEncoderTest.cpp -----------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "gtest/gtest.h" |
| |
| #include "lldb/Utility/DataEncoder.h" |
| #include "llvm/ADT/ArrayRef.h" |
| #include <vector> |
| using namespace lldb_private; |
| using namespace llvm; |
| |
| TEST(DataEncoderTest, PutU8) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| offset = encoder.PutU8(offset, 11); |
| ASSERT_EQ(offset, 1U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 2, 3, 4, 5, 6, 7, 8})); |
| offset = encoder.PutU8(offset, 12); |
| ASSERT_EQ(offset, 2U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 3, 4, 5, 6, 7, 8})); |
| offset = encoder.PutU8(offset, 13); |
| ASSERT_EQ(offset, 3U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 4, 5, 6, 7, 8})); |
| offset = encoder.PutU8(offset, 14); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 14, 5, 6, 7, 8})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU8(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 14, 5, 6, 7, 8})); |
| } |
| |
| TEST(DataEncoderTest, AppendUnsignedLittle) { |
| const uint32_t addr_size = 4; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderLittle, addr_size); |
| encoder.AppendU8(0x11); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11})); |
| encoder.AppendU16(0x2233); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x33, 0x22})); |
| encoder.AppendU32(0x44556677); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x33, 0x22, 0x77, 0x66, 0x55, 0x44})); |
| encoder.AppendU64(0x8899AABBCCDDEEFF); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x33, 0x22, 0x77, 0x66, 0x55, 0x44, |
| 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88})); |
| encoder.AppendU64(0x8899AABBCCDDEEFF); |
| } |
| |
| TEST(DataEncoderTest, AppendUnsignedBig) { |
| const uint32_t addr_size = 4; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderBig, addr_size); |
| encoder.AppendU8(0x11); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11})); |
| encoder.AppendU16(0x2233); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x22, 0x33})); |
| encoder.AppendU32(0x44556677); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77})); |
| encoder.AppendU64(0x8899AABBCCDDEEFF); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, |
| 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF})); |
| } |
| |
| TEST(DataEncoderTest, AppendAddress4Little) { |
| const uint32_t addr_size = 4; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderLittle, addr_size); |
| encoder.AppendAddress(0x11223344); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11})); |
| encoder.AppendAddress(0x55); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x55, 0x00, 0x00, 0x00})); |
| } |
| |
| TEST(DataEncoderTest, AppendAddress4Big) { |
| const uint32_t addr_size = 4; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderBig, addr_size); |
| encoder.AppendAddress(0x11223344); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44})); |
| encoder.AppendAddress(0x55); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00, 0x55})); |
| } |
| |
| TEST(DataEncoderTest, AppendAddress8Little) { |
| const uint32_t addr_size = 8; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderLittle, addr_size); |
| encoder.AppendAddress(0x11223344); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| encoder.AppendAddress(0x5566778899AABBCC); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00, |
| 0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55})); |
| } |
| |
| TEST(DataEncoderTest, AppendAddress8Big) { |
| const uint32_t addr_size = 8; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderBig, addr_size); |
| encoder.AppendAddress(0x11223344); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44})); |
| encoder.AppendAddress(0x5566778899AABBCC); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44, |
| 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC})); |
| } |
| |
| TEST(DataEncoderTest, AppendData) { |
| const uint32_t addr_size = 4; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderBig, addr_size); |
| // Make sure default constructed StringRef appends nothing |
| encoder.AppendData(StringRef()); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({})); |
| // Make sure empty StringRef appends nothing |
| encoder.AppendData(StringRef("")); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({})); |
| // Append some bytes that contains a NULL character |
| encoder.AppendData(StringRef("\x11\x00\x22", 3)); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x00, 0x22})); |
| } |
| |
| TEST(DataEncoderTest, AppendCString) { |
| const uint32_t addr_size = 4; |
| std::vector<uint8_t> expected; |
| DataEncoder encoder(lldb::eByteOrderBig, addr_size); |
| // Make sure default constructed StringRef appends nothing |
| encoder.AppendCString(StringRef()); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({})); |
| // Make sure empty StringRef appends a NULL character since the StringRef |
| // doesn't contain a NULL in the referenced string. |
| encoder.AppendCString(StringRef("")); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x00})); |
| // Make sure empty StringRef appends only one NULL character if StringRef |
| // does contain a NULL in the referenced string. |
| encoder.AppendCString(StringRef("\0", 1)); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x00, 0x00})); |
| // Append a string where the StringRef doesn't contain a NULL termination |
| // and verify the NULL terminate gets added |
| encoder.AppendCString(StringRef("hello")); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x00, 0x00, 'h', 'e', 'l', 'l', 'o', 0x00})); |
| // Append a string where the StringRef does contain a NULL termination and |
| // verify only one NULL is added |
| encoder.AppendCString(StringRef("world", 6)); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x00, 0x00, 'h', 'e', 'l', 'l', 'o', 0x00, |
| 'w', 'o', 'r', 'l', 'd', '\0'})); |
| } |
| |
| TEST(DataEncoderTest, PutU16Little) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| offset = encoder.PutU16(offset, 11); |
| ASSERT_EQ(offset, 2U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 3, 4, 5, 6, 7, 8})); |
| offset = encoder.PutU16(offset, 12); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 5, 6, 7, 8})); |
| offset = encoder.PutU16(offset, 13); |
| ASSERT_EQ(offset, 6U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 13, 0, 7, 8})); |
| offset = encoder.PutU16(offset, 14); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 13, 0, 14, 0})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU16(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 13, 0, 14, 0})); |
| } |
| |
| TEST(DataEncoderTest, PutU16Big) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig, |
| addr_size); |
| offset = encoder.PutU16(offset, 11); |
| ASSERT_EQ(offset, 2U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 3, 4, 5, 6, 7, 8})); |
| offset = encoder.PutU16(offset, 12); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 5, 6, 7, 8})); |
| offset = encoder.PutU16(offset, 13); |
| ASSERT_EQ(offset, 6U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 0, 13, 7, 8})); |
| offset = encoder.PutU16(offset, 14); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 0, 13, 0, 14})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU16(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 0, 13, 0, 14})); |
| } |
| |
| TEST(DataEncoderTest, PutU32Little) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| offset = encoder.PutU32(offset, 11); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 5, 6, 7, 8})); |
| offset = encoder.PutU32(offset, 12); |
| ASSERT_EQ(offset, 8u); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 12, 0, 0, 0})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU32(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 12, 0, 0, 0})); |
| } |
| |
| TEST(DataEncoderTest, PutU32Big) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig, |
| addr_size); |
| offset = encoder.PutU32(offset, 11); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 11, 5, 6, 7, 8})); |
| offset = encoder.PutU32(offset, 12); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 11, 0, 0, 0, 12})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU32(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 11, 0, 0, 0, 12})); |
| } |
| |
| TEST(DataEncoderTest, PutU64Little) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| offset = encoder.PutU64(offset, 11); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 0, 0, 0, 0})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU64(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 0, 0, 0, 0})); |
| } |
| |
| TEST(DataEncoderTest, PutU64Big) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig, |
| addr_size); |
| offset = encoder.PutU64(offset, 11); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 0, 0, 0, 0, 11})); |
| // Check that putting a number to an invalid offset doesn't work and returns |
| // an error offset and doesn't modify the buffer. |
| ASSERT_EQ(encoder.PutU64(init.size(), 15), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 0, 0, 0, 0, 11})); |
| } |
| |
| TEST(DataEncoderTest, PutUnsignedLittle) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| // Put only the least significant byte from the uint64_t into the encoder |
| offset = encoder.PutUnsigned(0, 1, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 1U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x88, 2, 3, 4, 5, 6, 7, 8})); |
| |
| // Put only the least significant 2 byte2 from the uint64_t into the encoder |
| offset = encoder.PutUnsigned(0, 2, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 2U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x88, 0x77, 3, 4, 5, 6, 7, 8})); |
| |
| // Put only the least significant 4 bytes from the uint64_t into the encoder |
| offset = encoder.PutUnsigned(0, 4, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x88, 0x77, 0x66, 0x55, 5, 6, 7, 8})); |
| |
| // Put the full uint64_t value into the encoder |
| offset = encoder.PutUnsigned(0, 8, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11})); |
| } |
| |
| TEST(DataEncoderTest, PutUnsignedBig) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| uint32_t offset = 0; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig, |
| addr_size); |
| // Put only the least significant byte from the uint64_t into the encoder |
| offset = encoder.PutUnsigned(0, 1, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 1U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x88, 2, 3, 4, 5, 6, 7, 8})); |
| |
| // Put only the least significant 2 byte2 from the uint64_t into the encoder |
| offset = encoder.PutUnsigned(0, 2, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 2U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x77, 0x88, 3, 4, 5, 6, 7, 8})); |
| |
| // Put only the least significant 4 bytes from the uint64_t into the encoder |
| offset = encoder.PutUnsigned(0, 4, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 4U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x55, 0x66, 0x77, 0x88, 5, 6, 7, 8})); |
| |
| // Put the full uint64_t value into the encoder |
| offset = encoder.PutUnsigned(0, 8, 0x1122334455667788ULL); |
| ASSERT_EQ(offset, 8U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| } |
| |
| TEST(DataEncoderTest, PutData) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| char one_byte[] = {11}; |
| char two_bytes[] = {12, 13}; |
| char to_many_bytes[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| uint32_t offset = 0; |
| // Test putting zero bytes from a invalid array (NULL) |
| offset = encoder.PutData(offset, nullptr, 0); |
| ASSERT_EQ(offset, 0U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>(init)); |
| // Test putting zero bytes from a valid array |
| offset = encoder.PutData(offset, one_byte, 0); |
| ASSERT_EQ(offset, 0U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>(init)); |
| // Test putting one byte from a valid array |
| offset = encoder.PutData(offset, one_byte, sizeof(one_byte)); |
| ASSERT_EQ(offset, 1U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 2, 3, 4, 5, 6, 7, 8})); |
| offset = encoder.PutData(offset, two_bytes, sizeof(two_bytes)); |
| ASSERT_EQ(offset, 3U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 4, 5, 6, 7, 8})); |
| offset = encoder.PutData(0, to_many_bytes, sizeof(to_many_bytes)); |
| ASSERT_EQ(offset, UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 4, 5, 6, 7, 8})); |
| } |
| |
| TEST(DataEncoderTest, PutCString) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| // Test putting invalid string pointer |
| ASSERT_EQ(encoder.PutCString(0, nullptr), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>(init)); |
| // Test putting an empty string |
| uint32_t offset = 0; |
| offset = encoder.PutCString(offset, ""); |
| ASSERT_EQ(offset, 1U); |
| ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({'\0', 2, 3, 4, 5, 6, 7, 8})); |
| // Test putting valid C string |
| offset = encoder.PutCString(offset, "hello"); |
| ASSERT_EQ(offset, 7U); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({'\0', 'h', 'e', 'l', 'l', 'o', '\0', 8})); |
| // Test putting valid C string but where it won't fit in existing data and |
| // make sure data stay unchanged. |
| offset = encoder.PutCString(offset, "world"); |
| ASSERT_EQ(offset, UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({'\0', 'h', 'e', 'l', 'l', 'o', '\0', 8})); |
| } |
| |
| TEST(DataEncoderTest, PutAddressLittle4) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| uint32_t offset = 0; |
| offset = encoder.PutAddress(offset, 0x11223344); |
| ASSERT_EQ(offset, addr_size); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 5, 6, 7, 8})); |
| offset = encoder.PutAddress(offset, 0x55667788); |
| ASSERT_EQ(offset, addr_size*2); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55})); |
| // Make sure we can put an address when it won't fit in the existing buffer |
| // and that the buffer doesn't get modified. |
| ASSERT_EQ(encoder.PutAddress(addr_size+1, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55})); |
| ASSERT_EQ(encoder.PutAddress(addr_size+2, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55})); |
| ASSERT_EQ(encoder.PutAddress(addr_size+3, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55})); |
| ASSERT_EQ(encoder.PutAddress(addr_size+4, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55})); |
| } |
| |
| TEST(DataEncoderTest, PutAddressBig4) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 4; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig, |
| addr_size); |
| uint32_t offset = 0; |
| offset = encoder.PutAddress(offset, 0x11223344); |
| ASSERT_EQ(offset, addr_size); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 5, 6, 7, 8})); |
| offset = encoder.PutAddress(offset, 0x55667788); |
| ASSERT_EQ(offset, addr_size*2); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| // Make sure we can put an address when it won't fit in the existing buffer |
| // and that the buffer doesn't get modified. |
| ASSERT_EQ(encoder.PutAddress(addr_size+1, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(addr_size+2, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(addr_size+3, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(addr_size+4, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| } |
| |
| TEST(DataEncoderTest, PutAddressLittle8) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 8; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle, |
| addr_size); |
| uint32_t offset = 0; |
| offset = encoder.PutAddress(offset, 0x11223344); |
| ASSERT_EQ(offset, addr_size); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| // Make sure we can put an address when it won't fit in the existing buffer |
| // and that the buffer doesn't get modified. |
| ASSERT_EQ(encoder.PutAddress(1, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(2, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(3, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(4, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(5, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(6, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(7, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| ASSERT_EQ(encoder.PutAddress(8, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00})); |
| } |
| |
| TEST(DataEncoderTest, PutAddressBig8) { |
| const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8}; |
| const uint32_t addr_size = 8; |
| DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig, |
| addr_size); |
| uint32_t offset = 0; |
| offset = encoder.PutAddress(offset, 0x1122334455667788); |
| ASSERT_EQ(offset, addr_size); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| // Make sure we can put an address when it won't fit in the existing buffer |
| // and that the buffer doesn't get modified. |
| ASSERT_EQ(encoder.PutAddress(1, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(2, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(3, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(4, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(5, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(6, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(7, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| ASSERT_EQ(encoder.PutAddress(8, 0x10203040), UINT32_MAX); |
| ASSERT_EQ(encoder.GetData(), |
| ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})); |
| } |