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