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