lldb/unittests/Utility/DataEncoderTest.cpp

   1 //===-- DataEncoderTest.cpp -----------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "gtest/gtest.h"
  10
  11 #include "lldb/Utility/DataEncoder.h"
  12 #include "llvm/ADT/ArrayRef.h"
  13 #include <vector>
  14 using namespace lldb_private;
  15 using namespace llvm;
  16
  17 TEST(DataEncoderTest, PutU8) {
  18   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
  19   const uint32_t addr_size = 4;
  20
  21   uint32_t offset = 0;
  22   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
  23                       addr_size);
  24   offset = encoder.PutU8(offset, 11);
  25   ASSERT_EQ(offset, 1U);
  26   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 2, 3, 4, 5, 6, 7, 8}));
  27   offset = encoder.PutU8(offset, 12);
  28   ASSERT_EQ(offset, 2U);
  29   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 3, 4, 5, 6, 7, 8}));
  30   offset = encoder.PutU8(offset, 13);
  31   ASSERT_EQ(offset, 3U);
  32   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 4, 5, 6, 7, 8}));
  33   offset = encoder.PutU8(offset, 14);
  34   ASSERT_EQ(offset, 4U);
  35   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 14, 5, 6, 7, 8}));
  36   // Check that putting a number to an invalid offset doesn't work and returns
  37   // an error offset and doesn't modify the buffer.
  38   ASSERT_EQ(encoder.PutU8(init.size(), 15), UINT32_MAX);
  39   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 14, 5, 6, 7, 8}));
  40 }
  41
  42 TEST(DataEncoderTest, AppendUnsignedLittle) {
  43   const uint32_t addr_size = 4;
  44   std::vector<uint8_t> expected;
  45   DataEncoder encoder(lldb::eByteOrderLittle, addr_size);
  46   encoder.AppendU8(0x11);
  47   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11}));
  48   encoder.AppendU16(0x2233);
  49   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x33, 0x22}));
  50   encoder.AppendU32(0x44556677);
  51   ASSERT_EQ(encoder.GetData(),
  52             ArrayRef<uint8_t>({0x11, 0x33, 0x22, 0x77, 0x66, 0x55, 0x44}));
  53   encoder.AppendU64(0x8899AABBCCDDEEFF);
  54   ASSERT_EQ(encoder.GetData(),
  55             ArrayRef<uint8_t>({0x11, 0x33, 0x22, 0x77, 0x66, 0x55, 0x44,
  56                                0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88}));
  57   encoder.AppendU64(0x8899AABBCCDDEEFF);
  58 }
  59
  60 TEST(DataEncoderTest, AppendUnsignedBig) {
  61   const uint32_t addr_size = 4;
  62   std::vector<uint8_t> expected;
  63   DataEncoder encoder(lldb::eByteOrderBig, addr_size);
  64   encoder.AppendU8(0x11);
  65   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11}));
  66   encoder.AppendU16(0x2233);
  67   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x22, 0x33}));
  68   encoder.AppendU32(0x44556677);
  69   ASSERT_EQ(encoder.GetData(),
  70             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}));
  71   encoder.AppendU64(0x8899AABBCCDDEEFF);
  72   ASSERT_EQ(encoder.GetData(),
  73             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
  74                                0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}));
  75 }
  76
  77 TEST(DataEncoderTest, AppendAddress4Little) {
  78   const uint32_t addr_size = 4;
  79   std::vector<uint8_t> expected;
  80   DataEncoder encoder(lldb::eByteOrderLittle, addr_size);
  81   encoder.AppendAddress(0x11223344);
  82   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11}));
  83   encoder.AppendAddress(0x55);
  84   ASSERT_EQ(encoder.GetData(),
  85             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x55, 0x00, 0x00, 0x00}));
  86 }
  87
  88 TEST(DataEncoderTest, AppendAddress4Big) {
  89   const uint32_t addr_size = 4;
  90   std::vector<uint8_t> expected;
  91   DataEncoder encoder(lldb::eByteOrderBig, addr_size);
  92   encoder.AppendAddress(0x11223344);
  93   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44}));
  94   encoder.AppendAddress(0x55);
  95   ASSERT_EQ(encoder.GetData(),
  96             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00, 0x55}));
  97 }
  98
  99 TEST(DataEncoderTest, AppendAddress8Little) {
 100   const uint32_t addr_size = 8;
 101   std::vector<uint8_t> expected;
 102   DataEncoder encoder(lldb::eByteOrderLittle, addr_size);
 103   encoder.AppendAddress(0x11223344);
 104   ASSERT_EQ(encoder.GetData(),
 105             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 106   encoder.AppendAddress(0x5566778899AABBCC);
 107   ASSERT_EQ(encoder.GetData(),
 108             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00,
 109                                0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55}));
 110 }
 111
 112 TEST(DataEncoderTest, AppendAddress8Big) {
 113   const uint32_t addr_size = 8;
 114   std::vector<uint8_t> expected;
 115   DataEncoder encoder(lldb::eByteOrderBig, addr_size);
 116   encoder.AppendAddress(0x11223344);
 117   ASSERT_EQ(encoder.GetData(),
 118             ArrayRef<uint8_t>({0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44}));
 119   encoder.AppendAddress(0x5566778899AABBCC);
 120   ASSERT_EQ(encoder.GetData(),
 121             ArrayRef<uint8_t>({0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44,
 122                                0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC}));
 123 }
 124
 125 TEST(DataEncoderTest, AppendData) {
 126   const uint32_t addr_size = 4;
 127   std::vector<uint8_t> expected;
 128   DataEncoder encoder(lldb::eByteOrderBig, addr_size);
 129   // Make sure default constructed StringRef appends nothing
 130   encoder.AppendData(StringRef());
 131   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({}));
 132   // Make sure empty StringRef appends nothing
 133   encoder.AppendData(StringRef(""));
 134   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({}));
 135   // Append some bytes that contains a NULL character
 136   encoder.AppendData(StringRef("\x11\x00\x22", 3));
 137   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x11, 0x00, 0x22}));
 138 }
 139
 140 TEST(DataEncoderTest, AppendCString) {
 141   const uint32_t addr_size = 4;
 142   std::vector<uint8_t> expected;
 143   DataEncoder encoder(lldb::eByteOrderBig, addr_size);
 144   // Make sure default constructed StringRef appends nothing
 145   encoder.AppendCString(StringRef());
 146   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({}));
 147   // Make sure empty StringRef appends a NULL character since the StringRef
 148   // doesn't contain a NULL in the referenced string.
 149   encoder.AppendCString(StringRef(""));
 150   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x00}));
 151   // Make sure empty StringRef appends only one NULL character if StringRef
 152   // does contain a NULL in the referenced string.
 153   encoder.AppendCString(StringRef("\0", 1));
 154   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x00, 0x00}));
 155   // Append a string where the StringRef doesn't contain a NULL termination
 156   // and verify the NULL terminate gets added
 157   encoder.AppendCString(StringRef("hello"));
 158   ASSERT_EQ(encoder.GetData(),
 159             ArrayRef<uint8_t>({0x00, 0x00, 'h', 'e', 'l', 'l', 'o', 0x00}));
 160   // Append a string where the StringRef does contain a NULL termination and
 161   // verify only one NULL is added
 162   encoder.AppendCString(StringRef("world", 6));
 163   ASSERT_EQ(encoder.GetData(),
 164             ArrayRef<uint8_t>({0x00, 0x00, 'h', 'e', 'l', 'l', 'o', 0x00,
 165                                'w', 'o', 'r', 'l', 'd', '\0'}));
 166 }
 167
 168 TEST(DataEncoderTest, PutU16Little) {
 169   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 170   const uint32_t addr_size = 4;
 171   uint32_t offset = 0;
 172   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 173                       addr_size);
 174   offset = encoder.PutU16(offset, 11);
 175   ASSERT_EQ(offset, 2U);
 176   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 3, 4, 5, 6, 7, 8}));
 177   offset = encoder.PutU16(offset, 12);
 178   ASSERT_EQ(offset, 4U);
 179   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 5, 6, 7, 8}));
 180   offset = encoder.PutU16(offset, 13);
 181   ASSERT_EQ(offset, 6U);
 182   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 13, 0, 7, 8}));
 183   offset = encoder.PutU16(offset, 14);
 184   ASSERT_EQ(offset, 8U);
 185   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 13, 0, 14, 0}));
 186   // Check that putting a number to an invalid offset doesn't work and returns
 187   // an error offset and doesn't modify the buffer.
 188   ASSERT_EQ(encoder.PutU16(init.size(), 15), UINT32_MAX);
 189   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 12, 0, 13, 0, 14, 0}));
 190 }
 191
 192 TEST(DataEncoderTest, PutU16Big) {
 193   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 194   const uint32_t addr_size = 4;
 195   uint32_t offset = 0;
 196   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig,
 197                       addr_size);
 198   offset = encoder.PutU16(offset, 11);
 199   ASSERT_EQ(offset, 2U);
 200   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 3, 4, 5, 6, 7, 8}));
 201   offset = encoder.PutU16(offset, 12);
 202   ASSERT_EQ(offset, 4U);
 203   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 5, 6, 7, 8}));
 204   offset = encoder.PutU16(offset, 13);
 205   ASSERT_EQ(offset, 6U);
 206   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 0, 13, 7, 8}));
 207   offset = encoder.PutU16(offset, 14);
 208   ASSERT_EQ(offset, 8U);
 209   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 0, 13, 0, 14}));
 210   // Check that putting a number to an invalid offset doesn't work and returns
 211   // an error offset and doesn't modify the buffer.
 212   ASSERT_EQ(encoder.PutU16(init.size(), 15), UINT32_MAX);
 213   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 11, 0, 12, 0, 13, 0, 14}));
 214 }
 215
 216 TEST(DataEncoderTest, PutU32Little) {
 217   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 218   const uint32_t addr_size = 4;
 219
 220   uint32_t offset = 0;
 221   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 222                       addr_size);
 223   offset = encoder.PutU32(offset, 11);
 224   ASSERT_EQ(offset, 4U);
 225   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 5, 6, 7, 8}));
 226   offset = encoder.PutU32(offset, 12);
 227   ASSERT_EQ(offset, 8u);
 228   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 12, 0, 0, 0}));
 229   // Check that putting a number to an invalid offset doesn't work and returns
 230   // an error offset and doesn't modify the buffer.
 231   ASSERT_EQ(encoder.PutU32(init.size(), 15), UINT32_MAX);
 232   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 12, 0, 0, 0}));
 233 }
 234
 235 TEST(DataEncoderTest, PutU32Big) {
 236   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 237   const uint32_t addr_size = 4;
 238
 239   uint32_t offset = 0;
 240   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig,
 241                       addr_size);
 242   offset = encoder.PutU32(offset, 11);
 243   ASSERT_EQ(offset, 4U);
 244   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 11, 5, 6, 7, 8}));
 245   offset = encoder.PutU32(offset, 12);
 246   ASSERT_EQ(offset, 8U);
 247   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 11, 0, 0, 0, 12}));
 248   // Check that putting a number to an invalid offset doesn't work and returns
 249   // an error offset and doesn't modify the buffer.
 250   ASSERT_EQ(encoder.PutU32(init.size(), 15), UINT32_MAX);
 251   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 11, 0, 0, 0, 12}));
 252 }
 253
 254 TEST(DataEncoderTest, PutU64Little) {
 255   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 256   const uint32_t addr_size = 4;
 257   uint32_t offset = 0;
 258   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 259                       addr_size);
 260   offset = encoder.PutU64(offset, 11);
 261   ASSERT_EQ(offset, 8U);
 262   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 0, 0, 0, 0}));
 263   // Check that putting a number to an invalid offset doesn't work and returns
 264   // an error offset and doesn't modify the buffer.
 265   ASSERT_EQ(encoder.PutU64(init.size(), 15), UINT32_MAX);
 266   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 0, 0, 0, 0, 0, 0, 0}));
 267 }
 268
 269 TEST(DataEncoderTest, PutU64Big) {
 270   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 271   const uint32_t addr_size = 4;
 272   uint32_t offset = 0;
 273   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig,
 274                       addr_size);
 275   offset = encoder.PutU64(offset, 11);
 276   ASSERT_EQ(offset, 8U);
 277   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 0, 0, 0, 0, 11}));
 278   // Check that putting a number to an invalid offset doesn't work and returns
 279   // an error offset and doesn't modify the buffer.
 280   ASSERT_EQ(encoder.PutU64(init.size(), 15), UINT32_MAX);
 281   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0, 0, 0, 0, 0, 0, 0, 11}));
 282 }
 283
 284 TEST(DataEncoderTest, PutUnsignedLittle) {
 285   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 286   const uint32_t addr_size = 4;
 287   uint32_t offset = 0;
 288   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 289                       addr_size);
 290   // Put only the least significant byte from the uint64_t into the encoder
 291   offset = encoder.PutUnsigned(0, 1, 0x1122334455667788ULL);
 292   ASSERT_EQ(offset, 1U);
 293   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({0x88, 2, 3, 4, 5, 6, 7, 8}));
 294
 295   // Put only the least significant 2 byte2 from the uint64_t into the encoder
 296   offset = encoder.PutUnsigned(0, 2, 0x1122334455667788ULL);
 297   ASSERT_EQ(offset, 2U);
 298   ASSERT_EQ(encoder.GetData(),
 299             ArrayRef<uint8_t>({0x88, 0x77, 3, 4, 5, 6, 7, 8}));
 300
 301   // Put only the least significant 4 bytes from the uint64_t into the encoder
 302   offset = encoder.PutUnsigned(0, 4, 0x1122334455667788ULL);
 303   ASSERT_EQ(offset, 4U);
 304   ASSERT_EQ(encoder.GetData(),
 305             ArrayRef<uint8_t>({0x88, 0x77, 0x66, 0x55, 5, 6, 7, 8}));
 306
 307   // Put the full uint64_t value into the encoder
 308   offset = encoder.PutUnsigned(0, 8, 0x1122334455667788ULL);
 309   ASSERT_EQ(offset, 8U);
 310   ASSERT_EQ(encoder.GetData(),
 311             ArrayRef<uint8_t>({0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11}));
 312 }
 313
 314 TEST(DataEncoderTest, PutUnsignedBig) {
 315   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 316   const uint32_t addr_size = 4;
 317   uint32_t offset = 0;
 318   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig,
 319                       addr_size);
 320   // Put only the least significant byte from the uint64_t into the encoder
 321   offset = encoder.PutUnsigned(0, 1, 0x1122334455667788ULL);
 322   ASSERT_EQ(offset, 1U);
 323   ASSERT_EQ(encoder.GetData(),
 324             ArrayRef<uint8_t>({0x88, 2, 3, 4, 5, 6, 7, 8}));
 325
 326   // Put only the least significant 2 byte2 from the uint64_t into the encoder
 327   offset = encoder.PutUnsigned(0, 2, 0x1122334455667788ULL);
 328   ASSERT_EQ(offset, 2U);
 329   ASSERT_EQ(encoder.GetData(),
 330             ArrayRef<uint8_t>({0x77, 0x88, 3, 4, 5, 6, 7, 8}));
 331
 332   // Put only the least significant 4 bytes from the uint64_t into the encoder
 333   offset = encoder.PutUnsigned(0, 4, 0x1122334455667788ULL);
 334   ASSERT_EQ(offset, 4U);
 335   ASSERT_EQ(encoder.GetData(),
 336             ArrayRef<uint8_t>({0x55, 0x66, 0x77, 0x88, 5, 6, 7, 8}));
 337
 338   // Put the full uint64_t value into the encoder
 339   offset = encoder.PutUnsigned(0, 8, 0x1122334455667788ULL);
 340   ASSERT_EQ(offset, 8U);
 341   ASSERT_EQ(encoder.GetData(),
 342             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 343 }
 344
 345 TEST(DataEncoderTest, PutData) {
 346   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 347   const uint32_t addr_size = 4;
 348   char one_byte[] = {11};
 349   char two_bytes[] = {12, 13};
 350   char to_many_bytes[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 351   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 352                       addr_size);
 353   uint32_t offset = 0;
 354   // Test putting zero bytes from a invalid array (NULL)
 355   offset = encoder.PutData(offset, nullptr, 0);
 356   ASSERT_EQ(offset, 0U);
 357   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>(init));
 358   // Test putting zero bytes from a valid array
 359   offset = encoder.PutData(offset, one_byte, 0);
 360   ASSERT_EQ(offset, 0U);
 361   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>(init));
 362   // Test putting one byte from a valid array
 363   offset = encoder.PutData(offset, one_byte, sizeof(one_byte));
 364   ASSERT_EQ(offset, 1U);
 365   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 2, 3, 4, 5, 6, 7, 8}));
 366   offset = encoder.PutData(offset, two_bytes, sizeof(two_bytes));
 367   ASSERT_EQ(offset, 3U);
 368   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 4, 5, 6, 7, 8}));
 369   offset = encoder.PutData(0, to_many_bytes, sizeof(to_many_bytes));
 370   ASSERT_EQ(offset, UINT32_MAX);
 371   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({11, 12, 13, 4, 5, 6, 7, 8}));
 372 }
 373
 374 TEST(DataEncoderTest, PutCString) {
 375   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 376   const uint32_t addr_size = 4;
 377   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 378                       addr_size);
 379   // Test putting invalid string pointer
 380   ASSERT_EQ(encoder.PutCString(0, nullptr), UINT32_MAX);
 381   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>(init));
 382   // Test putting an empty string
 383   uint32_t offset = 0;
 384   offset = encoder.PutCString(offset, "");
 385   ASSERT_EQ(offset, 1U);
 386   ASSERT_EQ(encoder.GetData(), ArrayRef<uint8_t>({'\0', 2, 3, 4, 5, 6, 7, 8}));
 387   // Test putting valid C string
 388   offset = encoder.PutCString(offset, "hello");
 389   ASSERT_EQ(offset, 7U);
 390   ASSERT_EQ(encoder.GetData(),
 391             ArrayRef<uint8_t>({'\0', 'h', 'e', 'l', 'l', 'o', '\0', 8}));
 392   // Test putting valid C string but where it won't fit in existing data and
 393   // make sure data stay unchanged.
 394   offset = encoder.PutCString(offset, "world");
 395   ASSERT_EQ(offset, UINT32_MAX);
 396   ASSERT_EQ(encoder.GetData(),
 397             ArrayRef<uint8_t>({'\0', 'h', 'e', 'l', 'l', 'o', '\0', 8}));
 398 }
 399
 400 TEST(DataEncoderTest, PutAddressLittle4) {
 401   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 402   const uint32_t addr_size = 4;
 403   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 404                       addr_size);
 405   uint32_t offset = 0;
 406   offset = encoder.PutAddress(offset, 0x11223344);
 407   ASSERT_EQ(offset, addr_size);
 408   ASSERT_EQ(encoder.GetData(),
 409             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 5, 6, 7, 8}));
 410   offset = encoder.PutAddress(offset, 0x55667788);
 411   ASSERT_EQ(offset, addr_size*2);
 412   ASSERT_EQ(encoder.GetData(),
 413             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55}));
 414   // Make sure we can put an address when it won't fit in the existing buffer
 415   // and that the buffer doesn't get modified.
 416   ASSERT_EQ(encoder.PutAddress(addr_size+1, 0x10203040), UINT32_MAX);
 417   ASSERT_EQ(encoder.GetData(),
 418             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55}));
 419   ASSERT_EQ(encoder.PutAddress(addr_size+2, 0x10203040), UINT32_MAX);
 420   ASSERT_EQ(encoder.GetData(),
 421             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55}));
 422   ASSERT_EQ(encoder.PutAddress(addr_size+3, 0x10203040), UINT32_MAX);
 423   ASSERT_EQ(encoder.GetData(),
 424             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55}));
 425   ASSERT_EQ(encoder.PutAddress(addr_size+4, 0x10203040), UINT32_MAX);
 426   ASSERT_EQ(encoder.GetData(),
 427             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55}));
 428 }
 429
 430 TEST(DataEncoderTest, PutAddressBig4) {
 431   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 432   const uint32_t addr_size = 4;
 433   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig,
 434                       addr_size);
 435   uint32_t offset = 0;
 436   offset = encoder.PutAddress(offset, 0x11223344);
 437   ASSERT_EQ(offset, addr_size);
 438   ASSERT_EQ(encoder.GetData(),
 439             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 5, 6, 7, 8}));
 440   offset = encoder.PutAddress(offset, 0x55667788);
 441   ASSERT_EQ(offset, addr_size*2);
 442   ASSERT_EQ(encoder.GetData(),
 443             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 444   // Make sure we can put an address when it won't fit in the existing buffer
 445   // and that the buffer doesn't get modified.
 446   ASSERT_EQ(encoder.PutAddress(addr_size+1, 0x10203040), UINT32_MAX);
 447   ASSERT_EQ(encoder.GetData(),
 448             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 449   ASSERT_EQ(encoder.PutAddress(addr_size+2, 0x10203040), UINT32_MAX);
 450   ASSERT_EQ(encoder.GetData(),
 451             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 452   ASSERT_EQ(encoder.PutAddress(addr_size+3, 0x10203040), UINT32_MAX);
 453   ASSERT_EQ(encoder.GetData(),
 454             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 455   ASSERT_EQ(encoder.PutAddress(addr_size+4, 0x10203040), UINT32_MAX);
 456   ASSERT_EQ(encoder.GetData(),
 457             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 458 }
 459
 460 TEST(DataEncoderTest, PutAddressLittle8) {
 461   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 462   const uint32_t addr_size = 8;
 463   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderLittle,
 464                       addr_size);
 465   uint32_t offset = 0;
 466   offset = encoder.PutAddress(offset, 0x11223344);
 467   ASSERT_EQ(offset, addr_size);
 468   ASSERT_EQ(encoder.GetData(),
 469             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 470   // Make sure we can put an address when it won't fit in the existing buffer
 471   // and that the buffer doesn't get modified.
 472   ASSERT_EQ(encoder.PutAddress(1, 0x10203040), UINT32_MAX);
 473   ASSERT_EQ(encoder.GetData(),
 474             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 475   ASSERT_EQ(encoder.PutAddress(2, 0x10203040), UINT32_MAX);
 476   ASSERT_EQ(encoder.GetData(),
 477             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 478   ASSERT_EQ(encoder.PutAddress(3, 0x10203040), UINT32_MAX);
 479   ASSERT_EQ(encoder.GetData(),
 480             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 481   ASSERT_EQ(encoder.PutAddress(4, 0x10203040), UINT32_MAX);
 482   ASSERT_EQ(encoder.GetData(),
 483             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 484   ASSERT_EQ(encoder.PutAddress(5, 0x10203040), UINT32_MAX);
 485   ASSERT_EQ(encoder.GetData(),
 486             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 487   ASSERT_EQ(encoder.PutAddress(6, 0x10203040), UINT32_MAX);
 488   ASSERT_EQ(encoder.GetData(),
 489             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 490   ASSERT_EQ(encoder.PutAddress(7, 0x10203040), UINT32_MAX);
 491   ASSERT_EQ(encoder.GetData(),
 492             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 493   ASSERT_EQ(encoder.PutAddress(8, 0x10203040), UINT32_MAX);
 494   ASSERT_EQ(encoder.GetData(),
 495             ArrayRef<uint8_t>({0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00}));
 496 }
 497
 498 TEST(DataEncoderTest, PutAddressBig8) {
 499   const std::vector<uint8_t> init = {1, 2, 3, 4, 5, 6, 7, 8};
 500   const uint32_t addr_size = 8;
 501   DataEncoder encoder(init.data(), init.size(), lldb::eByteOrderBig,
 502                       addr_size);
 503   uint32_t offset = 0;
 504   offset = encoder.PutAddress(offset, 0x1122334455667788);
 505   ASSERT_EQ(offset, addr_size);
 506   ASSERT_EQ(encoder.GetData(),
 507             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 508   // Make sure we can put an address when it won't fit in the existing buffer
 509   // and that the buffer doesn't get modified.
 510   ASSERT_EQ(encoder.PutAddress(1, 0x10203040), UINT32_MAX);
 511   ASSERT_EQ(encoder.GetData(),
 512             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 513   ASSERT_EQ(encoder.PutAddress(2, 0x10203040), UINT32_MAX);
 514   ASSERT_EQ(encoder.GetData(),
 515             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 516   ASSERT_EQ(encoder.PutAddress(3, 0x10203040), UINT32_MAX);
 517   ASSERT_EQ(encoder.GetData(),
 518             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 519   ASSERT_EQ(encoder.PutAddress(4, 0x10203040), UINT32_MAX);
 520   ASSERT_EQ(encoder.GetData(),
 521             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 522   ASSERT_EQ(encoder.PutAddress(5, 0x10203040), UINT32_MAX);
 523   ASSERT_EQ(encoder.GetData(),
 524             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 525   ASSERT_EQ(encoder.PutAddress(6, 0x10203040), UINT32_MAX);
 526   ASSERT_EQ(encoder.GetData(),
 527             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 528   ASSERT_EQ(encoder.PutAddress(7, 0x10203040), UINT32_MAX);
 529   ASSERT_EQ(encoder.GetData(),
 530             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 531   ASSERT_EQ(encoder.PutAddress(8, 0x10203040), UINT32_MAX);
 532   ASSERT_EQ(encoder.GetData(),
 533             ArrayRef<uint8_t>({0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}));
 534 }