1 //===- llvm/unittest/ADT/StringRefTest.cpp - StringRef unit tests ---------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/ADT/StringRef.h" 11 #include "llvm/ADT/Hashing.h" 12 #include "llvm/ADT/STLExtras.h" 13 #include "llvm/ADT/SmallVector.h" 14 #include "llvm/ADT/StringExtras.h" 15 #include "llvm/Support/Allocator.h" 16 #include "llvm/Support/raw_ostream.h" 17 #include "gtest/gtest.h" 18 using namespace llvm; 19 20 namespace llvm { 21 22 std::ostream &operator<<(std::ostream &OS, const StringRef &S) { 23 OS << S.str(); 24 return OS; 25 } 26 27 std::ostream &operator<<(std::ostream &OS, 28 const std::pair<StringRef, StringRef> &P) { 29 OS << "(" << P.first << ", " << P.second << ")"; 30 return OS; 31 } 32 33 } 34 35 namespace { 36 TEST(StringRefTest, Construction) { 37 EXPECT_EQ("", StringRef()); 38 EXPECT_EQ("hello", StringRef("hello")); 39 EXPECT_EQ("hello", StringRef("hello world", 5)); 40 EXPECT_EQ("hello", StringRef(std::string("hello"))); 41 } 42 43 TEST(StringRefTest, Iteration) { 44 StringRef S("hello"); 45 const char *p = "hello"; 46 for (const char *it = S.begin(), *ie = S.end(); it != ie; ++it, ++p) 47 EXPECT_EQ(*it, *p); 48 } 49 50 TEST(StringRefTest, StringOps) { 51 const char *p = "hello"; 52 EXPECT_EQ(p, StringRef(p, 0).data()); 53 EXPECT_TRUE(StringRef().empty()); 54 EXPECT_EQ((size_t) 5, StringRef("hello").size()); 55 EXPECT_EQ(-1, StringRef("aab").compare("aad")); 56 EXPECT_EQ( 0, StringRef("aab").compare("aab")); 57 EXPECT_EQ( 1, StringRef("aab").compare("aaa")); 58 EXPECT_EQ(-1, StringRef("aab").compare("aabb")); 59 EXPECT_EQ( 1, StringRef("aab").compare("aa")); 60 EXPECT_EQ( 1, StringRef("\xFF").compare("\1")); 61 62 EXPECT_EQ(-1, StringRef("AaB").compare_lower("aAd")); 63 EXPECT_EQ( 0, StringRef("AaB").compare_lower("aab")); 64 EXPECT_EQ( 1, StringRef("AaB").compare_lower("AAA")); 65 EXPECT_EQ(-1, StringRef("AaB").compare_lower("aaBb")); 66 EXPECT_EQ(-1, StringRef("AaB").compare_lower("bb")); 67 EXPECT_EQ( 1, StringRef("aaBb").compare_lower("AaB")); 68 EXPECT_EQ( 1, StringRef("bb").compare_lower("AaB")); 69 EXPECT_EQ( 1, StringRef("AaB").compare_lower("aA")); 70 EXPECT_EQ( 1, StringRef("\xFF").compare_lower("\1")); 71 72 EXPECT_EQ(-1, StringRef("aab").compare_numeric("aad")); 73 EXPECT_EQ( 0, StringRef("aab").compare_numeric("aab")); 74 EXPECT_EQ( 1, StringRef("aab").compare_numeric("aaa")); 75 EXPECT_EQ(-1, StringRef("aab").compare_numeric("aabb")); 76 EXPECT_EQ( 1, StringRef("aab").compare_numeric("aa")); 77 EXPECT_EQ(-1, StringRef("1").compare_numeric("10")); 78 EXPECT_EQ( 0, StringRef("10").compare_numeric("10")); 79 EXPECT_EQ( 0, StringRef("10a").compare_numeric("10a")); 80 EXPECT_EQ( 1, StringRef("2").compare_numeric("1")); 81 EXPECT_EQ( 0, StringRef("llvm_v1i64_ty").compare_numeric("llvm_v1i64_ty")); 82 EXPECT_EQ( 1, StringRef("\xFF").compare_numeric("\1")); 83 EXPECT_EQ( 1, StringRef("V16").compare_numeric("V1_q0")); 84 EXPECT_EQ(-1, StringRef("V1_q0").compare_numeric("V16")); 85 EXPECT_EQ(-1, StringRef("V8_q0").compare_numeric("V16")); 86 EXPECT_EQ( 1, StringRef("V16").compare_numeric("V8_q0")); 87 EXPECT_EQ(-1, StringRef("V1_q0").compare_numeric("V8_q0")); 88 EXPECT_EQ( 1, StringRef("V8_q0").compare_numeric("V1_q0")); 89 } 90 91 TEST(StringRefTest, Operators) { 92 EXPECT_EQ("", StringRef()); 93 EXPECT_TRUE(StringRef("aab") < StringRef("aad")); 94 EXPECT_FALSE(StringRef("aab") < StringRef("aab")); 95 EXPECT_TRUE(StringRef("aab") <= StringRef("aab")); 96 EXPECT_FALSE(StringRef("aab") <= StringRef("aaa")); 97 EXPECT_TRUE(StringRef("aad") > StringRef("aab")); 98 EXPECT_FALSE(StringRef("aab") > StringRef("aab")); 99 EXPECT_TRUE(StringRef("aab") >= StringRef("aab")); 100 EXPECT_FALSE(StringRef("aaa") >= StringRef("aab")); 101 EXPECT_EQ(StringRef("aab"), StringRef("aab")); 102 EXPECT_FALSE(StringRef("aab") == StringRef("aac")); 103 EXPECT_FALSE(StringRef("aab") != StringRef("aab")); 104 EXPECT_TRUE(StringRef("aab") != StringRef("aac")); 105 EXPECT_EQ('a', StringRef("aab")[1]); 106 } 107 108 TEST(StringRefTest, Substr) { 109 StringRef Str("hello"); 110 EXPECT_EQ("lo", Str.substr(3)); 111 EXPECT_EQ("", Str.substr(100)); 112 EXPECT_EQ("hello", Str.substr(0, 100)); 113 EXPECT_EQ("o", Str.substr(4, 10)); 114 } 115 116 TEST(StringRefTest, Slice) { 117 StringRef Str("hello"); 118 EXPECT_EQ("l", Str.slice(2, 3)); 119 EXPECT_EQ("ell", Str.slice(1, 4)); 120 EXPECT_EQ("llo", Str.slice(2, 100)); 121 EXPECT_EQ("", Str.slice(2, 1)); 122 EXPECT_EQ("", Str.slice(10, 20)); 123 } 124 125 TEST(StringRefTest, Split) { 126 StringRef Str("hello"); 127 EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")), 128 Str.split('X')); 129 EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")), 130 Str.split('e')); 131 EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")), 132 Str.split('h')); 133 EXPECT_EQ(std::make_pair(StringRef("he"), StringRef("lo")), 134 Str.split('l')); 135 EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")), 136 Str.split('o')); 137 138 EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")), 139 Str.rsplit('X')); 140 EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")), 141 Str.rsplit('e')); 142 EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")), 143 Str.rsplit('h')); 144 EXPECT_EQ(std::make_pair(StringRef("hel"), StringRef("o")), 145 Str.rsplit('l')); 146 EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")), 147 Str.rsplit('o')); 148 } 149 150 TEST(StringRefTest, Split2) { 151 SmallVector<StringRef, 5> parts; 152 SmallVector<StringRef, 5> expected; 153 154 expected.push_back("ab"); expected.push_back("c"); 155 StringRef(",ab,,c,").split(parts, ",", -1, false); 156 EXPECT_TRUE(parts == expected); 157 158 expected.clear(); parts.clear(); 159 expected.push_back(""); expected.push_back("ab"); expected.push_back(""); 160 expected.push_back("c"); expected.push_back(""); 161 StringRef(",ab,,c,").split(parts, ",", -1, true); 162 EXPECT_TRUE(parts == expected); 163 164 expected.clear(); parts.clear(); 165 expected.push_back(""); 166 StringRef("").split(parts, ",", -1, true); 167 EXPECT_TRUE(parts == expected); 168 169 expected.clear(); parts.clear(); 170 StringRef("").split(parts, ",", -1, false); 171 EXPECT_TRUE(parts == expected); 172 173 expected.clear(); parts.clear(); 174 StringRef(",").split(parts, ",", -1, false); 175 EXPECT_TRUE(parts == expected); 176 177 expected.clear(); parts.clear(); 178 expected.push_back(""); expected.push_back(""); 179 StringRef(",").split(parts, ",", -1, true); 180 EXPECT_TRUE(parts == expected); 181 182 expected.clear(); parts.clear(); 183 expected.push_back("a"); expected.push_back("b"); 184 StringRef("a,b").split(parts, ",", -1, true); 185 EXPECT_TRUE(parts == expected); 186 187 // Test MaxSplit 188 expected.clear(); parts.clear(); 189 expected.push_back("a,,b,c"); 190 StringRef("a,,b,c").split(parts, ",", 0, true); 191 EXPECT_TRUE(parts == expected); 192 193 expected.clear(); parts.clear(); 194 expected.push_back("a,,b,c"); 195 StringRef("a,,b,c").split(parts, ",", 0, false); 196 EXPECT_TRUE(parts == expected); 197 198 expected.clear(); parts.clear(); 199 expected.push_back("a"); expected.push_back(",b,c"); 200 StringRef("a,,b,c").split(parts, ",", 1, true); 201 EXPECT_TRUE(parts == expected); 202 203 expected.clear(); parts.clear(); 204 expected.push_back("a"); expected.push_back(",b,c"); 205 StringRef("a,,b,c").split(parts, ",", 1, false); 206 EXPECT_TRUE(parts == expected); 207 208 expected.clear(); parts.clear(); 209 expected.push_back("a"); expected.push_back(""); expected.push_back("b,c"); 210 StringRef("a,,b,c").split(parts, ",", 2, true); 211 EXPECT_TRUE(parts == expected); 212 213 expected.clear(); parts.clear(); 214 expected.push_back("a"); expected.push_back("b,c"); 215 StringRef("a,,b,c").split(parts, ",", 2, false); 216 EXPECT_TRUE(parts == expected); 217 218 expected.clear(); parts.clear(); 219 expected.push_back("a"); expected.push_back(""); expected.push_back("b"); 220 expected.push_back("c"); 221 StringRef("a,,b,c").split(parts, ",", 3, true); 222 EXPECT_TRUE(parts == expected); 223 224 expected.clear(); parts.clear(); 225 expected.push_back("a"); expected.push_back("b"); expected.push_back("c"); 226 StringRef("a,,b,c").split(parts, ",", 3, false); 227 EXPECT_TRUE(parts == expected); 228 229 expected.clear(); parts.clear(); 230 expected.push_back("a"); expected.push_back("b"); expected.push_back("c"); 231 StringRef("a,,b,c").split(parts, ',', 3, false); 232 EXPECT_TRUE(parts == expected); 233 234 expected.clear(); parts.clear(); 235 expected.push_back(""); 236 StringRef().split(parts, ",", 0, true); 237 EXPECT_TRUE(parts == expected); 238 239 expected.clear(); parts.clear(); 240 expected.push_back(StringRef()); 241 StringRef("").split(parts, ",", 0, true); 242 EXPECT_TRUE(parts == expected); 243 244 expected.clear(); parts.clear(); 245 StringRef("").split(parts, ",", 0, false); 246 EXPECT_TRUE(parts == expected); 247 StringRef().split(parts, ",", 0, false); 248 EXPECT_TRUE(parts == expected); 249 250 expected.clear(); parts.clear(); 251 expected.push_back("a"); 252 expected.push_back(""); 253 expected.push_back("b"); 254 expected.push_back("c,d"); 255 StringRef("a,,b,c,d").split(parts, ",", 3, true); 256 EXPECT_TRUE(parts == expected); 257 258 expected.clear(); parts.clear(); 259 expected.push_back(""); 260 StringRef().split(parts, ',', 0, true); 261 EXPECT_TRUE(parts == expected); 262 263 expected.clear(); parts.clear(); 264 expected.push_back(StringRef()); 265 StringRef("").split(parts, ',', 0, true); 266 EXPECT_TRUE(parts == expected); 267 268 expected.clear(); parts.clear(); 269 StringRef("").split(parts, ',', 0, false); 270 EXPECT_TRUE(parts == expected); 271 StringRef().split(parts, ',', 0, false); 272 EXPECT_TRUE(parts == expected); 273 274 expected.clear(); parts.clear(); 275 expected.push_back("a"); 276 expected.push_back(""); 277 expected.push_back("b"); 278 expected.push_back("c,d"); 279 StringRef("a,,b,c,d").split(parts, ',', 3, true); 280 EXPECT_TRUE(parts == expected); 281 } 282 283 TEST(StringRefTest, Trim) { 284 StringRef Str0("hello"); 285 StringRef Str1(" hello "); 286 StringRef Str2(" hello "); 287 288 EXPECT_EQ(StringRef("hello"), Str0.rtrim()); 289 EXPECT_EQ(StringRef(" hello"), Str1.rtrim()); 290 EXPECT_EQ(StringRef(" hello"), Str2.rtrim()); 291 EXPECT_EQ(StringRef("hello"), Str0.ltrim()); 292 EXPECT_EQ(StringRef("hello "), Str1.ltrim()); 293 EXPECT_EQ(StringRef("hello "), Str2.ltrim()); 294 EXPECT_EQ(StringRef("hello"), Str0.trim()); 295 EXPECT_EQ(StringRef("hello"), Str1.trim()); 296 EXPECT_EQ(StringRef("hello"), Str2.trim()); 297 298 EXPECT_EQ(StringRef("ello"), Str0.trim("hhhhhhhhhhh")); 299 300 EXPECT_EQ(StringRef(""), StringRef("").trim()); 301 EXPECT_EQ(StringRef(""), StringRef(" ").trim()); 302 EXPECT_EQ(StringRef("\0", 1), StringRef(" \0 ", 3).trim()); 303 EXPECT_EQ(StringRef("\0\0", 2), StringRef("\0\0", 2).trim()); 304 EXPECT_EQ(StringRef("x"), StringRef("\0\0x\0\0", 5).trim('\0')); 305 } 306 307 TEST(StringRefTest, StartsWith) { 308 StringRef Str("hello"); 309 EXPECT_TRUE(Str.startswith("")); 310 EXPECT_TRUE(Str.startswith("he")); 311 EXPECT_FALSE(Str.startswith("helloworld")); 312 EXPECT_FALSE(Str.startswith("hi")); 313 } 314 315 TEST(StringRefTest, StartsWithLower) { 316 StringRef Str("heLLo"); 317 EXPECT_TRUE(Str.startswith_lower("")); 318 EXPECT_TRUE(Str.startswith_lower("he")); 319 EXPECT_TRUE(Str.startswith_lower("hell")); 320 EXPECT_TRUE(Str.startswith_lower("HELlo")); 321 EXPECT_FALSE(Str.startswith_lower("helloworld")); 322 EXPECT_FALSE(Str.startswith_lower("hi")); 323 } 324 325 TEST(StringRefTest, ConsumeFront) { 326 StringRef Str("hello"); 327 EXPECT_TRUE(Str.consume_front("")); 328 EXPECT_EQ("hello", Str); 329 EXPECT_TRUE(Str.consume_front("he")); 330 EXPECT_EQ("llo", Str); 331 EXPECT_FALSE(Str.consume_front("lloworld")); 332 EXPECT_EQ("llo", Str); 333 EXPECT_FALSE(Str.consume_front("lol")); 334 EXPECT_EQ("llo", Str); 335 EXPECT_TRUE(Str.consume_front("llo")); 336 EXPECT_EQ("", Str); 337 EXPECT_FALSE(Str.consume_front("o")); 338 EXPECT_TRUE(Str.consume_front("")); 339 } 340 341 TEST(StringRefTest, EndsWith) { 342 StringRef Str("hello"); 343 EXPECT_TRUE(Str.endswith("")); 344 EXPECT_TRUE(Str.endswith("lo")); 345 EXPECT_FALSE(Str.endswith("helloworld")); 346 EXPECT_FALSE(Str.endswith("worldhello")); 347 EXPECT_FALSE(Str.endswith("so")); 348 } 349 350 TEST(StringRefTest, EndsWithLower) { 351 StringRef Str("heLLo"); 352 EXPECT_TRUE(Str.endswith_lower("")); 353 EXPECT_TRUE(Str.endswith_lower("lo")); 354 EXPECT_TRUE(Str.endswith_lower("LO")); 355 EXPECT_TRUE(Str.endswith_lower("ELlo")); 356 EXPECT_FALSE(Str.endswith_lower("helloworld")); 357 EXPECT_FALSE(Str.endswith_lower("hi")); 358 } 359 360 TEST(StringRefTest, ConsumeBack) { 361 StringRef Str("hello"); 362 EXPECT_TRUE(Str.consume_back("")); 363 EXPECT_EQ("hello", Str); 364 EXPECT_TRUE(Str.consume_back("lo")); 365 EXPECT_EQ("hel", Str); 366 EXPECT_FALSE(Str.consume_back("helhel")); 367 EXPECT_EQ("hel", Str); 368 EXPECT_FALSE(Str.consume_back("hle")); 369 EXPECT_EQ("hel", Str); 370 EXPECT_TRUE(Str.consume_back("hel")); 371 EXPECT_EQ("", Str); 372 EXPECT_FALSE(Str.consume_back("h")); 373 EXPECT_TRUE(Str.consume_back("")); 374 } 375 376 TEST(StringRefTest, Find) { 377 StringRef Str("hello"); 378 EXPECT_EQ(2U, Str.find('l')); 379 EXPECT_EQ(StringRef::npos, Str.find('z')); 380 EXPECT_EQ(StringRef::npos, Str.find("helloworld")); 381 EXPECT_EQ(0U, Str.find("hello")); 382 EXPECT_EQ(1U, Str.find("ello")); 383 EXPECT_EQ(StringRef::npos, Str.find("zz")); 384 EXPECT_EQ(2U, Str.find("ll", 2)); 385 EXPECT_EQ(StringRef::npos, Str.find("ll", 3)); 386 EXPECT_EQ(0U, Str.find("")); 387 StringRef LongStr("hellx xello hell ello world foo bar hello"); 388 EXPECT_EQ(36U, LongStr.find("hello")); 389 EXPECT_EQ(28U, LongStr.find("foo")); 390 EXPECT_EQ(12U, LongStr.find("hell", 2)); 391 EXPECT_EQ(0U, LongStr.find("")); 392 393 EXPECT_EQ(3U, Str.rfind('l')); 394 EXPECT_EQ(StringRef::npos, Str.rfind('z')); 395 EXPECT_EQ(StringRef::npos, Str.rfind("helloworld")); 396 EXPECT_EQ(0U, Str.rfind("hello")); 397 EXPECT_EQ(1U, Str.rfind("ello")); 398 EXPECT_EQ(StringRef::npos, Str.rfind("zz")); 399 400 EXPECT_EQ(2U, Str.find_first_of('l')); 401 EXPECT_EQ(1U, Str.find_first_of("el")); 402 EXPECT_EQ(StringRef::npos, Str.find_first_of("xyz")); 403 404 EXPECT_EQ(1U, Str.find_first_not_of('h')); 405 EXPECT_EQ(4U, Str.find_first_not_of("hel")); 406 EXPECT_EQ(StringRef::npos, Str.find_first_not_of("hello")); 407 408 EXPECT_EQ(3U, Str.find_last_not_of('o')); 409 EXPECT_EQ(1U, Str.find_last_not_of("lo")); 410 EXPECT_EQ(StringRef::npos, Str.find_last_not_of("helo")); 411 } 412 413 TEST(StringRefTest, Count) { 414 StringRef Str("hello"); 415 EXPECT_EQ(2U, Str.count('l')); 416 EXPECT_EQ(1U, Str.count('o')); 417 EXPECT_EQ(0U, Str.count('z')); 418 EXPECT_EQ(0U, Str.count("helloworld")); 419 EXPECT_EQ(1U, Str.count("hello")); 420 EXPECT_EQ(1U, Str.count("ello")); 421 EXPECT_EQ(0U, Str.count("zz")); 422 } 423 424 TEST(StringRefTest, EditDistance) { 425 StringRef Str("hello"); 426 EXPECT_EQ(2U, Str.edit_distance("hill")); 427 } 428 429 TEST(StringRefTest, Misc) { 430 std::string Storage; 431 raw_string_ostream OS(Storage); 432 OS << StringRef("hello"); 433 EXPECT_EQ("hello", OS.str()); 434 } 435 436 TEST(StringRefTest, Hashing) { 437 EXPECT_EQ(hash_value(std::string()), hash_value(StringRef())); 438 EXPECT_EQ(hash_value(std::string()), hash_value(StringRef(""))); 439 std::string S = "hello world"; 440 hash_code H = hash_value(S); 441 EXPECT_EQ(H, hash_value(StringRef("hello world"))); 442 EXPECT_EQ(H, hash_value(StringRef(S))); 443 EXPECT_NE(H, hash_value(StringRef("hello worl"))); 444 EXPECT_EQ(hash_value(std::string("hello worl")), 445 hash_value(StringRef("hello worl"))); 446 EXPECT_NE(H, hash_value(StringRef("hello world "))); 447 EXPECT_EQ(hash_value(std::string("hello world ")), 448 hash_value(StringRef("hello world "))); 449 EXPECT_EQ(H, hash_value(StringRef("hello world\0"))); 450 EXPECT_NE(hash_value(std::string("ello worl")), 451 hash_value(StringRef("hello world").slice(1, -1))); 452 } 453 454 struct UnsignedPair { 455 const char *Str; 456 uint64_t Expected; 457 } Unsigned[] = 458 { {"0", 0} 459 , {"255", 255} 460 , {"256", 256} 461 , {"65535", 65535} 462 , {"65536", 65536} 463 , {"4294967295", 4294967295ULL} 464 , {"4294967296", 4294967296ULL} 465 , {"18446744073709551615", 18446744073709551615ULL} 466 , {"042", 34} 467 , {"0x42", 66} 468 , {"0b101010", 42} 469 }; 470 471 struct SignedPair { 472 const char *Str; 473 int64_t Expected; 474 } Signed[] = 475 { {"0", 0} 476 , {"-0", 0} 477 , {"127", 127} 478 , {"128", 128} 479 , {"-128", -128} 480 , {"-129", -129} 481 , {"32767", 32767} 482 , {"32768", 32768} 483 , {"-32768", -32768} 484 , {"-32769", -32769} 485 , {"2147483647", 2147483647LL} 486 , {"2147483648", 2147483648LL} 487 , {"-2147483648", -2147483648LL} 488 , {"-2147483649", -2147483649LL} 489 , {"-9223372036854775808", -(9223372036854775807LL) - 1} 490 , {"042", 34} 491 , {"0x42", 66} 492 , {"0b101010", 42} 493 , {"-042", -34} 494 , {"-0x42", -66} 495 , {"-0b101010", -42} 496 }; 497 498 TEST(StringRefTest, getAsInteger) { 499 uint8_t U8; 500 uint16_t U16; 501 uint32_t U32; 502 uint64_t U64; 503 504 for (size_t i = 0; i < array_lengthof(Unsigned); ++i) { 505 bool U8Success = StringRef(Unsigned[i].Str).getAsInteger(0, U8); 506 if (static_cast<uint8_t>(Unsigned[i].Expected) == Unsigned[i].Expected) { 507 ASSERT_FALSE(U8Success); 508 EXPECT_EQ(U8, Unsigned[i].Expected); 509 } else { 510 ASSERT_TRUE(U8Success); 511 } 512 bool U16Success = StringRef(Unsigned[i].Str).getAsInteger(0, U16); 513 if (static_cast<uint16_t>(Unsigned[i].Expected) == Unsigned[i].Expected) { 514 ASSERT_FALSE(U16Success); 515 EXPECT_EQ(U16, Unsigned[i].Expected); 516 } else { 517 ASSERT_TRUE(U16Success); 518 } 519 bool U32Success = StringRef(Unsigned[i].Str).getAsInteger(0, U32); 520 if (static_cast<uint32_t>(Unsigned[i].Expected) == Unsigned[i].Expected) { 521 ASSERT_FALSE(U32Success); 522 EXPECT_EQ(U32, Unsigned[i].Expected); 523 } else { 524 ASSERT_TRUE(U32Success); 525 } 526 bool U64Success = StringRef(Unsigned[i].Str).getAsInteger(0, U64); 527 if (static_cast<uint64_t>(Unsigned[i].Expected) == Unsigned[i].Expected) { 528 ASSERT_FALSE(U64Success); 529 EXPECT_EQ(U64, Unsigned[i].Expected); 530 } else { 531 ASSERT_TRUE(U64Success); 532 } 533 } 534 535 int8_t S8; 536 int16_t S16; 537 int32_t S32; 538 int64_t S64; 539 540 for (size_t i = 0; i < array_lengthof(Signed); ++i) { 541 bool S8Success = StringRef(Signed[i].Str).getAsInteger(0, S8); 542 if (static_cast<int8_t>(Signed[i].Expected) == Signed[i].Expected) { 543 ASSERT_FALSE(S8Success); 544 EXPECT_EQ(S8, Signed[i].Expected); 545 } else { 546 ASSERT_TRUE(S8Success); 547 } 548 bool S16Success = StringRef(Signed[i].Str).getAsInteger(0, S16); 549 if (static_cast<int16_t>(Signed[i].Expected) == Signed[i].Expected) { 550 ASSERT_FALSE(S16Success); 551 EXPECT_EQ(S16, Signed[i].Expected); 552 } else { 553 ASSERT_TRUE(S16Success); 554 } 555 bool S32Success = StringRef(Signed[i].Str).getAsInteger(0, S32); 556 if (static_cast<int32_t>(Signed[i].Expected) == Signed[i].Expected) { 557 ASSERT_FALSE(S32Success); 558 EXPECT_EQ(S32, Signed[i].Expected); 559 } else { 560 ASSERT_TRUE(S32Success); 561 } 562 bool S64Success = StringRef(Signed[i].Str).getAsInteger(0, S64); 563 if (static_cast<int64_t>(Signed[i].Expected) == Signed[i].Expected) { 564 ASSERT_FALSE(S64Success); 565 EXPECT_EQ(S64, Signed[i].Expected); 566 } else { 567 ASSERT_TRUE(S64Success); 568 } 569 } 570 } 571 572 573 static const char* BadStrings[] = { 574 "" // empty string 575 , "18446744073709551617" // value just over max 576 , "123456789012345678901" // value way too large 577 , "4t23v" // illegal decimal characters 578 , "0x123W56" // illegal hex characters 579 , "0b2" // illegal bin characters 580 , "08" // illegal oct characters 581 , "0o8" // illegal oct characters 582 , "-123" // negative unsigned value 583 }; 584 585 586 TEST(StringRefTest, getAsUnsignedIntegerBadStrings) { 587 unsigned long long U64; 588 for (size_t i = 0; i < array_lengthof(BadStrings); ++i) { 589 bool IsBadNumber = StringRef(BadStrings[i]).getAsInteger(0, U64); 590 ASSERT_TRUE(IsBadNumber); 591 } 592 } 593 594 struct ConsumeUnsignedPair { 595 const char *Str; 596 uint64_t Expected; 597 const char *Leftover; 598 } ConsumeUnsigned[] = { 599 {"0", 0, ""}, 600 {"255", 255, ""}, 601 {"256", 256, ""}, 602 {"65535", 65535, ""}, 603 {"65536", 65536, ""}, 604 {"4294967295", 4294967295ULL, ""}, 605 {"4294967296", 4294967296ULL, ""}, 606 {"255A376", 255, "A376"}, 607 {"18446744073709551615", 18446744073709551615ULL, ""}, 608 {"18446744073709551615ABC", 18446744073709551615ULL, "ABC"}, 609 {"042", 34, ""}, 610 {"0x42", 66, ""}, 611 {"0x42-0x34", 66, "-0x34"}, 612 {"0b101010", 42, ""}, 613 {"0429F", 042, "9F"}, // Auto-sensed octal radix, invalid digit 614 {"0x42G12", 0x42, "G12"}, // Auto-sensed hex radix, invalid digit 615 {"0b10101020101", 42, "20101"}}; // Auto-sensed binary radix, invalid digit. 616 617 struct ConsumeSignedPair { 618 const char *Str; 619 int64_t Expected; 620 const char *Leftover; 621 } ConsumeSigned[] = { 622 {"0", 0, ""}, 623 {"-0", 0, ""}, 624 {"0-1", 0, "-1"}, 625 {"-0-1", 0, "-1"}, 626 {"127", 127, ""}, 627 {"128", 128, ""}, 628 {"127-1", 127, "-1"}, 629 {"128-1", 128, "-1"}, 630 {"-128", -128, ""}, 631 {"-129", -129, ""}, 632 {"-128-1", -128, "-1"}, 633 {"-129-1", -129, "-1"}, 634 {"32767", 32767, ""}, 635 {"32768", 32768, ""}, 636 {"32767-1", 32767, "-1"}, 637 {"32768-1", 32768, "-1"}, 638 {"-32768", -32768, ""}, 639 {"-32769", -32769, ""}, 640 {"-32768-1", -32768, "-1"}, 641 {"-32769-1", -32769, "-1"}, 642 {"2147483647", 2147483647LL, ""}, 643 {"2147483648", 2147483648LL, ""}, 644 {"2147483647-1", 2147483647LL, "-1"}, 645 {"2147483648-1", 2147483648LL, "-1"}, 646 {"-2147483648", -2147483648LL, ""}, 647 {"-2147483649", -2147483649LL, ""}, 648 {"-2147483648-1", -2147483648LL, "-1"}, 649 {"-2147483649-1", -2147483649LL, "-1"}, 650 {"-9223372036854775808", -(9223372036854775807LL) - 1, ""}, 651 {"-9223372036854775808-1", -(9223372036854775807LL) - 1, "-1"}, 652 {"042", 34, ""}, 653 {"042-1", 34, "-1"}, 654 {"0x42", 66, ""}, 655 {"0x42-1", 66, "-1"}, 656 {"0b101010", 42, ""}, 657 {"0b101010-1", 42, "-1"}, 658 {"-042", -34, ""}, 659 {"-042-1", -34, "-1"}, 660 {"-0x42", -66, ""}, 661 {"-0x42-1", -66, "-1"}, 662 {"-0b101010", -42, ""}, 663 {"-0b101010-1", -42, "-1"}}; 664 665 TEST(StringRefTest, consumeIntegerUnsigned) { 666 uint8_t U8; 667 uint16_t U16; 668 uint32_t U32; 669 uint64_t U64; 670 671 for (size_t i = 0; i < array_lengthof(ConsumeUnsigned); ++i) { 672 StringRef Str = ConsumeUnsigned[i].Str; 673 bool U8Success = Str.consumeInteger(0, U8); 674 if (static_cast<uint8_t>(ConsumeUnsigned[i].Expected) == 675 ConsumeUnsigned[i].Expected) { 676 ASSERT_FALSE(U8Success); 677 EXPECT_EQ(U8, ConsumeUnsigned[i].Expected); 678 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover); 679 } else { 680 ASSERT_TRUE(U8Success); 681 } 682 683 Str = ConsumeUnsigned[i].Str; 684 bool U16Success = Str.consumeInteger(0, U16); 685 if (static_cast<uint16_t>(ConsumeUnsigned[i].Expected) == 686 ConsumeUnsigned[i].Expected) { 687 ASSERT_FALSE(U16Success); 688 EXPECT_EQ(U16, ConsumeUnsigned[i].Expected); 689 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover); 690 } else { 691 ASSERT_TRUE(U16Success); 692 } 693 694 Str = ConsumeUnsigned[i].Str; 695 bool U32Success = Str.consumeInteger(0, U32); 696 if (static_cast<uint32_t>(ConsumeUnsigned[i].Expected) == 697 ConsumeUnsigned[i].Expected) { 698 ASSERT_FALSE(U32Success); 699 EXPECT_EQ(U32, ConsumeUnsigned[i].Expected); 700 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover); 701 } else { 702 ASSERT_TRUE(U32Success); 703 } 704 705 Str = ConsumeUnsigned[i].Str; 706 bool U64Success = Str.consumeInteger(0, U64); 707 if (static_cast<uint64_t>(ConsumeUnsigned[i].Expected) == 708 ConsumeUnsigned[i].Expected) { 709 ASSERT_FALSE(U64Success); 710 EXPECT_EQ(U64, ConsumeUnsigned[i].Expected); 711 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover); 712 } else { 713 ASSERT_TRUE(U64Success); 714 } 715 } 716 } 717 718 TEST(StringRefTest, consumeIntegerSigned) { 719 int8_t S8; 720 int16_t S16; 721 int32_t S32; 722 int64_t S64; 723 724 for (size_t i = 0; i < array_lengthof(ConsumeSigned); ++i) { 725 StringRef Str = ConsumeSigned[i].Str; 726 bool S8Success = Str.consumeInteger(0, S8); 727 if (static_cast<int8_t>(ConsumeSigned[i].Expected) == 728 ConsumeSigned[i].Expected) { 729 ASSERT_FALSE(S8Success); 730 EXPECT_EQ(S8, ConsumeSigned[i].Expected); 731 EXPECT_EQ(Str, ConsumeSigned[i].Leftover); 732 } else { 733 ASSERT_TRUE(S8Success); 734 } 735 736 Str = ConsumeSigned[i].Str; 737 bool S16Success = Str.consumeInteger(0, S16); 738 if (static_cast<int16_t>(ConsumeSigned[i].Expected) == 739 ConsumeSigned[i].Expected) { 740 ASSERT_FALSE(S16Success); 741 EXPECT_EQ(S16, ConsumeSigned[i].Expected); 742 EXPECT_EQ(Str, ConsumeSigned[i].Leftover); 743 } else { 744 ASSERT_TRUE(S16Success); 745 } 746 747 Str = ConsumeSigned[i].Str; 748 bool S32Success = Str.consumeInteger(0, S32); 749 if (static_cast<int32_t>(ConsumeSigned[i].Expected) == 750 ConsumeSigned[i].Expected) { 751 ASSERT_FALSE(S32Success); 752 EXPECT_EQ(S32, ConsumeSigned[i].Expected); 753 EXPECT_EQ(Str, ConsumeSigned[i].Leftover); 754 } else { 755 ASSERT_TRUE(S32Success); 756 } 757 758 Str = ConsumeSigned[i].Str; 759 bool S64Success = Str.consumeInteger(0, S64); 760 if (static_cast<int64_t>(ConsumeSigned[i].Expected) == 761 ConsumeSigned[i].Expected) { 762 ASSERT_FALSE(S64Success); 763 EXPECT_EQ(S64, ConsumeSigned[i].Expected); 764 EXPECT_EQ(Str, ConsumeSigned[i].Leftover); 765 } else { 766 ASSERT_TRUE(S64Success); 767 } 768 } 769 } 770 771 static const char *join_input[] = { "a", "b", "c" }; 772 static const char join_result1[] = "a"; 773 static const char join_result2[] = "a:b:c"; 774 static const char join_result3[] = "a::b::c"; 775 776 TEST(StringRefTest, joinStrings) { 777 std::vector<StringRef> v1; 778 std::vector<std::string> v2; 779 for (size_t i = 0; i < array_lengthof(join_input); ++i) { 780 v1.push_back(join_input[i]); 781 v2.push_back(join_input[i]); 782 } 783 784 bool v1_join1 = join(v1.begin(), v1.begin() + 1, ":") == join_result1; 785 EXPECT_TRUE(v1_join1); 786 bool v1_join2 = join(v1.begin(), v1.end(), ":") == join_result2; 787 EXPECT_TRUE(v1_join2); 788 bool v1_join3 = join(v1.begin(), v1.end(), "::") == join_result3; 789 EXPECT_TRUE(v1_join3); 790 791 bool v2_join1 = join(v2.begin(), v2.begin() + 1, ":") == join_result1; 792 EXPECT_TRUE(v2_join1); 793 bool v2_join2 = join(v2.begin(), v2.end(), ":") == join_result2; 794 EXPECT_TRUE(v2_join2); 795 bool v2_join3 = join(v2.begin(), v2.end(), "::") == join_result3; 796 EXPECT_TRUE(v2_join3); 797 } 798 799 800 TEST(StringRefTest, AllocatorCopy) { 801 BumpPtrAllocator Alloc; 802 // First test empty strings. We don't want these to allocate anything on the 803 // allocator. 804 StringRef StrEmpty = ""; 805 StringRef StrEmptyc = StrEmpty.copy(Alloc); 806 EXPECT_TRUE(StrEmpty.equals(StrEmptyc)); 807 EXPECT_EQ(StrEmptyc.data(), nullptr); 808 EXPECT_EQ(StrEmptyc.size(), 0u); 809 EXPECT_EQ(Alloc.getTotalMemory(), 0u); 810 811 StringRef Str1 = "hello"; 812 StringRef Str2 = "bye"; 813 StringRef Str1c = Str1.copy(Alloc); 814 StringRef Str2c = Str2.copy(Alloc); 815 EXPECT_TRUE(Str1.equals(Str1c)); 816 EXPECT_NE(Str1.data(), Str1c.data()); 817 EXPECT_TRUE(Str2.equals(Str2c)); 818 EXPECT_NE(Str2.data(), Str2c.data()); 819 } 820 821 TEST(StringRefTest, Drop) { 822 StringRef Test("StringRefTest::Drop"); 823 824 StringRef Dropped = Test.drop_front(5); 825 EXPECT_EQ(Dropped, "gRefTest::Drop"); 826 827 Dropped = Test.drop_back(5); 828 EXPECT_EQ(Dropped, "StringRefTest:"); 829 830 Dropped = Test.drop_front(0); 831 EXPECT_EQ(Dropped, Test); 832 833 Dropped = Test.drop_back(0); 834 EXPECT_EQ(Dropped, Test); 835 836 Dropped = Test.drop_front(Test.size()); 837 EXPECT_TRUE(Dropped.empty()); 838 839 Dropped = Test.drop_back(Test.size()); 840 EXPECT_TRUE(Dropped.empty()); 841 } 842 843 TEST(StringRefTest, Take) { 844 StringRef Test("StringRefTest::Take"); 845 846 StringRef Taken = Test.take_front(5); 847 EXPECT_EQ(Taken, "Strin"); 848 849 Taken = Test.take_back(5); 850 EXPECT_EQ(Taken, ":Take"); 851 852 Taken = Test.take_front(Test.size()); 853 EXPECT_EQ(Taken, Test); 854 855 Taken = Test.take_back(Test.size()); 856 EXPECT_EQ(Taken, Test); 857 858 Taken = Test.take_front(0); 859 EXPECT_TRUE(Taken.empty()); 860 861 Taken = Test.take_back(0); 862 EXPECT_TRUE(Taken.empty()); 863 } 864 865 } // end anonymous namespace 866