1 // Copyright 2008, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 // 30 // This file tests the internal cross-platform support utilities. 31 #include <stdio.h> 32 33 #include "gtest/internal/gtest-port.h" 34 35 #ifdef GTEST_OS_MAC 36 #include <time.h> 37 #endif // GTEST_OS_MAC 38 39 #include <chrono> // NOLINT 40 #include <list> 41 #include <memory> 42 #include <string> 43 #include <thread> // NOLINT 44 #include <utility> // For std::pair and std::make_pair. 45 #include <vector> 46 47 #include "gtest/gtest-spi.h" 48 #include "gtest/gtest.h" 49 #include "src/gtest-internal-inl.h" 50 51 using std::make_pair; 52 using std::pair; 53 54 namespace testing { 55 namespace internal { 56 57 TEST(IsXDigitTest, WorksForNarrowAscii) { 58 EXPECT_TRUE(IsXDigit('0')); 59 EXPECT_TRUE(IsXDigit('9')); 60 EXPECT_TRUE(IsXDigit('A')); 61 EXPECT_TRUE(IsXDigit('F')); 62 EXPECT_TRUE(IsXDigit('a')); 63 EXPECT_TRUE(IsXDigit('f')); 64 65 EXPECT_FALSE(IsXDigit('-')); 66 EXPECT_FALSE(IsXDigit('g')); 67 EXPECT_FALSE(IsXDigit('G')); 68 } 69 70 TEST(IsXDigitTest, ReturnsFalseForNarrowNonAscii) { 71 EXPECT_FALSE(IsXDigit(static_cast<char>('\x80'))); 72 EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80'))); 73 } 74 75 TEST(IsXDigitTest, WorksForWideAscii) { 76 EXPECT_TRUE(IsXDigit(L'0')); 77 EXPECT_TRUE(IsXDigit(L'9')); 78 EXPECT_TRUE(IsXDigit(L'A')); 79 EXPECT_TRUE(IsXDigit(L'F')); 80 EXPECT_TRUE(IsXDigit(L'a')); 81 EXPECT_TRUE(IsXDigit(L'f')); 82 83 EXPECT_FALSE(IsXDigit(L'-')); 84 EXPECT_FALSE(IsXDigit(L'g')); 85 EXPECT_FALSE(IsXDigit(L'G')); 86 } 87 88 TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) { 89 EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80))); 90 EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80))); 91 EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100))); 92 } 93 94 class Base { 95 public: 96 Base() : member_(0) {} 97 explicit Base(int n) : member_(n) {} 98 Base(const Base&) = default; 99 Base& operator=(const Base&) = default; 100 virtual ~Base() = default; 101 int member() { return member_; } 102 103 private: 104 int member_; 105 }; 106 107 class Derived : public Base { 108 public: 109 explicit Derived(int n) : Base(n) {} 110 }; 111 112 TEST(ImplicitCastTest, ConvertsPointers) { 113 Derived derived(0); 114 EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived)); 115 } 116 117 TEST(ImplicitCastTest, CanUseInheritance) { 118 Derived derived(1); 119 Base base = ::testing::internal::ImplicitCast_<Base>(derived); 120 EXPECT_EQ(derived.member(), base.member()); 121 } 122 123 class Castable { 124 public: 125 explicit Castable(bool* converted) : converted_(converted) {} 126 operator Base() { 127 *converted_ = true; 128 return Base(); 129 } 130 131 private: 132 bool* converted_; 133 }; 134 135 TEST(ImplicitCastTest, CanUseNonConstCastOperator) { 136 bool converted = false; 137 Castable castable(&converted); 138 Base base = ::testing::internal::ImplicitCast_<Base>(castable); 139 EXPECT_TRUE(converted); 140 } 141 142 class ConstCastable { 143 public: 144 explicit ConstCastable(bool* converted) : converted_(converted) {} 145 operator Base() const { 146 *converted_ = true; 147 return Base(); 148 } 149 150 private: 151 bool* converted_; 152 }; 153 154 TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) { 155 bool converted = false; 156 const ConstCastable const_castable(&converted); 157 Base base = ::testing::internal::ImplicitCast_<Base>(const_castable); 158 EXPECT_TRUE(converted); 159 } 160 161 class ConstAndNonConstCastable { 162 public: 163 ConstAndNonConstCastable(bool* converted, bool* const_converted) 164 : converted_(converted), const_converted_(const_converted) {} 165 operator Base() { 166 *converted_ = true; 167 return Base(); 168 } 169 operator Base() const { 170 *const_converted_ = true; 171 return Base(); 172 } 173 174 private: 175 bool* converted_; 176 bool* const_converted_; 177 }; 178 179 TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) { 180 bool converted = false; 181 bool const_converted = false; 182 ConstAndNonConstCastable castable(&converted, &const_converted); 183 Base base = ::testing::internal::ImplicitCast_<Base>(castable); 184 EXPECT_TRUE(converted); 185 EXPECT_FALSE(const_converted); 186 187 converted = false; 188 const_converted = false; 189 const ConstAndNonConstCastable const_castable(&converted, &const_converted); 190 base = ::testing::internal::ImplicitCast_<Base>(const_castable); 191 EXPECT_FALSE(converted); 192 EXPECT_TRUE(const_converted); 193 } 194 195 class To { 196 public: 197 To(bool* converted) { *converted = true; } // NOLINT 198 }; 199 200 TEST(ImplicitCastTest, CanUseImplicitConstructor) { 201 bool converted = false; 202 To to = ::testing::internal::ImplicitCast_<To>(&converted); 203 (void)to; 204 EXPECT_TRUE(converted); 205 } 206 207 // The following code intentionally tests a suboptimal syntax. 208 #ifdef __GNUC__ 209 #pragma GCC diagnostic push 210 #pragma GCC diagnostic ignored "-Wdangling-else" 211 #pragma GCC diagnostic ignored "-Wempty-body" 212 #pragma GCC diagnostic ignored "-Wpragmas" 213 #endif 214 TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) { 215 if (AlwaysFalse()) 216 GTEST_CHECK_(false) << "This should never be executed; " 217 "It's a compilation test only."; 218 219 if (AlwaysTrue()) 220 GTEST_CHECK_(true); 221 else 222 ; // NOLINT 223 224 if (AlwaysFalse()) 225 ; // NOLINT 226 else 227 GTEST_CHECK_(true) << ""; 228 } 229 #ifdef __GNUC__ 230 #pragma GCC diagnostic pop 231 #endif 232 233 TEST(GtestCheckSyntaxTest, WorksWithSwitch) { 234 switch (0) { 235 case 1: 236 break; 237 default: 238 GTEST_CHECK_(true); 239 } 240 241 switch (0) 242 case 0: 243 GTEST_CHECK_(true) << "Check failed in switch case"; 244 } 245 246 // Verifies behavior of FormatFileLocation. 247 TEST(FormatFileLocationTest, FormatsFileLocation) { 248 EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42)); 249 EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42)); 250 } 251 252 TEST(FormatFileLocationTest, FormatsUnknownFile) { 253 EXPECT_PRED_FORMAT2(IsSubstring, "unknown file", 254 FormatFileLocation(nullptr, 42)); 255 EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(nullptr, 42)); 256 } 257 258 TEST(FormatFileLocationTest, FormatsUknownLine) { 259 EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1)); 260 } 261 262 TEST(FormatFileLocationTest, FormatsUknownFileAndLine) { 263 EXPECT_EQ("unknown file:", FormatFileLocation(nullptr, -1)); 264 } 265 266 // Verifies behavior of FormatCompilerIndependentFileLocation. 267 TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) { 268 EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42)); 269 } 270 271 TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) { 272 EXPECT_EQ("unknown file:42", 273 FormatCompilerIndependentFileLocation(nullptr, 42)); 274 } 275 276 TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) { 277 EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1)); 278 } 279 280 TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) { 281 EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(nullptr, -1)); 282 } 283 284 #if defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) || \ 285 defined(GTEST_OS_QNX) || defined(GTEST_OS_FUCHSIA) || \ 286 defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) || \ 287 defined(GTEST_OS_GNU_KFREEBSD) || defined(GTEST_OS_NETBSD) || \ 288 defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_GNU_HURD) 289 void* ThreadFunc(void* data) { 290 internal::Mutex* mutex = static_cast<internal::Mutex*>(data); 291 mutex->Lock(); 292 mutex->Unlock(); 293 return nullptr; 294 } 295 296 TEST(GetThreadCountTest, ReturnsCorrectValue) { 297 size_t starting_count; 298 size_t thread_count_after_create; 299 size_t thread_count_after_join; 300 301 // We can't guarantee that no other thread was created or destroyed between 302 // any two calls to GetThreadCount(). We make multiple attempts, hoping that 303 // background noise is not constant and we would see the "right" values at 304 // some point. 305 for (int attempt = 0; attempt < 20; ++attempt) { 306 starting_count = GetThreadCount(); 307 pthread_t thread_id; 308 309 internal::Mutex mutex; 310 { 311 internal::MutexLock lock(&mutex); 312 pthread_attr_t attr; 313 ASSERT_EQ(0, pthread_attr_init(&attr)); 314 ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE)); 315 316 const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex); 317 ASSERT_EQ(0, pthread_attr_destroy(&attr)); 318 ASSERT_EQ(0, status); 319 } 320 321 thread_count_after_create = GetThreadCount(); 322 323 void* dummy; 324 ASSERT_EQ(0, pthread_join(thread_id, &dummy)); 325 326 // Join before we decide whether we need to retry the test. Retry if an 327 // arbitrary other thread was created or destroyed in the meantime. 328 if (thread_count_after_create != starting_count + 1) continue; 329 330 // The OS may not immediately report the updated thread count after 331 // joining a thread, causing flakiness in this test. To counter that, we 332 // wait for up to .5 seconds for the OS to report the correct value. 333 bool thread_count_matches = false; 334 for (int i = 0; i < 5; ++i) { 335 thread_count_after_join = GetThreadCount(); 336 if (thread_count_after_join == starting_count) { 337 thread_count_matches = true; 338 break; 339 } 340 341 std::this_thread::sleep_for(std::chrono::milliseconds(100)); 342 } 343 344 // Retry if an arbitrary other thread was created or destroyed. 345 if (!thread_count_matches) continue; 346 347 break; 348 } 349 350 EXPECT_EQ(thread_count_after_create, starting_count + 1); 351 EXPECT_EQ(thread_count_after_join, starting_count); 352 } 353 #else 354 TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) { 355 EXPECT_EQ(0U, GetThreadCount()); 356 } 357 #endif // GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX || GTEST_OS_FUCHSIA 358 359 TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) { 360 const bool a_false_condition = false; 361 const char regex[] = 362 #ifdef _MSC_VER 363 "googletest-port-test\\.cc\\(\\d+\\):" 364 #elif defined(GTEST_USES_POSIX_RE) 365 "googletest-port-test\\.cc:[0-9]+" 366 #else 367 "googletest-port-test\\.cc:\\d+" 368 #endif // _MSC_VER 369 ".*a_false_condition.*Extra info.*"; 370 371 EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info", 372 regex); 373 } 374 375 #ifdef GTEST_HAS_DEATH_TEST 376 377 TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) { 378 EXPECT_EXIT( 379 { 380 GTEST_CHECK_(true) << "Extra info"; 381 ::std::cerr << "Success\n"; 382 exit(0); 383 }, 384 ::testing::ExitedWithCode(0), "Success"); 385 } 386 387 #endif // GTEST_HAS_DEATH_TEST 388 389 // Verifies that Google Test choose regular expression engine appropriate to 390 // the platform. The test will produce compiler errors in case of failure. 391 // For simplicity, we only cover the most important platforms here. 392 TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) { 393 #ifdef GTEST_HAS_ABSL 394 EXPECT_TRUE(GTEST_USES_RE2); 395 #elif GTEST_HAS_POSIX_RE 396 EXPECT_TRUE(GTEST_USES_POSIX_RE); 397 #else 398 EXPECT_TRUE(GTEST_USES_SIMPLE_RE); 399 #endif 400 } 401 402 #ifdef GTEST_USES_POSIX_RE 403 404 template <typename Str> 405 class RETest : public ::testing::Test {}; 406 407 // Defines StringTypes as the list of all string types that class RE 408 // supports. 409 typedef testing::Types< ::std::string, const char*> StringTypes; 410 411 TYPED_TEST_SUITE(RETest, StringTypes); 412 413 // Tests RE's implicit constructors. 414 TYPED_TEST(RETest, ImplicitConstructorWorks) { 415 const RE empty(TypeParam("")); 416 EXPECT_STREQ("", empty.pattern()); 417 418 const RE simple(TypeParam("hello")); 419 EXPECT_STREQ("hello", simple.pattern()); 420 421 const RE normal(TypeParam(".*(\\w+)")); 422 EXPECT_STREQ(".*(\\w+)", normal.pattern()); 423 } 424 425 // Tests that RE's constructors reject invalid regular expressions. 426 TYPED_TEST(RETest, RejectsInvalidRegex) { 427 EXPECT_NONFATAL_FAILURE( 428 { const RE invalid(TypeParam("?")); }, 429 "\"?\" is not a valid POSIX Extended regular expression."); 430 } 431 432 // Tests RE::FullMatch(). 433 TYPED_TEST(RETest, FullMatchWorks) { 434 const RE empty(TypeParam("")); 435 EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty)); 436 EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty)); 437 438 const RE re(TypeParam("a.*z")); 439 EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re)); 440 EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re)); 441 EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re)); 442 EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re)); 443 } 444 445 // Tests RE::PartialMatch(). 446 TYPED_TEST(RETest, PartialMatchWorks) { 447 const RE empty(TypeParam("")); 448 EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty)); 449 EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty)); 450 451 const RE re(TypeParam("a.*z")); 452 EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re)); 453 EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re)); 454 EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re)); 455 EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re)); 456 EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re)); 457 } 458 459 #elif defined(GTEST_USES_SIMPLE_RE) 460 461 TEST(IsInSetTest, NulCharIsNotInAnySet) { 462 EXPECT_FALSE(IsInSet('\0', "")); 463 EXPECT_FALSE(IsInSet('\0', "\0")); 464 EXPECT_FALSE(IsInSet('\0', "a")); 465 } 466 467 TEST(IsInSetTest, WorksForNonNulChars) { 468 EXPECT_FALSE(IsInSet('a', "Ab")); 469 EXPECT_FALSE(IsInSet('c', "")); 470 471 EXPECT_TRUE(IsInSet('b', "bcd")); 472 EXPECT_TRUE(IsInSet('b', "ab")); 473 } 474 475 TEST(IsAsciiDigitTest, IsFalseForNonDigit) { 476 EXPECT_FALSE(IsAsciiDigit('\0')); 477 EXPECT_FALSE(IsAsciiDigit(' ')); 478 EXPECT_FALSE(IsAsciiDigit('+')); 479 EXPECT_FALSE(IsAsciiDigit('-')); 480 EXPECT_FALSE(IsAsciiDigit('.')); 481 EXPECT_FALSE(IsAsciiDigit('a')); 482 } 483 484 TEST(IsAsciiDigitTest, IsTrueForDigit) { 485 EXPECT_TRUE(IsAsciiDigit('0')); 486 EXPECT_TRUE(IsAsciiDigit('1')); 487 EXPECT_TRUE(IsAsciiDigit('5')); 488 EXPECT_TRUE(IsAsciiDigit('9')); 489 } 490 491 TEST(IsAsciiPunctTest, IsFalseForNonPunct) { 492 EXPECT_FALSE(IsAsciiPunct('\0')); 493 EXPECT_FALSE(IsAsciiPunct(' ')); 494 EXPECT_FALSE(IsAsciiPunct('\n')); 495 EXPECT_FALSE(IsAsciiPunct('a')); 496 EXPECT_FALSE(IsAsciiPunct('0')); 497 } 498 499 TEST(IsAsciiPunctTest, IsTrueForPunct) { 500 for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) { 501 EXPECT_PRED1(IsAsciiPunct, *p); 502 } 503 } 504 505 TEST(IsRepeatTest, IsFalseForNonRepeatChar) { 506 EXPECT_FALSE(IsRepeat('\0')); 507 EXPECT_FALSE(IsRepeat(' ')); 508 EXPECT_FALSE(IsRepeat('a')); 509 EXPECT_FALSE(IsRepeat('1')); 510 EXPECT_FALSE(IsRepeat('-')); 511 } 512 513 TEST(IsRepeatTest, IsTrueForRepeatChar) { 514 EXPECT_TRUE(IsRepeat('?')); 515 EXPECT_TRUE(IsRepeat('*')); 516 EXPECT_TRUE(IsRepeat('+')); 517 } 518 519 TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) { 520 EXPECT_FALSE(IsAsciiWhiteSpace('\0')); 521 EXPECT_FALSE(IsAsciiWhiteSpace('a')); 522 EXPECT_FALSE(IsAsciiWhiteSpace('1')); 523 EXPECT_FALSE(IsAsciiWhiteSpace('+')); 524 EXPECT_FALSE(IsAsciiWhiteSpace('_')); 525 } 526 527 TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) { 528 EXPECT_TRUE(IsAsciiWhiteSpace(' ')); 529 EXPECT_TRUE(IsAsciiWhiteSpace('\n')); 530 EXPECT_TRUE(IsAsciiWhiteSpace('\r')); 531 EXPECT_TRUE(IsAsciiWhiteSpace('\t')); 532 EXPECT_TRUE(IsAsciiWhiteSpace('\v')); 533 EXPECT_TRUE(IsAsciiWhiteSpace('\f')); 534 } 535 536 TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) { 537 EXPECT_FALSE(IsAsciiWordChar('\0')); 538 EXPECT_FALSE(IsAsciiWordChar('+')); 539 EXPECT_FALSE(IsAsciiWordChar('.')); 540 EXPECT_FALSE(IsAsciiWordChar(' ')); 541 EXPECT_FALSE(IsAsciiWordChar('\n')); 542 } 543 544 TEST(IsAsciiWordCharTest, IsTrueForLetter) { 545 EXPECT_TRUE(IsAsciiWordChar('a')); 546 EXPECT_TRUE(IsAsciiWordChar('b')); 547 EXPECT_TRUE(IsAsciiWordChar('A')); 548 EXPECT_TRUE(IsAsciiWordChar('Z')); 549 } 550 551 TEST(IsAsciiWordCharTest, IsTrueForDigit) { 552 EXPECT_TRUE(IsAsciiWordChar('0')); 553 EXPECT_TRUE(IsAsciiWordChar('1')); 554 EXPECT_TRUE(IsAsciiWordChar('7')); 555 EXPECT_TRUE(IsAsciiWordChar('9')); 556 } 557 558 TEST(IsAsciiWordCharTest, IsTrueForUnderscore) { 559 EXPECT_TRUE(IsAsciiWordChar('_')); 560 } 561 562 TEST(IsValidEscapeTest, IsFalseForNonPrintable) { 563 EXPECT_FALSE(IsValidEscape('\0')); 564 EXPECT_FALSE(IsValidEscape('\007')); 565 } 566 567 TEST(IsValidEscapeTest, IsFalseForDigit) { 568 EXPECT_FALSE(IsValidEscape('0')); 569 EXPECT_FALSE(IsValidEscape('9')); 570 } 571 572 TEST(IsValidEscapeTest, IsFalseForWhiteSpace) { 573 EXPECT_FALSE(IsValidEscape(' ')); 574 EXPECT_FALSE(IsValidEscape('\n')); 575 } 576 577 TEST(IsValidEscapeTest, IsFalseForSomeLetter) { 578 EXPECT_FALSE(IsValidEscape('a')); 579 EXPECT_FALSE(IsValidEscape('Z')); 580 } 581 582 TEST(IsValidEscapeTest, IsTrueForPunct) { 583 EXPECT_TRUE(IsValidEscape('.')); 584 EXPECT_TRUE(IsValidEscape('-')); 585 EXPECT_TRUE(IsValidEscape('^')); 586 EXPECT_TRUE(IsValidEscape('$')); 587 EXPECT_TRUE(IsValidEscape('(')); 588 EXPECT_TRUE(IsValidEscape(']')); 589 EXPECT_TRUE(IsValidEscape('{')); 590 EXPECT_TRUE(IsValidEscape('|')); 591 } 592 593 TEST(IsValidEscapeTest, IsTrueForSomeLetter) { 594 EXPECT_TRUE(IsValidEscape('d')); 595 EXPECT_TRUE(IsValidEscape('D')); 596 EXPECT_TRUE(IsValidEscape('s')); 597 EXPECT_TRUE(IsValidEscape('S')); 598 EXPECT_TRUE(IsValidEscape('w')); 599 EXPECT_TRUE(IsValidEscape('W')); 600 } 601 602 TEST(AtomMatchesCharTest, EscapedPunct) { 603 EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0')); 604 EXPECT_FALSE(AtomMatchesChar(true, '\\', ' ')); 605 EXPECT_FALSE(AtomMatchesChar(true, '_', '.')); 606 EXPECT_FALSE(AtomMatchesChar(true, '.', 'a')); 607 608 EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\')); 609 EXPECT_TRUE(AtomMatchesChar(true, '_', '_')); 610 EXPECT_TRUE(AtomMatchesChar(true, '+', '+')); 611 EXPECT_TRUE(AtomMatchesChar(true, '.', '.')); 612 } 613 614 TEST(AtomMatchesCharTest, Escaped_d) { 615 EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0')); 616 EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a')); 617 EXPECT_FALSE(AtomMatchesChar(true, 'd', '.')); 618 619 EXPECT_TRUE(AtomMatchesChar(true, 'd', '0')); 620 EXPECT_TRUE(AtomMatchesChar(true, 'd', '9')); 621 } 622 623 TEST(AtomMatchesCharTest, Escaped_D) { 624 EXPECT_FALSE(AtomMatchesChar(true, 'D', '0')); 625 EXPECT_FALSE(AtomMatchesChar(true, 'D', '9')); 626 627 EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0')); 628 EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a')); 629 EXPECT_TRUE(AtomMatchesChar(true, 'D', '-')); 630 } 631 632 TEST(AtomMatchesCharTest, Escaped_s) { 633 EXPECT_FALSE(AtomMatchesChar(true, 's', '\0')); 634 EXPECT_FALSE(AtomMatchesChar(true, 's', 'a')); 635 EXPECT_FALSE(AtomMatchesChar(true, 's', '.')); 636 EXPECT_FALSE(AtomMatchesChar(true, 's', '9')); 637 638 EXPECT_TRUE(AtomMatchesChar(true, 's', ' ')); 639 EXPECT_TRUE(AtomMatchesChar(true, 's', '\n')); 640 EXPECT_TRUE(AtomMatchesChar(true, 's', '\t')); 641 } 642 643 TEST(AtomMatchesCharTest, Escaped_S) { 644 EXPECT_FALSE(AtomMatchesChar(true, 'S', ' ')); 645 EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r')); 646 647 EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0')); 648 EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a')); 649 EXPECT_TRUE(AtomMatchesChar(true, 'S', '9')); 650 } 651 652 TEST(AtomMatchesCharTest, Escaped_w) { 653 EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0')); 654 EXPECT_FALSE(AtomMatchesChar(true, 'w', '+')); 655 EXPECT_FALSE(AtomMatchesChar(true, 'w', ' ')); 656 EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n')); 657 658 EXPECT_TRUE(AtomMatchesChar(true, 'w', '0')); 659 EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b')); 660 EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C')); 661 EXPECT_TRUE(AtomMatchesChar(true, 'w', '_')); 662 } 663 664 TEST(AtomMatchesCharTest, Escaped_W) { 665 EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A')); 666 EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b')); 667 EXPECT_FALSE(AtomMatchesChar(true, 'W', '9')); 668 EXPECT_FALSE(AtomMatchesChar(true, 'W', '_')); 669 670 EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0')); 671 EXPECT_TRUE(AtomMatchesChar(true, 'W', '*')); 672 EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n')); 673 } 674 675 TEST(AtomMatchesCharTest, EscapedWhiteSpace) { 676 EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0')); 677 EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n')); 678 EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0')); 679 EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r')); 680 EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0')); 681 EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a')); 682 EXPECT_FALSE(AtomMatchesChar(true, 't', '\0')); 683 EXPECT_FALSE(AtomMatchesChar(true, 't', 't')); 684 EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0')); 685 EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f')); 686 687 EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f')); 688 EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n')); 689 EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r')); 690 EXPECT_TRUE(AtomMatchesChar(true, 't', '\t')); 691 EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v')); 692 } 693 694 TEST(AtomMatchesCharTest, UnescapedDot) { 695 EXPECT_FALSE(AtomMatchesChar(false, '.', '\n')); 696 697 EXPECT_TRUE(AtomMatchesChar(false, '.', '\0')); 698 EXPECT_TRUE(AtomMatchesChar(false, '.', '.')); 699 EXPECT_TRUE(AtomMatchesChar(false, '.', 'a')); 700 EXPECT_TRUE(AtomMatchesChar(false, '.', ' ')); 701 } 702 703 TEST(AtomMatchesCharTest, UnescapedChar) { 704 EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0')); 705 EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b')); 706 EXPECT_FALSE(AtomMatchesChar(false, '$', 'a')); 707 708 EXPECT_TRUE(AtomMatchesChar(false, '$', '$')); 709 EXPECT_TRUE(AtomMatchesChar(false, '5', '5')); 710 EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z')); 711 } 712 713 TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) { 714 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)), 715 "NULL is not a valid simple regular expression"); 716 EXPECT_NONFATAL_FAILURE( 717 ASSERT_FALSE(ValidateRegex("a\\")), 718 "Syntax error at index 1 in simple regular expression \"a\\\": "); 719 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")), 720 "'\\' cannot appear at the end"); 721 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")), 722 "'\\' cannot appear at the end"); 723 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")), 724 "invalid escape sequence \"\\h\""); 725 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")), 726 "'^' can only appear at the beginning"); 727 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")), 728 "'^' can only appear at the beginning"); 729 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")), 730 "'$' can only appear at the end"); 731 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")), 732 "'$' can only appear at the end"); 733 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")), 734 "'(' is unsupported"); 735 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")), 736 "')' is unsupported"); 737 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")), 738 "'[' is unsupported"); 739 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")), 740 "'{' is unsupported"); 741 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")), 742 "'?' can only follow a repeatable token"); 743 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")), 744 "'*' can only follow a repeatable token"); 745 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")), 746 "'+' can only follow a repeatable token"); 747 } 748 749 TEST(ValidateRegexTest, ReturnsTrueForValid) { 750 EXPECT_TRUE(ValidateRegex("")); 751 EXPECT_TRUE(ValidateRegex("a")); 752 EXPECT_TRUE(ValidateRegex(".*")); 753 EXPECT_TRUE(ValidateRegex("^a_+")); 754 EXPECT_TRUE(ValidateRegex("^a\\t\\&?")); 755 EXPECT_TRUE(ValidateRegex("09*$")); 756 EXPECT_TRUE(ValidateRegex("^Z$")); 757 EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}")); 758 } 759 760 TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) { 761 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba")); 762 // Repeating more than once. 763 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab")); 764 765 // Repeating zero times. 766 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba")); 767 // Repeating once. 768 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab")); 769 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##")); 770 } 771 772 TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) { 773 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab")); 774 775 // Repeating zero times. 776 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc")); 777 // Repeating once. 778 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc")); 779 // Repeating more than once. 780 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g")); 781 } 782 783 TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) { 784 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab")); 785 // Repeating zero times. 786 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc")); 787 788 // Repeating once. 789 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc")); 790 // Repeating more than once. 791 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g")); 792 } 793 794 TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) { 795 EXPECT_TRUE(MatchRegexAtHead("", "")); 796 EXPECT_TRUE(MatchRegexAtHead("", "ab")); 797 } 798 799 TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) { 800 EXPECT_FALSE(MatchRegexAtHead("$", "a")); 801 802 EXPECT_TRUE(MatchRegexAtHead("$", "")); 803 EXPECT_TRUE(MatchRegexAtHead("a$", "a")); 804 } 805 806 TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) { 807 EXPECT_FALSE(MatchRegexAtHead("\\w", "+")); 808 EXPECT_FALSE(MatchRegexAtHead("\\W", "ab")); 809 810 EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab")); 811 EXPECT_TRUE(MatchRegexAtHead("\\d", "1a")); 812 } 813 814 TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) { 815 EXPECT_FALSE(MatchRegexAtHead(".+a", "abc")); 816 EXPECT_FALSE(MatchRegexAtHead("a?b", "aab")); 817 818 EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab")); 819 EXPECT_TRUE(MatchRegexAtHead("a?b", "b")); 820 EXPECT_TRUE(MatchRegexAtHead("a?b", "ab")); 821 } 822 823 TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetionOfEscapeSequence) { 824 EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc")); 825 EXPECT_FALSE(MatchRegexAtHead("\\s?b", " b")); 826 827 EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab")); 828 EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b")); 829 EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b")); 830 EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b")); 831 } 832 833 TEST(MatchRegexAtHeadTest, MatchesSequentially) { 834 EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc")); 835 836 EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc")); 837 } 838 839 TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) { 840 EXPECT_FALSE(MatchRegexAnywhere("", NULL)); 841 } 842 843 TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) { 844 EXPECT_FALSE(MatchRegexAnywhere("^a", "ba")); 845 EXPECT_FALSE(MatchRegexAnywhere("^$", "a")); 846 847 EXPECT_TRUE(MatchRegexAnywhere("^a", "ab")); 848 EXPECT_TRUE(MatchRegexAnywhere("^", "ab")); 849 EXPECT_TRUE(MatchRegexAnywhere("^$", "")); 850 } 851 852 TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) { 853 EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123")); 854 EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888")); 855 } 856 857 TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) { 858 EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5")); 859 EXPECT_TRUE(MatchRegexAnywhere(".*=", "=")); 860 EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc")); 861 } 862 863 TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) { 864 EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5")); 865 EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "= ...=")); 866 } 867 868 // Tests RE's implicit constructors. 869 TEST(RETest, ImplicitConstructorWorks) { 870 const RE empty(""); 871 EXPECT_STREQ("", empty.pattern()); 872 873 const RE simple("hello"); 874 EXPECT_STREQ("hello", simple.pattern()); 875 } 876 877 // Tests that RE's constructors reject invalid regular expressions. 878 TEST(RETest, RejectsInvalidRegex) { 879 EXPECT_NONFATAL_FAILURE({ const RE normal(NULL); }, 880 "NULL is not a valid simple regular expression"); 881 882 EXPECT_NONFATAL_FAILURE({ const RE normal(".*(\\w+"); }, 883 "'(' is unsupported"); 884 885 EXPECT_NONFATAL_FAILURE({ const RE invalid("^?"); }, 886 "'?' can only follow a repeatable token"); 887 } 888 889 // Tests RE::FullMatch(). 890 TEST(RETest, FullMatchWorks) { 891 const RE empty(""); 892 EXPECT_TRUE(RE::FullMatch("", empty)); 893 EXPECT_FALSE(RE::FullMatch("a", empty)); 894 895 const RE re1("a"); 896 EXPECT_TRUE(RE::FullMatch("a", re1)); 897 898 const RE re("a.*z"); 899 EXPECT_TRUE(RE::FullMatch("az", re)); 900 EXPECT_TRUE(RE::FullMatch("axyz", re)); 901 EXPECT_FALSE(RE::FullMatch("baz", re)); 902 EXPECT_FALSE(RE::FullMatch("azy", re)); 903 } 904 905 // Tests RE::PartialMatch(). 906 TEST(RETest, PartialMatchWorks) { 907 const RE empty(""); 908 EXPECT_TRUE(RE::PartialMatch("", empty)); 909 EXPECT_TRUE(RE::PartialMatch("a", empty)); 910 911 const RE re("a.*z"); 912 EXPECT_TRUE(RE::PartialMatch("az", re)); 913 EXPECT_TRUE(RE::PartialMatch("axyz", re)); 914 EXPECT_TRUE(RE::PartialMatch("baz", re)); 915 EXPECT_TRUE(RE::PartialMatch("azy", re)); 916 EXPECT_FALSE(RE::PartialMatch("zza", re)); 917 } 918 919 #endif // GTEST_USES_POSIX_RE 920 921 #ifndef GTEST_OS_WINDOWS_MOBILE 922 923 TEST(CaptureTest, CapturesStdout) { 924 CaptureStdout(); 925 fprintf(stdout, "abc"); 926 EXPECT_STREQ("abc", GetCapturedStdout().c_str()); 927 928 CaptureStdout(); 929 fprintf(stdout, "def%cghi", '\0'); 930 EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout())); 931 } 932 933 TEST(CaptureTest, CapturesStderr) { 934 CaptureStderr(); 935 fprintf(stderr, "jkl"); 936 EXPECT_STREQ("jkl", GetCapturedStderr().c_str()); 937 938 CaptureStderr(); 939 fprintf(stderr, "jkl%cmno", '\0'); 940 EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr())); 941 } 942 943 // Tests that stdout and stderr capture don't interfere with each other. 944 TEST(CaptureTest, CapturesStdoutAndStderr) { 945 CaptureStdout(); 946 CaptureStderr(); 947 fprintf(stdout, "pqr"); 948 fprintf(stderr, "stu"); 949 EXPECT_STREQ("pqr", GetCapturedStdout().c_str()); 950 EXPECT_STREQ("stu", GetCapturedStderr().c_str()); 951 } 952 953 TEST(CaptureDeathTest, CannotReenterStdoutCapture) { 954 CaptureStdout(); 955 EXPECT_DEATH_IF_SUPPORTED(CaptureStdout(), 956 "Only one stdout capturer can exist at a time"); 957 GetCapturedStdout(); 958 959 // We cannot test stderr capturing using death tests as they use it 960 // themselves. 961 } 962 963 #endif // !GTEST_OS_WINDOWS_MOBILE 964 965 TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) { 966 ThreadLocal<int> t1; 967 EXPECT_EQ(0, t1.get()); 968 969 ThreadLocal<void*> t2; 970 EXPECT_TRUE(t2.get() == nullptr); 971 } 972 973 TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) { 974 ThreadLocal<int> t1(123); 975 EXPECT_EQ(123, t1.get()); 976 977 int i = 0; 978 ThreadLocal<int*> t2(&i); 979 EXPECT_EQ(&i, t2.get()); 980 } 981 982 class NoDefaultConstructor { 983 public: 984 explicit NoDefaultConstructor(const char*) {} 985 NoDefaultConstructor(const NoDefaultConstructor&) = default; 986 }; 987 988 TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) { 989 ThreadLocal<NoDefaultConstructor> bar(NoDefaultConstructor("foo")); 990 bar.pointer(); 991 } 992 993 TEST(ThreadLocalTest, GetAndPointerReturnSameValue) { 994 ThreadLocal<std::string> thread_local_string; 995 996 EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get())); 997 998 // Verifies the condition still holds after calling set. 999 thread_local_string.set("foo"); 1000 EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get())); 1001 } 1002 1003 TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) { 1004 ThreadLocal<std::string> thread_local_string; 1005 const ThreadLocal<std::string>& const_thread_local_string = 1006 thread_local_string; 1007 1008 EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer()); 1009 1010 thread_local_string.set("foo"); 1011 EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer()); 1012 } 1013 1014 #ifdef GTEST_IS_THREADSAFE 1015 1016 void AddTwo(int* param) { *param += 2; } 1017 1018 TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) { 1019 int i = 40; 1020 ThreadWithParam<int*> thread(&AddTwo, &i, nullptr); 1021 thread.Join(); 1022 EXPECT_EQ(42, i); 1023 } 1024 1025 TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) { 1026 // AssertHeld() is flaky only in the presence of multiple threads accessing 1027 // the lock. In this case, the test is robust. 1028 EXPECT_DEATH_IF_SUPPORTED( 1029 { 1030 Mutex m; 1031 { MutexLock lock(&m); } 1032 m.AssertHeld(); 1033 }, 1034 "thread .*hold"); 1035 } 1036 1037 TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) { 1038 Mutex m; 1039 MutexLock lock(&m); 1040 m.AssertHeld(); 1041 } 1042 1043 class AtomicCounterWithMutex { 1044 public: 1045 explicit AtomicCounterWithMutex(Mutex* mutex) 1046 : value_(0), mutex_(mutex), random_(42) {} 1047 1048 void Increment() { 1049 MutexLock lock(mutex_); 1050 int temp = value_; 1051 { 1052 // We need to put up a memory barrier to prevent reads and writes to 1053 // value_ rearranged with the call to sleep_for when observed 1054 // from other threads. 1055 #if GTEST_HAS_PTHREAD 1056 // On POSIX, locking a mutex puts up a memory barrier. We cannot use 1057 // Mutex and MutexLock here or rely on their memory barrier 1058 // functionality as we are testing them here. 1059 pthread_mutex_t memory_barrier_mutex; 1060 GTEST_CHECK_POSIX_SUCCESS_( 1061 pthread_mutex_init(&memory_barrier_mutex, nullptr)); 1062 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex)); 1063 1064 std::this_thread::sleep_for( 1065 std::chrono::milliseconds(random_.Generate(30))); 1066 1067 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex)); 1068 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex)); 1069 #elif defined(GTEST_OS_WINDOWS) 1070 // On Windows, performing an interlocked access puts up a memory barrier. 1071 volatile LONG dummy = 0; 1072 ::InterlockedIncrement(&dummy); 1073 std::this_thread::sleep_for( 1074 std::chrono::milliseconds(random_.Generate(30))); 1075 ::InterlockedIncrement(&dummy); 1076 #else 1077 #error "Memory barrier not implemented on this platform." 1078 #endif // GTEST_HAS_PTHREAD 1079 } 1080 value_ = temp + 1; 1081 } 1082 int value() const { return value_; } 1083 1084 private: 1085 volatile int value_; 1086 Mutex* const mutex_; // Protects value_. 1087 Random random_; 1088 }; 1089 1090 void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) { 1091 for (int i = 0; i < param.second; ++i) param.first->Increment(); 1092 } 1093 1094 // Tests that the mutex only lets one thread at a time to lock it. 1095 TEST(MutexTest, OnlyOneThreadCanLockAtATime) { 1096 Mutex mutex; 1097 AtomicCounterWithMutex locked_counter(&mutex); 1098 1099 typedef ThreadWithParam<pair<AtomicCounterWithMutex*, int> > ThreadType; 1100 const int kCycleCount = 20; 1101 const int kThreadCount = 7; 1102 std::unique_ptr<ThreadType> counting_threads[kThreadCount]; 1103 Notification threads_can_start; 1104 // Creates and runs kThreadCount threads that increment locked_counter 1105 // kCycleCount times each. 1106 for (int i = 0; i < kThreadCount; ++i) { 1107 counting_threads[i] = std::make_unique<ThreadType>( 1108 &CountingThreadFunc, make_pair(&locked_counter, kCycleCount), 1109 &threads_can_start); 1110 } 1111 threads_can_start.Notify(); 1112 for (int i = 0; i < kThreadCount; ++i) counting_threads[i]->Join(); 1113 1114 // If the mutex lets more than one thread to increment the counter at a 1115 // time, they are likely to encounter a race condition and have some 1116 // increments overwritten, resulting in the lower then expected counter 1117 // value. 1118 EXPECT_EQ(kCycleCount * kThreadCount, locked_counter.value()); 1119 } 1120 1121 template <typename T> 1122 void RunFromThread(void(func)(T), T param) { 1123 ThreadWithParam<T> thread(func, param, nullptr); 1124 thread.Join(); 1125 } 1126 1127 void RetrieveThreadLocalValue( 1128 pair<ThreadLocal<std::string>*, std::string*> param) { 1129 *param.second = param.first->get(); 1130 } 1131 1132 TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) { 1133 ThreadLocal<std::string> thread_local_string("foo"); 1134 EXPECT_STREQ("foo", thread_local_string.get().c_str()); 1135 1136 thread_local_string.set("bar"); 1137 EXPECT_STREQ("bar", thread_local_string.get().c_str()); 1138 1139 std::string result; 1140 RunFromThread(&RetrieveThreadLocalValue, 1141 make_pair(&thread_local_string, &result)); 1142 EXPECT_STREQ("foo", result.c_str()); 1143 } 1144 1145 // Keeps track of whether of destructors being called on instances of 1146 // DestructorTracker. On Windows, waits for the destructor call reports. 1147 class DestructorCall { 1148 public: 1149 DestructorCall() { 1150 invoked_ = false; 1151 #ifdef GTEST_OS_WINDOWS 1152 wait_event_.Reset(::CreateEvent(NULL, TRUE, FALSE, NULL)); 1153 GTEST_CHECK_(wait_event_.Get() != NULL); 1154 #endif 1155 } 1156 1157 bool CheckDestroyed() const { 1158 #ifdef GTEST_OS_WINDOWS 1159 if (::WaitForSingleObject(wait_event_.Get(), 1000) != WAIT_OBJECT_0) 1160 return false; 1161 #endif 1162 return invoked_; 1163 } 1164 1165 void ReportDestroyed() { 1166 invoked_ = true; 1167 #ifdef GTEST_OS_WINDOWS 1168 ::SetEvent(wait_event_.Get()); 1169 #endif 1170 } 1171 1172 static std::vector<DestructorCall*>& List() { return *list_; } 1173 1174 static void ResetList() { 1175 for (size_t i = 0; i < list_->size(); ++i) { 1176 delete list_->at(i); 1177 } 1178 list_->clear(); 1179 } 1180 1181 private: 1182 bool invoked_; 1183 #ifdef GTEST_OS_WINDOWS 1184 AutoHandle wait_event_; 1185 #endif 1186 static std::vector<DestructorCall*>* const list_; 1187 1188 DestructorCall(const DestructorCall&) = delete; 1189 DestructorCall& operator=(const DestructorCall&) = delete; 1190 }; 1191 1192 std::vector<DestructorCall*>* const DestructorCall::list_ = 1193 new std::vector<DestructorCall*>; 1194 1195 // DestructorTracker keeps track of whether its instances have been 1196 // destroyed. 1197 class DestructorTracker { 1198 public: 1199 DestructorTracker() : index_(GetNewIndex()) {} 1200 DestructorTracker(const DestructorTracker& /* rhs */) 1201 : index_(GetNewIndex()) {} 1202 ~DestructorTracker() { 1203 // We never access DestructorCall::List() concurrently, so we don't need 1204 // to protect this access with a mutex. 1205 DestructorCall::List()[index_]->ReportDestroyed(); 1206 } 1207 1208 private: 1209 static size_t GetNewIndex() { 1210 DestructorCall::List().push_back(new DestructorCall); 1211 return DestructorCall::List().size() - 1; 1212 } 1213 const size_t index_; 1214 }; 1215 1216 typedef ThreadLocal<DestructorTracker>* ThreadParam; 1217 1218 void CallThreadLocalGet(ThreadParam thread_local_param) { 1219 thread_local_param->get(); 1220 } 1221 1222 // Tests that when a ThreadLocal object dies in a thread, it destroys 1223 // the managed object for that thread. 1224 TEST(ThreadLocalTest, DestroysManagedObjectForOwnThreadWhenDying) { 1225 DestructorCall::ResetList(); 1226 1227 { 1228 ThreadLocal<DestructorTracker> thread_local_tracker; 1229 ASSERT_EQ(0U, DestructorCall::List().size()); 1230 1231 // This creates another DestructorTracker object for the main thread. 1232 thread_local_tracker.get(); 1233 ASSERT_EQ(1U, DestructorCall::List().size()); 1234 ASSERT_FALSE(DestructorCall::List()[0]->CheckDestroyed()); 1235 } 1236 1237 // Now thread_local_tracker has died. 1238 ASSERT_EQ(1U, DestructorCall::List().size()); 1239 EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed()); 1240 1241 DestructorCall::ResetList(); 1242 } 1243 1244 // Tests that when a thread exits, the thread-local object for that 1245 // thread is destroyed. 1246 TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) { 1247 DestructorCall::ResetList(); 1248 1249 { 1250 ThreadLocal<DestructorTracker> thread_local_tracker; 1251 ASSERT_EQ(0U, DestructorCall::List().size()); 1252 1253 // This creates another DestructorTracker object in the new thread. 1254 ThreadWithParam<ThreadParam> thread(&CallThreadLocalGet, 1255 &thread_local_tracker, nullptr); 1256 thread.Join(); 1257 1258 // The thread has exited, and we should have a DestroyedTracker 1259 // instance created for it. But it may not have been destroyed yet. 1260 ASSERT_EQ(1U, DestructorCall::List().size()); 1261 } 1262 1263 // The thread has exited and thread_local_tracker has died. 1264 ASSERT_EQ(1U, DestructorCall::List().size()); 1265 EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed()); 1266 1267 DestructorCall::ResetList(); 1268 } 1269 1270 TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) { 1271 ThreadLocal<std::string> thread_local_string; 1272 thread_local_string.set("Foo"); 1273 EXPECT_STREQ("Foo", thread_local_string.get().c_str()); 1274 1275 std::string result; 1276 RunFromThread(&RetrieveThreadLocalValue, 1277 make_pair(&thread_local_string, &result)); 1278 EXPECT_TRUE(result.empty()); 1279 } 1280 1281 #endif // GTEST_IS_THREADSAFE 1282 1283 #ifdef GTEST_OS_WINDOWS 1284 TEST(WindowsTypesTest, HANDLEIsVoidStar) { 1285 StaticAssertTypeEq<HANDLE, void*>(); 1286 } 1287 1288 #if defined(GTEST_OS_WINDOWS_MINGW) && !defined(__MINGW64_VERSION_MAJOR) 1289 TEST(WindowsTypesTest, _CRITICAL_SECTIONIs_CRITICAL_SECTION) { 1290 StaticAssertTypeEq<CRITICAL_SECTION, _CRITICAL_SECTION>(); 1291 } 1292 #else 1293 TEST(WindowsTypesTest, CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION) { 1294 StaticAssertTypeEq<CRITICAL_SECTION, _RTL_CRITICAL_SECTION>(); 1295 } 1296 #endif 1297 1298 #endif // GTEST_OS_WINDOWS 1299 1300 } // namespace internal 1301 } // namespace testing 1302