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