Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  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.