lldb/unittests/Utility/StringExtractorTest.cpp

   1 #include "gtest/gtest.h"
   2 #include <limits.h>
   3
   4 #include "lldb/Utility/StringExtractor.h"
   5
   6 namespace {
   7 class StringExtractorTest : public ::testing::Test {};
   8 } // namespace
   9
  10 TEST_F(StringExtractorTest, InitEmpty) {
  11   llvm::StringRef kEmptyString = "";
  12   StringExtractor ex(kEmptyString);
  13
  14   ASSERT_EQ(true, ex.IsGood());
  15   ASSERT_EQ(0u, ex.GetFilePos());
  16   ASSERT_EQ(kEmptyString, ex.GetStringRef());
  17   ASSERT_EQ(true, ex.Empty());
  18   ASSERT_EQ(0u, ex.GetBytesLeft());
  19   ASSERT_EQ(nullptr, ex.Peek());
  20 }
  21
  22 TEST_F(StringExtractorTest, InitMisc) {
  23   llvm::StringRef kInitMiscString = "Hello, StringExtractor!";
  24   StringExtractor ex(kInitMiscString);
  25
  26   ASSERT_EQ(true, ex.IsGood());
  27   ASSERT_EQ(0u, ex.GetFilePos());
  28   ASSERT_EQ(kInitMiscString, ex.GetStringRef());
  29   ASSERT_EQ(false, ex.Empty());
  30   ASSERT_EQ(kInitMiscString.size(), ex.GetBytesLeft());
  31   ASSERT_EQ(kInitMiscString[0], *ex.Peek());
  32 }
  33
  34 TEST_F(StringExtractorTest, DecodeHexU8_Underflow) {
  35   llvm::StringRef kEmptyString = "";
  36   StringExtractor ex(kEmptyString);
  37
  38   ASSERT_EQ(-1, ex.DecodeHexU8());
  39   ASSERT_EQ(true, ex.IsGood());
  40   ASSERT_EQ(0u, ex.GetFilePos());
  41   ASSERT_EQ(true, ex.Empty());
  42   ASSERT_EQ(0u, ex.GetBytesLeft());
  43   ASSERT_EQ(nullptr, ex.Peek());
  44 }
  45
  46 TEST_F(StringExtractorTest, DecodeHexU8_Underflow2) {
  47   StringExtractor ex("1");
  48
  49   ASSERT_EQ(-1, ex.DecodeHexU8());
  50   ASSERT_EQ(true, ex.IsGood());
  51   ASSERT_EQ(0u, ex.GetFilePos());
  52   ASSERT_EQ(1u, ex.GetBytesLeft());
  53   ASSERT_EQ('1', *ex.Peek());
  54 }
  55
  56 TEST_F(StringExtractorTest, DecodeHexU8_InvalidHex) {
  57   llvm::StringRef kInvalidHex = "xa";
  58   StringExtractor ex(kInvalidHex);
  59
  60   ASSERT_EQ(-1, ex.DecodeHexU8());
  61   ASSERT_EQ(true, ex.IsGood());
  62   ASSERT_EQ(0u, ex.GetFilePos());
  63   ASSERT_EQ(2u, ex.GetBytesLeft());
  64   ASSERT_EQ('x', *ex.Peek());
  65 }
  66
  67 TEST_F(StringExtractorTest, DecodeHexU8_InvalidHex2) {
  68   llvm::StringRef kInvalidHex = "ax";
  69   StringExtractor ex(kInvalidHex);
  70
  71   ASSERT_EQ(-1, ex.DecodeHexU8());
  72   ASSERT_EQ(true, ex.IsGood());
  73   ASSERT_EQ(0u, ex.GetFilePos());
  74   ASSERT_EQ(2u, ex.GetBytesLeft());
  75   ASSERT_EQ('a', *ex.Peek());
  76 }
  77
  78 TEST_F(StringExtractorTest, DecodeHexU8_Exact) {
  79   llvm::StringRef kValidHexPair = "12";
  80   StringExtractor ex(kValidHexPair);
  81
  82   ASSERT_EQ(0x12, ex.DecodeHexU8());
  83   ASSERT_EQ(true, ex.IsGood());
  84   ASSERT_EQ(2u, ex.GetFilePos());
  85   ASSERT_EQ(0u, ex.GetBytesLeft());
  86   ASSERT_EQ(nullptr, ex.Peek());
  87 }
  88
  89 TEST_F(StringExtractorTest, DecodeHexU8_Extra) {
  90   llvm::StringRef kValidHexPair = "1234";
  91   StringExtractor ex(kValidHexPair);
  92
  93   ASSERT_EQ(0x12, ex.DecodeHexU8());
  94   ASSERT_EQ(true, ex.IsGood());
  95   ASSERT_EQ(2u, ex.GetFilePos());
  96   ASSERT_EQ(2u, ex.GetBytesLeft());
  97   ASSERT_EQ('3', *ex.Peek());
  98 }
  99
 100 TEST_F(StringExtractorTest, GetHexU8_Underflow) {
 101   llvm::StringRef kEmptyString = "";
 102   StringExtractor ex(kEmptyString);
 103
 104   ASSERT_EQ(0xab, ex.GetHexU8(0xab));
 105   ASSERT_EQ(false, ex.IsGood());
 106   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
 107   ASSERT_EQ(true, ex.Empty());
 108   ASSERT_EQ(0u, ex.GetBytesLeft());
 109   ASSERT_EQ(nullptr, ex.Peek());
 110 }
 111
 112 TEST_F(StringExtractorTest, GetHexU8_Underflow2) {
 113   llvm::StringRef kOneNibble = "1";
 114   StringExtractor ex(kOneNibble);
 115
 116   ASSERT_EQ(0xbc, ex.GetHexU8(0xbc));
 117   ASSERT_EQ(false, ex.IsGood());
 118   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
 119   ASSERT_EQ(0u, ex.GetBytesLeft());
 120   ASSERT_EQ(nullptr, ex.Peek());
 121 }
 122
 123 TEST_F(StringExtractorTest, GetHexU8_InvalidHex) {
 124   llvm::StringRef kInvalidHex = "xx";
 125   StringExtractor ex(kInvalidHex);
 126
 127   ASSERT_EQ(0xcd, ex.GetHexU8(0xcd));
 128   ASSERT_EQ(false, ex.IsGood());
 129   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
 130   ASSERT_EQ(0u, ex.GetBytesLeft());
 131   ASSERT_EQ(nullptr, ex.Peek());
 132 }
 133
 134 TEST_F(StringExtractorTest, GetHexU8_Exact) {
 135   llvm::StringRef kValidHexPair = "12";
 136   StringExtractor ex(kValidHexPair);
 137
 138   ASSERT_EQ(0x12, ex.GetHexU8(0x12));
 139   ASSERT_EQ(true, ex.IsGood());
 140   ASSERT_EQ(2u, ex.GetFilePos());
 141   ASSERT_EQ(0u, ex.GetBytesLeft());
 142   ASSERT_EQ(nullptr, ex.Peek());
 143 }
 144
 145 TEST_F(StringExtractorTest, GetHexU8_Extra) {
 146   llvm::StringRef kValidHexPair = "1234";
 147   StringExtractor ex(kValidHexPair);
 148
 149   ASSERT_EQ(0x12, ex.GetHexU8(0x12));
 150   ASSERT_EQ(true, ex.IsGood());
 151   ASSERT_EQ(2u, ex.GetFilePos());
 152   ASSERT_EQ(2u, ex.GetBytesLeft());
 153   ASSERT_EQ('3', *ex.Peek());
 154 }
 155
 156 TEST_F(StringExtractorTest, GetHexU8_Underflow_NoEof) {
 157   llvm::StringRef kEmptyString = "";
 158   StringExtractor ex(kEmptyString);
 159   const bool kSetEofOnFail = false;
 160
 161   ASSERT_EQ(0xab, ex.GetHexU8(0xab, kSetEofOnFail));
 162   ASSERT_EQ(false, ex.IsGood()); // this result seems inconsistent with
 163                                  // kSetEofOnFail == false
 164   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
 165   ASSERT_EQ(true, ex.Empty());
 166   ASSERT_EQ(0u, ex.GetBytesLeft());
 167   ASSERT_EQ(nullptr, ex.Peek());
 168 }
 169
 170 TEST_F(StringExtractorTest, GetHexU8_Underflow2_NoEof) {
 171   llvm::StringRef kOneNibble = "1";
 172   StringExtractor ex(kOneNibble);
 173   const bool kSetEofOnFail = false;
 174
 175   ASSERT_EQ(0xbc, ex.GetHexU8(0xbc, kSetEofOnFail));
 176   ASSERT_EQ(true, ex.IsGood());
 177   ASSERT_EQ(0u, ex.GetFilePos());
 178   ASSERT_EQ(1u, ex.GetBytesLeft());
 179   ASSERT_EQ('1', *ex.Peek());
 180 }
 181
 182 TEST_F(StringExtractorTest, GetHexU8_InvalidHex_NoEof) {
 183   llvm::StringRef kInvalidHex = "xx";
 184   StringExtractor ex(kInvalidHex);
 185   const bool kSetEofOnFail = false;
 186
 187   ASSERT_EQ(0xcd, ex.GetHexU8(0xcd, kSetEofOnFail));
 188   ASSERT_EQ(true, ex.IsGood());
 189   ASSERT_EQ(0u, ex.GetFilePos());
 190   ASSERT_EQ(2u, ex.GetBytesLeft());
 191   ASSERT_EQ('x', *ex.Peek());
 192 }
 193
 194 TEST_F(StringExtractorTest, GetHexU8_Exact_NoEof) {
 195   llvm::StringRef kValidHexPair = "12";
 196   StringExtractor ex(kValidHexPair);
 197   const bool kSetEofOnFail = false;
 198
 199   ASSERT_EQ(0x12, ex.GetHexU8(0x12, kSetEofOnFail));
 200   ASSERT_EQ(true, ex.IsGood());
 201   ASSERT_EQ(2u, ex.GetFilePos());
 202   ASSERT_EQ(0u, ex.GetBytesLeft());
 203   ASSERT_EQ(nullptr, ex.Peek());
 204 }
 205
 206 TEST_F(StringExtractorTest, GetHexU8_Extra_NoEof) {
 207   llvm::StringRef kValidHexPair = "1234";
 208   StringExtractor ex(kValidHexPair);
 209   const bool kSetEofOnFail = false;
 210
 211   ASSERT_EQ(0x12, ex.GetHexU8(0x12, kSetEofOnFail));
 212   ASSERT_EQ(true, ex.IsGood());
 213   ASSERT_EQ(2u, ex.GetFilePos());
 214   ASSERT_EQ(2u, ex.GetBytesLeft());
 215   ASSERT_EQ('3', *ex.Peek());
 216 }
 217
 218 TEST_F(StringExtractorTest, GetHexBytes) {
 219   llvm::StringRef kHexEncodedBytes = "abcdef0123456789xyzw";
 220   const size_t kValidHexPairs = 8;
 221   StringExtractor ex(kHexEncodedBytes);
 222
 223   uint8_t dst[kValidHexPairs];
 224   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
 225   EXPECT_EQ(0xab, dst[0]);
 226   EXPECT_EQ(0xcd, dst[1]);
 227   EXPECT_EQ(0xef, dst[2]);
 228   EXPECT_EQ(0x01, dst[3]);
 229   EXPECT_EQ(0x23, dst[4]);
 230   EXPECT_EQ(0x45, dst[5]);
 231   EXPECT_EQ(0x67, dst[6]);
 232   EXPECT_EQ(0x89, dst[7]);
 233
 234   ASSERT_EQ(true, ex.IsGood());
 235   ASSERT_EQ(2 * kValidHexPairs, ex.GetFilePos());
 236   ASSERT_EQ(false, ex.Empty());
 237   ASSERT_EQ(4u, ex.GetBytesLeft());
 238   ASSERT_EQ('x', *ex.Peek());
 239 }
 240
 241 TEST_F(StringExtractorTest, GetHexBytes_FullString) {
 242   llvm::StringRef kHexEncodedBytes = "abcdef0123456789";
 243   const size_t kValidHexPairs = 8;
 244   StringExtractor ex(kHexEncodedBytes);
 245
 246   uint8_t dst[kValidHexPairs];
 247   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
 248   EXPECT_EQ(0xab, dst[0]);
 249   EXPECT_EQ(0xcd, dst[1]);
 250   EXPECT_EQ(0xef, dst[2]);
 251   EXPECT_EQ(0x01, dst[3]);
 252   EXPECT_EQ(0x23, dst[4]);
 253   EXPECT_EQ(0x45, dst[5]);
 254   EXPECT_EQ(0x67, dst[6]);
 255   EXPECT_EQ(0x89, dst[7]);
 256 }
 257
 258 TEST_F(StringExtractorTest, GetHexBytes_OddPair) {
 259   llvm::StringRef kHexEncodedBytes = "abcdef012345678w";
 260   const size_t kValidHexPairs = 7;
 261   StringExtractor ex(kHexEncodedBytes);
 262
 263   uint8_t dst[8];
 264   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
 265   EXPECT_EQ(0xab, dst[0]);
 266   EXPECT_EQ(0xcd, dst[1]);
 267   EXPECT_EQ(0xef, dst[2]);
 268   EXPECT_EQ(0x01, dst[3]);
 269   EXPECT_EQ(0x23, dst[4]);
 270   EXPECT_EQ(0x45, dst[5]);
 271   EXPECT_EQ(0x67, dst[6]);
 272
 273   // This one should be invalid
 274   EXPECT_EQ(0xde, dst[7]);
 275 }
 276
 277 TEST_F(StringExtractorTest, GetHexBytes_OddPair2) {
 278   llvm::StringRef kHexEncodedBytes = "abcdef012345678";
 279   const size_t kValidHexPairs = 7;
 280   StringExtractor ex(kHexEncodedBytes);
 281
 282   uint8_t dst[8];
 283   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
 284   EXPECT_EQ(0xab, dst[0]);
 285   EXPECT_EQ(0xcd, dst[1]);
 286   EXPECT_EQ(0xef, dst[2]);
 287   EXPECT_EQ(0x01, dst[3]);
 288   EXPECT_EQ(0x23, dst[4]);
 289   EXPECT_EQ(0x45, dst[5]);
 290   EXPECT_EQ(0x67, dst[6]);
 291
 292   EXPECT_EQ(0xde, dst[7]);
 293 }
 294
 295 TEST_F(StringExtractorTest, GetHexBytes_Underflow) {
 296   llvm::StringRef kHexEncodedBytes = "abcdef0123456789xyzw";
 297   const size_t kValidHexPairs = 8;
 298   StringExtractor ex(kHexEncodedBytes);
 299
 300   uint8_t dst[12];
 301   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
 302   EXPECT_EQ(0xab, dst[0]);
 303   EXPECT_EQ(0xcd, dst[1]);
 304   EXPECT_EQ(0xef, dst[2]);
 305   EXPECT_EQ(0x01, dst[3]);
 306   EXPECT_EQ(0x23, dst[4]);
 307   EXPECT_EQ(0x45, dst[5]);
 308   EXPECT_EQ(0x67, dst[6]);
 309   EXPECT_EQ(0x89, dst[7]);
 310   // these bytes should be filled with fail_fill_value 0xde
 311   EXPECT_EQ(0xde, dst[8]);
 312   EXPECT_EQ(0xde, dst[9]);
 313   EXPECT_EQ(0xde, dst[10]);
 314   EXPECT_EQ(0xde, dst[11]);
 315
 316   ASSERT_EQ(false, ex.IsGood());
 317   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
 318   ASSERT_EQ(false, ex.Empty());
 319   ASSERT_EQ(0u, ex.GetBytesLeft());
 320   ASSERT_EQ(nullptr, ex.Peek());
 321 }
 322
 323 TEST_F(StringExtractorTest, GetHexBytes_Partial) {
 324   llvm::StringRef kHexEncodedBytes = "abcdef0123456789xyzw";
 325   const size_t kReadBytes = 4;
 326   StringExtractor ex(kHexEncodedBytes);
 327
 328   uint8_t dst[12];
 329   memset(dst, 0xab, sizeof(dst));
 330   ASSERT_EQ(
 331       kReadBytes,
 332       ex.GetHexBytes(llvm::MutableArrayRef<uint8_t>(dst, kReadBytes), 0xde));
 333   EXPECT_EQ(0xab, dst[0]);
 334   EXPECT_EQ(0xcd, dst[1]);
 335   EXPECT_EQ(0xef, dst[2]);
 336   EXPECT_EQ(0x01, dst[3]);
 337   // these bytes should be unchanged
 338   EXPECT_EQ(0xab, dst[4]);
 339   EXPECT_EQ(0xab, dst[5]);
 340   EXPECT_EQ(0xab, dst[6]);
 341   EXPECT_EQ(0xab, dst[7]);
 342   EXPECT_EQ(0xab, dst[8]);
 343   EXPECT_EQ(0xab, dst[9]);
 344   EXPECT_EQ(0xab, dst[10]);
 345   EXPECT_EQ(0xab, dst[11]);
 346
 347   ASSERT_EQ(true, ex.IsGood());
 348   ASSERT_EQ(kReadBytes * 2, ex.GetFilePos());
 349   ASSERT_EQ(false, ex.Empty());
 350   ASSERT_EQ(12u, ex.GetBytesLeft());
 351   ASSERT_EQ('2', *ex.Peek());
 352 }
 353
 354 TEST_F(StringExtractorTest, GetHexBytesAvail) {
 355   llvm::StringRef kHexEncodedBytes = "abcdef0123456789xyzw";
 356   const size_t kValidHexPairs = 8;
 357   StringExtractor ex(kHexEncodedBytes);
 358
 359   uint8_t dst[kValidHexPairs];
 360   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
 361   EXPECT_EQ(0xab, dst[0]);
 362   EXPECT_EQ(0xcd, dst[1]);
 363   EXPECT_EQ(0xef, dst[2]);
 364   EXPECT_EQ(0x01, dst[3]);
 365   EXPECT_EQ(0x23, dst[4]);
 366   EXPECT_EQ(0x45, dst[5]);
 367   EXPECT_EQ(0x67, dst[6]);
 368   EXPECT_EQ(0x89, dst[7]);
 369
 370   ASSERT_EQ(true, ex.IsGood());
 371   ASSERT_EQ(2 * kValidHexPairs, ex.GetFilePos());
 372   ASSERT_EQ(false, ex.Empty());
 373   ASSERT_EQ(4u, ex.GetBytesLeft());
 374   ASSERT_EQ('x', *ex.Peek());
 375 }
 376
 377 TEST_F(StringExtractorTest, GetHexBytesAvail_FullString) {
 378   llvm::StringRef kHexEncodedBytes = "abcdef0123456789";
 379   const size_t kValidHexPairs = 8;
 380   StringExtractor ex(kHexEncodedBytes);
 381
 382   uint8_t dst[kValidHexPairs];
 383   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
 384   EXPECT_EQ(0xab, dst[0]);
 385   EXPECT_EQ(0xcd, dst[1]);
 386   EXPECT_EQ(0xef, dst[2]);
 387   EXPECT_EQ(0x01, dst[3]);
 388   EXPECT_EQ(0x23, dst[4]);
 389   EXPECT_EQ(0x45, dst[5]);
 390   EXPECT_EQ(0x67, dst[6]);
 391   EXPECT_EQ(0x89, dst[7]);
 392 }
 393
 394 TEST_F(StringExtractorTest, GetHexBytesAvail_OddPair) {
 395   llvm::StringRef kHexEncodedBytes = "abcdef012345678w";
 396   const size_t kValidHexPairs = 7;
 397   StringExtractor ex(kHexEncodedBytes);
 398
 399   uint8_t dst[8];
 400   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
 401   EXPECT_EQ(0xab, dst[0]);
 402   EXPECT_EQ(0xcd, dst[1]);
 403   EXPECT_EQ(0xef, dst[2]);
 404   EXPECT_EQ(0x01, dst[3]);
 405   EXPECT_EQ(0x23, dst[4]);
 406   EXPECT_EQ(0x45, dst[5]);
 407   EXPECT_EQ(0x67, dst[6]);
 408 }
 409
 410 TEST_F(StringExtractorTest, GetHexBytesAvail_OddPair2) {
 411   llvm::StringRef kHexEncodedBytes = "abcdef012345678";
 412   const size_t kValidHexPairs = 7;
 413   StringExtractor ex(kHexEncodedBytes);
 414
 415   uint8_t dst[8];
 416   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
 417   EXPECT_EQ(0xab, dst[0]);
 418   EXPECT_EQ(0xcd, dst[1]);
 419   EXPECT_EQ(0xef, dst[2]);
 420   EXPECT_EQ(0x01, dst[3]);
 421   EXPECT_EQ(0x23, dst[4]);
 422   EXPECT_EQ(0x45, dst[5]);
 423   EXPECT_EQ(0x67, dst[6]);
 424 }
 425
 426 TEST_F(StringExtractorTest, GetHexBytesAvail_Underflow) {
 427   llvm::StringRef kHexEncodedBytes = "abcdef0123456789xyzw";
 428   const size_t kValidHexPairs = 8;
 429   StringExtractor ex(kHexEncodedBytes);
 430
 431   uint8_t dst[12];
 432   memset(dst, 0xef, sizeof(dst));
 433   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
 434   EXPECT_EQ(0xab, dst[0]);
 435   EXPECT_EQ(0xcd, dst[1]);
 436   EXPECT_EQ(0xef, dst[2]);
 437   EXPECT_EQ(0x01, dst[3]);
 438   EXPECT_EQ(0x23, dst[4]);
 439   EXPECT_EQ(0x45, dst[5]);
 440   EXPECT_EQ(0x67, dst[6]);
 441   EXPECT_EQ(0x89, dst[7]);
 442   // these bytes should be unchanged
 443   EXPECT_EQ(0xef, dst[8]);
 444   EXPECT_EQ(0xef, dst[9]);
 445   EXPECT_EQ(0xef, dst[10]);
 446   EXPECT_EQ(0xef, dst[11]);
 447
 448   ASSERT_EQ(true, ex.IsGood());
 449   ASSERT_EQ(kValidHexPairs * 2, ex.GetFilePos());
 450   ASSERT_EQ(false, ex.Empty());
 451   ASSERT_EQ(4u, ex.GetBytesLeft());
 452   ASSERT_EQ('x', *ex.Peek());
 453 }
 454
 455 TEST_F(StringExtractorTest, GetHexBytesAvail_Partial) {
 456   llvm::StringRef kHexEncodedBytes = "abcdef0123456789xyzw";
 457   const size_t kReadBytes = 4;
 458   StringExtractor ex(kHexEncodedBytes);
 459
 460   uint8_t dst[12];
 461   memset(dst, 0xab, sizeof(dst));
 462   ASSERT_EQ(kReadBytes, ex.GetHexBytesAvail(
 463                             llvm::MutableArrayRef<uint8_t>(dst, kReadBytes)));
 464   EXPECT_EQ(0xab, dst[0]);
 465   EXPECT_EQ(0xcd, dst[1]);
 466   EXPECT_EQ(0xef, dst[2]);
 467   EXPECT_EQ(0x01, dst[3]);
 468   // these bytes should be unchanged
 469   EXPECT_EQ(0xab, dst[4]);
 470   EXPECT_EQ(0xab, dst[5]);
 471   EXPECT_EQ(0xab, dst[6]);
 472   EXPECT_EQ(0xab, dst[7]);
 473   EXPECT_EQ(0xab, dst[8]);
 474   EXPECT_EQ(0xab, dst[9]);
 475   EXPECT_EQ(0xab, dst[10]);
 476   EXPECT_EQ(0xab, dst[11]);
 477
 478   ASSERT_EQ(true, ex.IsGood());
 479   ASSERT_EQ(kReadBytes * 2, ex.GetFilePos());
 480   ASSERT_EQ(false, ex.Empty());
 481   ASSERT_EQ(12u, ex.GetBytesLeft());
 482   ASSERT_EQ('2', *ex.Peek());
 483 }
 484
 485 TEST_F(StringExtractorTest, GetNameColonValueSuccess) {
 486   llvm::StringRef kNameColonPairs = "key1:value1;key2:value2;";
 487   StringExtractor ex(kNameColonPairs);
 488
 489   llvm::StringRef name;
 490   llvm::StringRef value;
 491   EXPECT_TRUE(ex.GetNameColonValue(name, value));
 492   EXPECT_EQ("key1", name);
 493   EXPECT_EQ("value1", value);
 494   EXPECT_TRUE(ex.GetNameColonValue(name, value));
 495   EXPECT_EQ("key2", name);
 496   EXPECT_EQ("value2", value);
 497   EXPECT_EQ(0u, ex.GetBytesLeft());
 498 }
 499
 500 TEST_F(StringExtractorTest, GetNameColonValueContainsColon) {
 501   llvm::StringRef kNameColonPairs = "key1:value1:value2;key2:value3;";
 502   StringExtractor ex(kNameColonPairs);
 503
 504   llvm::StringRef name;
 505   llvm::StringRef value;
 506   EXPECT_TRUE(ex.GetNameColonValue(name, value));
 507   EXPECT_EQ("key1", name);
 508   EXPECT_EQ("value1:value2", value);
 509   EXPECT_TRUE(ex.GetNameColonValue(name, value));
 510   EXPECT_EQ("key2", name);
 511   EXPECT_EQ("value3", value);
 512   EXPECT_EQ(0u, ex.GetBytesLeft());
 513 }
 514
 515 TEST_F(StringExtractorTest, GetNameColonValueNoSemicolon) {
 516   llvm::StringRef kNameColonPairs = "key1:value1";
 517   StringExtractor ex(kNameColonPairs);
 518
 519   llvm::StringRef name;
 520   llvm::StringRef value;
 521   EXPECT_FALSE(ex.GetNameColonValue(name, value));
 522   EXPECT_EQ(0u, ex.GetBytesLeft());
 523 }
 524
 525 TEST_F(StringExtractorTest, GetNameColonValueNoColon) {
 526   llvm::StringRef kNameColonPairs = "key1value1;";
 527   StringExtractor ex(kNameColonPairs);
 528
 529   llvm::StringRef name;
 530   llvm::StringRef value;
 531   EXPECT_FALSE(ex.GetNameColonValue(name, value));
 532   EXPECT_EQ(0u, ex.GetBytesLeft());
 533 }
 534
 535 TEST_F(StringExtractorTest, GetU32LittleEndian) {
 536   StringExtractor ex("");
 537   EXPECT_EQ(0x0ull, ex.GetHexMaxU32(true, 0));
 538
 539   ex.Reset("0");
 540   EXPECT_EQ(0x0ull, ex.GetHexMaxU32(true, 1));
 541
 542   ex.Reset("1");
 543   EXPECT_EQ(0x1ull, ex.GetHexMaxU32(true, 0));
 544
 545   ex.Reset("01");
 546   EXPECT_EQ(0x1ull, ex.GetHexMaxU32(true, 0));
 547
 548   ex.Reset("001");
 549   EXPECT_EQ(0x100ull, ex.GetHexMaxU32(true, 0));
 550
 551   ex.Reset("12");
 552   EXPECT_EQ(0x12ull, ex.GetHexMaxU32(true, 0));
 553
 554   ex.Reset("123");
 555   EXPECT_EQ(0x312ull, ex.GetHexMaxU32(true, 0));
 556
 557   ex.Reset("1203");
 558   EXPECT_EQ(0x312ull, ex.GetHexMaxU32(true, 0));
 559
 560   ex.Reset("1234");
 561   EXPECT_EQ(0x3412ull, ex.GetHexMaxU32(true, 0));
 562
 563   ex.Reset("12340");
 564   EXPECT_EQ(0x3412ull, ex.GetHexMaxU32(true, 0));
 565
 566   ex.Reset("123400");
 567   EXPECT_EQ(0x3412ull, ex.GetHexMaxU32(true, 0));
 568
 569   ex.Reset("12345670");
 570   EXPECT_EQ(0x70563412ull, ex.GetHexMaxU32(true, 0));
 571
 572   ex.Reset("123456701");
 573   EXPECT_EQ(0ull, ex.GetHexMaxU32(true, 0));
 574 }
 575
 576 TEST_F(StringExtractorTest, GetU32BigEndian) {
 577   StringExtractor ex("");
 578   EXPECT_EQ(0x0ull, ex.GetHexMaxU32(false, 0));
 579
 580   ex.Reset("0");
 581   EXPECT_EQ(0x0ull, ex.GetHexMaxU32(false, 1));
 582
 583   ex.Reset("1");
 584   EXPECT_EQ(0x1ull, ex.GetHexMaxU32(false, 0));
 585
 586   ex.Reset("01");
 587   EXPECT_EQ(0x1ull, ex.GetHexMaxU32(false, 0));
 588
 589   ex.Reset("001");
 590   EXPECT_EQ(0x1ull, ex.GetHexMaxU32(false, 0));
 591
 592   ex.Reset("12");
 593   EXPECT_EQ(0x12ull, ex.GetHexMaxU32(false, 0));
 594
 595   ex.Reset("123");
 596   EXPECT_EQ(0x123ull, ex.GetHexMaxU32(false, 0));
 597
 598   ex.Reset("1203");
 599   EXPECT_EQ(0x1203ull, ex.GetHexMaxU32(false, 0));
 600
 601   ex.Reset("1234");
 602   EXPECT_EQ(0x1234ull, ex.GetHexMaxU32(false, 0));
 603
 604   ex.Reset("12340");
 605   EXPECT_EQ(0x12340ull, ex.GetHexMaxU32(false, 0));
 606
 607   ex.Reset("123400");
 608   EXPECT_EQ(0x123400ull, ex.GetHexMaxU32(false, 0));
 609
 610   ex.Reset("12345670");
 611   EXPECT_EQ(0x12345670ull, ex.GetHexMaxU32(false, 0));
 612
 613   ex.Reset("123456700");
 614   EXPECT_EQ(0ull, ex.GetHexMaxU32(false, 0));
 615 }
 616
 617 TEST_F(StringExtractorTest, GetU64LittleEndian) {
 618   StringExtractor ex("");
 619   EXPECT_EQ(0x0ull, ex.GetHexMaxU64(true, 0));
 620
 621   ex.Reset("0");
 622   EXPECT_EQ(0x0ull, ex.GetHexMaxU64(true, 1));
 623
 624   ex.Reset("1");
 625   EXPECT_EQ(0x1ull, ex.GetHexMaxU64(true, 0));
 626
 627   ex.Reset("01");
 628   EXPECT_EQ(0x1ull, ex.GetHexMaxU64(true, 0));
 629
 630   ex.Reset("001");
 631   EXPECT_EQ(0x100ull, ex.GetHexMaxU64(true, 0));
 632
 633   ex.Reset("12");
 634   EXPECT_EQ(0x12ull, ex.GetHexMaxU64(true, 0));
 635
 636   ex.Reset("123");
 637   EXPECT_EQ(0x312ull, ex.GetHexMaxU64(true, 0));
 638
 639   ex.Reset("1203");
 640   EXPECT_EQ(0x312ull, ex.GetHexMaxU64(true, 0));
 641
 642   ex.Reset("1234");
 643   EXPECT_EQ(0x3412ull, ex.GetHexMaxU64(true, 0));
 644
 645   ex.Reset("12340");
 646   EXPECT_EQ(0x3412ull, ex.GetHexMaxU64(true, 0));
 647
 648   ex.Reset("123400");
 649   EXPECT_EQ(0x3412ull, ex.GetHexMaxU64(true, 0));
 650
 651   ex.Reset("123456789ABCDEF0");
 652   EXPECT_EQ(0xF0DEBC9A78563412ULL, ex.GetHexMaxU64(true, 0));
 653
 654   ex.Reset("123456789ABCDEF01");
 655   EXPECT_EQ(0ull, ex.GetHexMaxU64(true, 0));
 656 }
 657
 658 TEST_F(StringExtractorTest, GetU64BigEndian) {
 659   StringExtractor ex("");
 660   EXPECT_EQ(0x0ull, ex.GetHexMaxU64(false, 0));
 661
 662   ex.Reset("0");
 663   EXPECT_EQ(0x0ull, ex.GetHexMaxU64(false, 1));
 664
 665   ex.Reset("1");
 666   EXPECT_EQ(0x1ull, ex.GetHexMaxU64(false, 0));
 667
 668   ex.Reset("01");
 669   EXPECT_EQ(0x1ull, ex.GetHexMaxU64(false, 0));
 670
 671   ex.Reset("001");
 672   EXPECT_EQ(0x1ull, ex.GetHexMaxU64(false, 0));
 673
 674   ex.Reset("12");
 675   EXPECT_EQ(0x12ull, ex.GetHexMaxU64(false, 0));
 676
 677   ex.Reset("123");
 678   EXPECT_EQ(0x123ull, ex.GetHexMaxU64(false, 0));
 679
 680   ex.Reset("1203");
 681   EXPECT_EQ(0x1203ull, ex.GetHexMaxU64(false, 0));
 682
 683   ex.Reset("1234");
 684   EXPECT_EQ(0x1234ull, ex.GetHexMaxU64(false, 0));
 685
 686   ex.Reset("12340");
 687   EXPECT_EQ(0x12340ull, ex.GetHexMaxU64(false, 0));
 688
 689   ex.Reset("123400");
 690   EXPECT_EQ(0x123400ull, ex.GetHexMaxU64(false, 0));
 691
 692   ex.Reset("123456789ABCDEF0");
 693   EXPECT_EQ(0x123456789ABCDEF0ULL, ex.GetHexMaxU64(false, 0));
 694
 695   ex.Reset("123456789ABCDEF000");
 696   EXPECT_EQ(0ull, ex.GetHexMaxU64(false, 0));
 697 }