googletest/test/googletest-port-test.cc

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