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