3rdparty/googletest/googletest/test/gtest_unittest.cc

   1 // Copyright 2005, 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 //
  31 // Tests for Google Test itself.  This verifies that the basic constructs of
  32 // Google Test work.
  33
  34 #include "gtest/gtest.h"
  35
  36 // Verifies that the command line flag variables can be accessed in
  37 // code once "gtest.h" has been #included.
  38 // Do not move it after other gtest #includes.
  39 TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
  40   bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
  41       || testing::GTEST_FLAG(break_on_failure)
  42       || testing::GTEST_FLAG(catch_exceptions)
  43       || testing::GTEST_FLAG(color) != "unknown"
  44       || testing::GTEST_FLAG(filter) != "unknown"
  45       || testing::GTEST_FLAG(list_tests)
  46       || testing::GTEST_FLAG(output) != "unknown"
  47       || testing::GTEST_FLAG(print_time)
  48       || testing::GTEST_FLAG(random_seed)
  49       || testing::GTEST_FLAG(repeat) > 0
  50       || testing::GTEST_FLAG(show_internal_stack_frames)
  51       || testing::GTEST_FLAG(shuffle)
  52       || testing::GTEST_FLAG(stack_trace_depth) > 0
  53       || testing::GTEST_FLAG(stream_result_to) != "unknown"
  54       || testing::GTEST_FLAG(throw_on_failure);
  55   EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
  56 }
  57
  58 #include <limits.h>  // For INT_MAX.
  59 #include <stdlib.h>
  60 #include <string.h>
  61 #include <time.h>
  62
  63 #include <map>
  64 #include <vector>
  65 #include <ostream>
  66 #if GTEST_LANG_CXX11
  67 #include <unordered_set>
  68 #endif  // GTEST_LANG_CXX11
  69
  70 #include "gtest/gtest-spi.h"
  71 #include "src/gtest-internal-inl.h"
  72
  73 namespace testing {
  74 namespace internal {
  75
  76 #if GTEST_CAN_STREAM_RESULTS_
  77
  78 class StreamingListenerTest : public Test {
  79  public:
  80   class FakeSocketWriter : public StreamingListener::AbstractSocketWriter {
  81    public:
  82     // Sends a string to the socket.
  83     virtual void Send(const std::string& message) { output_ += message; }
  84
  85     std::string output_;
  86   };
  87
  88   StreamingListenerTest()
  89       : fake_sock_writer_(new FakeSocketWriter),
  90         streamer_(fake_sock_writer_),
  91         test_info_obj_("FooTest", "Bar", NULL, NULL,
  92                        CodeLocation(__FILE__, __LINE__), 0, NULL) {}
  93
  94  protected:
  95   std::string* output() { return &(fake_sock_writer_->output_); }
  96
  97   FakeSocketWriter* const fake_sock_writer_;
  98   StreamingListener streamer_;
  99   UnitTest unit_test_;
 100   TestInfo test_info_obj_;  // The name test_info_ was taken by testing::Test.
 101 };
 102
 103 TEST_F(StreamingListenerTest, OnTestProgramEnd) {
 104   *output() = "";
 105   streamer_.OnTestProgramEnd(unit_test_);
 106   EXPECT_EQ("event=TestProgramEnd&passed=1\n", *output());
 107 }
 108
 109 TEST_F(StreamingListenerTest, OnTestIterationEnd) {
 110   *output() = "";
 111   streamer_.OnTestIterationEnd(unit_test_, 42);
 112   EXPECT_EQ("event=TestIterationEnd&passed=1&elapsed_time=0ms\n", *output());
 113 }
 114
 115 TEST_F(StreamingListenerTest, OnTestCaseStart) {
 116   *output() = "";
 117   streamer_.OnTestCaseStart(TestCase("FooTest", "Bar", NULL, NULL));
 118   EXPECT_EQ("event=TestCaseStart&name=FooTest\n", *output());
 119 }
 120
 121 TEST_F(StreamingListenerTest, OnTestCaseEnd) {
 122   *output() = "";
 123   streamer_.OnTestCaseEnd(TestCase("FooTest", "Bar", NULL, NULL));
 124   EXPECT_EQ("event=TestCaseEnd&passed=1&elapsed_time=0ms\n", *output());
 125 }
 126
 127 TEST_F(StreamingListenerTest, OnTestStart) {
 128   *output() = "";
 129   streamer_.OnTestStart(test_info_obj_);
 130   EXPECT_EQ("event=TestStart&name=Bar\n", *output());
 131 }
 132
 133 TEST_F(StreamingListenerTest, OnTestEnd) {
 134   *output() = "";
 135   streamer_.OnTestEnd(test_info_obj_);
 136   EXPECT_EQ("event=TestEnd&passed=1&elapsed_time=0ms\n", *output());
 137 }
 138
 139 TEST_F(StreamingListenerTest, OnTestPartResult) {
 140   *output() = "";
 141   streamer_.OnTestPartResult(TestPartResult(
 142       TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%"));
 143
 144   // Meta characters in the failure message should be properly escaped.
 145   EXPECT_EQ(
 146       "event=TestPartResult&file=foo.cc&line=42&message=failed%3D%0A%26%25\n",
 147       *output());
 148 }
 149
 150 #endif  // GTEST_CAN_STREAM_RESULTS_
 151
 152 // Provides access to otherwise private parts of the TestEventListeners class
 153 // that are needed to test it.
 154 class TestEventListenersAccessor {
 155  public:
 156   static TestEventListener* GetRepeater(TestEventListeners* listeners) {
 157     return listeners->repeater();
 158   }
 159
 160   static void SetDefaultResultPrinter(TestEventListeners* listeners,
 161                                       TestEventListener* listener) {
 162     listeners->SetDefaultResultPrinter(listener);
 163   }
 164   static void SetDefaultXmlGenerator(TestEventListeners* listeners,
 165                                      TestEventListener* listener) {
 166     listeners->SetDefaultXmlGenerator(listener);
 167   }
 168
 169   static bool EventForwardingEnabled(const TestEventListeners& listeners) {
 170     return listeners.EventForwardingEnabled();
 171   }
 172
 173   static void SuppressEventForwarding(TestEventListeners* listeners) {
 174     listeners->SuppressEventForwarding();
 175   }
 176 };
 177
 178 class UnitTestRecordPropertyTestHelper : public Test {
 179  protected:
 180   UnitTestRecordPropertyTestHelper() {}
 181
 182   // Forwards to UnitTest::RecordProperty() to bypass access controls.
 183   void UnitTestRecordProperty(const char* key, const std::string& value) {
 184     unit_test_.RecordProperty(key, value);
 185   }
 186
 187   UnitTest unit_test_;
 188 };
 189
 190 }  // namespace internal
 191 }  // namespace testing
 192
 193 using testing::AssertionFailure;
 194 using testing::AssertionResult;
 195 using testing::AssertionSuccess;
 196 using testing::DoubleLE;
 197 using testing::EmptyTestEventListener;
 198 using testing::Environment;
 199 using testing::FloatLE;
 200 using testing::GTEST_FLAG(also_run_disabled_tests);
 201 using testing::GTEST_FLAG(break_on_failure);
 202 using testing::GTEST_FLAG(catch_exceptions);
 203 using testing::GTEST_FLAG(color);
 204 using testing::GTEST_FLAG(death_test_use_fork);
 205 using testing::GTEST_FLAG(filter);
 206 using testing::GTEST_FLAG(list_tests);
 207 using testing::GTEST_FLAG(output);
 208 using testing::GTEST_FLAG(print_time);
 209 using testing::GTEST_FLAG(random_seed);
 210 using testing::GTEST_FLAG(repeat);
 211 using testing::GTEST_FLAG(show_internal_stack_frames);
 212 using testing::GTEST_FLAG(shuffle);
 213 using testing::GTEST_FLAG(stack_trace_depth);
 214 using testing::GTEST_FLAG(stream_result_to);
 215 using testing::GTEST_FLAG(throw_on_failure);
 216 using testing::IsNotSubstring;
 217 using testing::IsSubstring;
 218 using testing::Message;
 219 using testing::ScopedFakeTestPartResultReporter;
 220 using testing::StaticAssertTypeEq;
 221 using testing::Test;
 222 using testing::TestCase;
 223 using testing::TestEventListeners;
 224 using testing::TestInfo;
 225 using testing::TestPartResult;
 226 using testing::TestPartResultArray;
 227 using testing::TestProperty;
 228 using testing::TestResult;
 229 using testing::TimeInMillis;
 230 using testing::UnitTest;
 231 using testing::internal::AddReference;
 232 using testing::internal::AlwaysFalse;
 233 using testing::internal::AlwaysTrue;
 234 using testing::internal::AppendUserMessage;
 235 using testing::internal::ArrayAwareFind;
 236 using testing::internal::ArrayEq;
 237 using testing::internal::CodePointToUtf8;
 238 using testing::internal::CompileAssertTypesEqual;
 239 using testing::internal::CopyArray;
 240 using testing::internal::CountIf;
 241 using testing::internal::EqFailure;
 242 using testing::internal::FloatingPoint;
 243 using testing::internal::ForEach;
 244 using testing::internal::FormatEpochTimeInMillisAsIso8601;
 245 using testing::internal::FormatTimeInMillisAsSeconds;
 246 using testing::internal::GTestFlagSaver;
 247 using testing::internal::GetCurrentOsStackTraceExceptTop;
 248 using testing::internal::GetElementOr;
 249 using testing::internal::GetNextRandomSeed;
 250 using testing::internal::GetRandomSeedFromFlag;
 251 using testing::internal::GetTestTypeId;
 252 using testing::internal::GetTimeInMillis;
 253 using testing::internal::GetTypeId;
 254 using testing::internal::GetUnitTestImpl;
 255 using testing::internal::ImplicitlyConvertible;
 256 using testing::internal::Int32;
 257 using testing::internal::Int32FromEnvOrDie;
 258 using testing::internal::IsAProtocolMessage;
 259 using testing::internal::IsContainer;
 260 using testing::internal::IsContainerTest;
 261 using testing::internal::IsNotContainer;
 262 using testing::internal::NativeArray;
 263 using testing::internal::OsStackTraceGetter;
 264 using testing::internal::OsStackTraceGetterInterface;
 265 using testing::internal::ParseInt32Flag;
 266 using testing::internal::RelationToSourceCopy;
 267 using testing::internal::RelationToSourceReference;
 268 using testing::internal::RemoveConst;
 269 using testing::internal::RemoveReference;
 270 using testing::internal::ShouldRunTestOnShard;
 271 using testing::internal::ShouldShard;
 272 using testing::internal::ShouldUseColor;
 273 using testing::internal::Shuffle;
 274 using testing::internal::ShuffleRange;
 275 using testing::internal::SkipPrefix;
 276 using testing::internal::StreamableToString;
 277 using testing::internal::String;
 278 using testing::internal::TestEventListenersAccessor;
 279 using testing::internal::TestResultAccessor;
 280 using testing::internal::UInt32;
 281 using testing::internal::UnitTestImpl;
 282 using testing::internal::WideStringToUtf8;
 283 using testing::internal::edit_distance::CalculateOptimalEdits;
 284 using testing::internal::edit_distance::CreateUnifiedDiff;
 285 using testing::internal::edit_distance::EditType;
 286 using testing::internal::kMaxRandomSeed;
 287 using testing::internal::kTestTypeIdInGoogleTest;
 288 using testing::kMaxStackTraceDepth;
 289
 290 #if GTEST_HAS_STREAM_REDIRECTION
 291 using testing::internal::CaptureStdout;
 292 using testing::internal::GetCapturedStdout;
 293 #endif
 294
 295 #if GTEST_IS_THREADSAFE
 296 using testing::internal::ThreadWithParam;
 297 #endif
 298
 299 class TestingVector : public std::vector<int> {
 300 };
 301
 302 ::std::ostream& operator<<(::std::ostream& os,
 303                            const TestingVector& vector) {
 304   os << "{ ";
 305   for (size_t i = 0; i < vector.size(); i++) {
 306     os << vector[i] << " ";
 307   }
 308   os << "}";
 309   return os;
 310 }
 311
 312 // This line tests that we can define tests in an unnamed namespace.
 313 namespace {
 314
 315 TEST(GetRandomSeedFromFlagTest, HandlesZero) {
 316   const int seed = GetRandomSeedFromFlag(0);
 317   EXPECT_LE(1, seed);
 318   EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed));
 319 }
 320
 321 TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {
 322   EXPECT_EQ(1, GetRandomSeedFromFlag(1));
 323   EXPECT_EQ(2, GetRandomSeedFromFlag(2));
 324   EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1));
 325   EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
 326             GetRandomSeedFromFlag(kMaxRandomSeed));
 327 }
 328
 329 TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {
 330   const int seed1 = GetRandomSeedFromFlag(-1);
 331   EXPECT_LE(1, seed1);
 332   EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed));
 333
 334   const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1);
 335   EXPECT_LE(1, seed2);
 336   EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed));
 337 }
 338
 339 TEST(GetNextRandomSeedTest, WorksForValidInput) {
 340   EXPECT_EQ(2, GetNextRandomSeed(1));
 341   EXPECT_EQ(3, GetNextRandomSeed(2));
 342   EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
 343             GetNextRandomSeed(kMaxRandomSeed - 1));
 344   EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed));
 345
 346   // We deliberately don't test GetNextRandomSeed() with invalid
 347   // inputs, as that requires death tests, which are expensive.  This
 348   // is fine as GetNextRandomSeed() is internal and has a
 349   // straightforward definition.
 350 }
 351
 352 static void ClearCurrentTestPartResults() {
 353   TestResultAccessor::ClearTestPartResults(
 354       GetUnitTestImpl()->current_test_result());
 355 }
 356
 357 // Tests GetTypeId.
 358
 359 TEST(GetTypeIdTest, ReturnsSameValueForSameType) {
 360   EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>());
 361   EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>());
 362 }
 363
 364 class SubClassOfTest : public Test {};
 365 class AnotherSubClassOfTest : public Test {};
 366
 367 TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {
 368   EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>());
 369   EXPECT_NE(GetTypeId<int>(), GetTypeId<char>());
 370   EXPECT_NE(GetTypeId<int>(), GetTestTypeId());
 371   EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId());
 372   EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId());
 373   EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>());
 374 }
 375
 376 // Verifies that GetTestTypeId() returns the same value, no matter it
 377 // is called from inside Google Test or outside of it.
 378 TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {
 379   EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());
 380 }
 381
 382 // Tests CanonicalizeForStdLibVersioning.
 383
 384 using ::testing::internal::CanonicalizeForStdLibVersioning;
 385
 386 TEST(CanonicalizeForStdLibVersioning, LeavesUnversionedNamesUnchanged) {
 387   EXPECT_EQ("std::bind", CanonicalizeForStdLibVersioning("std::bind"));
 388   EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::_"));
 389   EXPECT_EQ("std::__foo", CanonicalizeForStdLibVersioning("std::__foo"));
 390   EXPECT_EQ("gtl::__1::x", CanonicalizeForStdLibVersioning("gtl::__1::x"));
 391   EXPECT_EQ("__1::x", CanonicalizeForStdLibVersioning("__1::x"));
 392   EXPECT_EQ("::__1::x", CanonicalizeForStdLibVersioning("::__1::x"));
 393 }
 394
 395 TEST(CanonicalizeForStdLibVersioning, ElidesDoubleUnderNames) {
 396   EXPECT_EQ("std::bind", CanonicalizeForStdLibVersioning("std::__1::bind"));
 397   EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::__1::_"));
 398
 399   EXPECT_EQ("std::bind", CanonicalizeForStdLibVersioning("std::__g::bind"));
 400   EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::__g::_"));
 401
 402   EXPECT_EQ("std::bind",
 403             CanonicalizeForStdLibVersioning("std::__google::bind"));
 404   EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::__google::_"));
 405 }
 406
 407 // Tests FormatTimeInMillisAsSeconds().
 408
 409 TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
 410   EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0));
 411 }
 412
 413 TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
 414   EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3));
 415   EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10));
 416   EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200));
 417   EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200));
 418   EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000));
 419 }
 420
 421 TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
 422   EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3));
 423   EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10));
 424   EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200));
 425   EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200));
 426   EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000));
 427 }
 428
 429 // Tests FormatEpochTimeInMillisAsIso8601().  The correctness of conversion
 430 // for particular dates below was verified in Python using
 431 // datetime.datetime.fromutctimestamp(<timetamp>/1000).
 432
 433 // FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we
 434 // have to set up a particular timezone to obtain predictable results.
 435 class FormatEpochTimeInMillisAsIso8601Test : public Test {
 436  public:
 437   // On Cygwin, GCC doesn't allow unqualified integer literals to exceed
 438   // 32 bits, even when 64-bit integer types are available.  We have to
 439   // force the constants to have a 64-bit type here.
 440   static const TimeInMillis kMillisPerSec = 1000;
 441
 442  private:
 443   virtual void SetUp() {
 444     saved_tz_ = NULL;
 445
 446     GTEST_DISABLE_MSC_DEPRECATED_PUSH_(/* getenv, strdup: deprecated */)
 447     if (getenv("TZ"))
 448       saved_tz_ = strdup(getenv("TZ"));
 449     GTEST_DISABLE_MSC_DEPRECATED_POP_()
 450
 451     // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use.  We
 452     // cannot use the local time zone because the function's output depends
 453     // on the time zone.
 454     SetTimeZone("UTC+00");
 455   }
 456
 457   virtual void TearDown() {
 458     SetTimeZone(saved_tz_);
 459     free(const_cast<char*>(saved_tz_));
 460     saved_tz_ = NULL;
 461   }
 462
 463   static void SetTimeZone(const char* time_zone) {
 464     // tzset() distinguishes between the TZ variable being present and empty
 465     // and not being present, so we have to consider the case of time_zone
 466     // being NULL.
 467 #if _MSC_VER || GTEST_OS_WINDOWS_MINGW
 468     // ...Unless it's MSVC, whose standard library's _putenv doesn't
 469     // distinguish between an empty and a missing variable.
 470     const std::string env_var =
 471         std::string("TZ=") + (time_zone ? time_zone : "");
 472     _putenv(env_var.c_str());
 473     GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
 474     tzset();
 475     GTEST_DISABLE_MSC_WARNINGS_POP_()
 476 #else
 477     if (time_zone) {
 478       setenv(("TZ"), time_zone, 1);
 479     } else {
 480       unsetenv("TZ");
 481     }
 482     tzset();
 483 #endif
 484   }
 485
 486   const char* saved_tz_;
 487 };
 488
 489 const TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec;
 490
 491 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
 492   EXPECT_EQ("2011-10-31T18:52:42",
 493             FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec));
 494 }
 495
 496 TEST_F(FormatEpochTimeInMillisAsIso8601Test, MillisecondsDoNotAffectResult) {
 497   EXPECT_EQ(
 498       "2011-10-31T18:52:42",
 499       FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
 500 }
 501
 502 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
 503   EXPECT_EQ("2011-09-03T05:07:02",
 504             FormatEpochTimeInMillisAsIso8601(1315026422 * kMillisPerSec));
 505 }
 506
 507 TEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) {
 508   EXPECT_EQ("2011-09-28T17:08:22",
 509             FormatEpochTimeInMillisAsIso8601(1317229702 * kMillisPerSec));
 510 }
 511
 512 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
 513   EXPECT_EQ("1970-01-01T00:00:00", FormatEpochTimeInMillisAsIso8601(0));
 514 }
 515
 516 #if GTEST_CAN_COMPARE_NULL
 517
 518 # ifdef __BORLANDC__
 519 // Silences warnings: "Condition is always true", "Unreachable code"
 520 #  pragma option push -w-ccc -w-rch
 521 # endif
 522
 523 // Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null
 524 // pointer literal.
 525 TEST(NullLiteralTest, IsTrueForNullLiterals) {
 526   EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL));
 527   EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0));
 528   EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U));
 529   EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L));
 530 }
 531
 532 // Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null
 533 // pointer literal.
 534 TEST(NullLiteralTest, IsFalseForNonNullLiterals) {
 535   EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1));
 536   EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0));
 537   EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a'));
 538   EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));
 539 }
 540
 541 # ifdef __BORLANDC__
 542 // Restores warnings after previous "#pragma option push" suppressed them.
 543 #  pragma option pop
 544 # endif
 545
 546 #endif  // GTEST_CAN_COMPARE_NULL
 547 //
 548 // Tests CodePointToUtf8().
 549
 550 // Tests that the NUL character L'\0' is encoded correctly.
 551 TEST(CodePointToUtf8Test, CanEncodeNul) {
 552   EXPECT_EQ("", CodePointToUtf8(L'\0'));
 553 }
 554
 555 // Tests that ASCII characters are encoded correctly.
 556 TEST(CodePointToUtf8Test, CanEncodeAscii) {
 557   EXPECT_EQ("a", CodePointToUtf8(L'a'));
 558   EXPECT_EQ("Z", CodePointToUtf8(L'Z'));
 559   EXPECT_EQ("&", CodePointToUtf8(L'&'));
 560   EXPECT_EQ("\x7F", CodePointToUtf8(L'\x7F'));
 561 }
 562
 563 // Tests that Unicode code-points that have 8 to 11 bits are encoded
 564 // as 110xxxxx 10xxxxxx.
 565 TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
 566   // 000 1101 0011 => 110-00011 10-010011
 567   EXPECT_EQ("\xC3\x93", CodePointToUtf8(L'\xD3'));
 568
 569   // 101 0111 0110 => 110-10101 10-110110
 570   // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
 571   // in wide strings and wide chars. In order to accommodate them, we have to
 572   // introduce such character constants as integers.
 573   EXPECT_EQ("\xD5\xB6",
 574             CodePointToUtf8(static_cast<wchar_t>(0x576)));
 575 }
 576
 577 // Tests that Unicode code-points that have 12 to 16 bits are encoded
 578 // as 1110xxxx 10xxxxxx 10xxxxxx.
 579 TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
 580   // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
 581   EXPECT_EQ("\xE0\xA3\x93",
 582             CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
 583
 584   // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
 585   EXPECT_EQ("\xEC\x9D\x8D",
 586             CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
 587 }
 588
 589 #if !GTEST_WIDE_STRING_USES_UTF16_
 590 // Tests in this group require a wchar_t to hold > 16 bits, and thus
 591 // are skipped on Windows, Cygwin, and Symbian, where a wchar_t is
 592 // 16-bit wide. This code may not compile on those systems.
 593
 594 // Tests that Unicode code-points that have 17 to 21 bits are encoded
 595 // as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.
 596 TEST(CodePointToUtf8Test, CanEncode17To21Bits) {
 597   // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
 598   EXPECT_EQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3'));
 599
 600   // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000
 601   EXPECT_EQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400'));
 602
 603   // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
 604   EXPECT_EQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634'));
 605 }
 606
 607 // Tests that encoding an invalid code-point generates the expected result.
 608 TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
 609   EXPECT_EQ("(Invalid Unicode 0x1234ABCD)", CodePointToUtf8(L'\x1234ABCD'));
 610 }
 611
 612 #endif  // !GTEST_WIDE_STRING_USES_UTF16_
 613
 614 // Tests WideStringToUtf8().
 615
 616 // Tests that the NUL character L'\0' is encoded correctly.
 617 TEST(WideStringToUtf8Test, CanEncodeNul) {
 618   EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str());
 619   EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str());
 620 }
 621
 622 // Tests that ASCII strings are encoded correctly.
 623 TEST(WideStringToUtf8Test, CanEncodeAscii) {
 624   EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str());
 625   EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str());
 626   EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str());
 627   EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str());
 628 }
 629
 630 // Tests that Unicode code-points that have 8 to 11 bits are encoded
 631 // as 110xxxxx 10xxxxxx.
 632 TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
 633   // 000 1101 0011 => 110-00011 10-010011
 634   EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str());
 635   EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
 636
 637   // 101 0111 0110 => 110-10101 10-110110
 638   const wchar_t s[] = { 0x576, '\0' };
 639   EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
 640   EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str());
 641 }
 642
 643 // Tests that Unicode code-points that have 12 to 16 bits are encoded
 644 // as 1110xxxx 10xxxxxx 10xxxxxx.
 645 TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
 646   // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
 647   const wchar_t s1[] = { 0x8D3, '\0' };
 648   EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
 649   EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
 650
 651   // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
 652   const wchar_t s2[] = { 0xC74D, '\0' };
 653   EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
 654   EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str());
 655 }
 656
 657 // Tests that the conversion stops when the function encounters \0 character.
 658 TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
 659   EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());
 660 }
 661
 662 // Tests that the conversion stops when the function reaches the limit
 663 // specified by the 'length' parameter.
 664 TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
 665   EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str());
 666 }
 667
 668 #if !GTEST_WIDE_STRING_USES_UTF16_
 669 // Tests that Unicode code-points that have 17 to 21 bits are encoded
 670 // as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile
 671 // on the systems using UTF-16 encoding.
 672 TEST(WideStringToUtf8Test, CanEncode17To21Bits) {
 673   // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
 674   EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str());
 675   EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str());
 676
 677   // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
 678   EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str());
 679   EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str());
 680 }
 681
 682 // Tests that encoding an invalid code-point generates the expected result.
 683 TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
 684   EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
 685                WideStringToUtf8(L"\xABCDFF", -1).c_str());
 686 }
 687 #else  // !GTEST_WIDE_STRING_USES_UTF16_
 688 // Tests that surrogate pairs are encoded correctly on the systems using
 689 // UTF-16 encoding in the wide strings.
 690 TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
 691   const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
 692   EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str());
 693 }
 694
 695 // Tests that encoding an invalid UTF-16 surrogate pair
 696 // generates the expected result.
 697 TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
 698   // Leading surrogate is at the end of the string.
 699   const wchar_t s1[] = { 0xD800, '\0' };
 700   EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
 701   // Leading surrogate is not followed by the trailing surrogate.
 702   const wchar_t s2[] = { 0xD800, 'M', '\0' };
 703   EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
 704   // Trailing surrogate appearas without a leading surrogate.
 705   const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
 706   EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
 707 }
 708 #endif  // !GTEST_WIDE_STRING_USES_UTF16_
 709
 710 // Tests that codepoint concatenation works correctly.
 711 #if !GTEST_WIDE_STRING_USES_UTF16_
 712 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
 713   const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
 714   EXPECT_STREQ(
 715       "\xF4\x88\x98\xB4"
 716           "\xEC\x9D\x8D"
 717           "\n"
 718           "\xD5\xB6"
 719           "\xE0\xA3\x93"
 720           "\xF4\x88\x98\xB4",
 721       WideStringToUtf8(s, -1).c_str());
 722 }
 723 #else
 724 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
 725   const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
 726   EXPECT_STREQ(
 727       "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
 728       WideStringToUtf8(s, -1).c_str());
 729 }
 730 #endif  // !GTEST_WIDE_STRING_USES_UTF16_
 731
 732 // Tests the Random class.
 733
 734 TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
 735   testing::internal::Random random(42);
 736   EXPECT_DEATH_IF_SUPPORTED(
 737       random.Generate(0),
 738       "Cannot generate a number in the range \\[0, 0\\)");
 739   EXPECT_DEATH_IF_SUPPORTED(
 740       random.Generate(testing::internal::Random::kMaxRange + 1),
 741       "Generation of a number in \\[0, 2147483649\\) was requested, "
 742       "but this can only generate numbers in \\[0, 2147483648\\)");
 743 }
 744
 745 TEST(RandomTest, GeneratesNumbersWithinRange) {
 746   const UInt32 kRange = 10000;
 747   testing::internal::Random random(12345);
 748   for (int i = 0; i < 10; i++) {
 749     EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i;
 750   }
 751
 752   testing::internal::Random random2(testing::internal::Random::kMaxRange);
 753   for (int i = 0; i < 10; i++) {
 754     EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i;
 755   }
 756 }
 757
 758 TEST(RandomTest, RepeatsWhenReseeded) {
 759   const int kSeed = 123;
 760   const int kArraySize = 10;
 761   const UInt32 kRange = 10000;
 762   UInt32 values[kArraySize];
 763
 764   testing::internal::Random random(kSeed);
 765   for (int i = 0; i < kArraySize; i++) {
 766     values[i] = random.Generate(kRange);
 767   }
 768
 769   random.Reseed(kSeed);
 770   for (int i = 0; i < kArraySize; i++) {
 771     EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i;
 772   }
 773 }
 774
 775 // Tests STL container utilities.
 776
 777 // Tests CountIf().
 778
 779 static bool IsPositive(int n) { return n > 0; }
 780
 781 TEST(ContainerUtilityTest, CountIf) {
 782   std::vector<int> v;
 783   EXPECT_EQ(0, CountIf(v, IsPositive));  // Works for an empty container.
 784
 785   v.push_back(-1);
 786   v.push_back(0);
 787   EXPECT_EQ(0, CountIf(v, IsPositive));  // Works when no value satisfies.
 788
 789   v.push_back(2);
 790   v.push_back(-10);
 791   v.push_back(10);
 792   EXPECT_EQ(2, CountIf(v, IsPositive));
 793 }
 794
 795 // Tests ForEach().
 796
 797 static int g_sum = 0;
 798 static void Accumulate(int n) { g_sum += n; }
 799
 800 TEST(ContainerUtilityTest, ForEach) {
 801   std::vector<int> v;
 802   g_sum = 0;
 803   ForEach(v, Accumulate);
 804   EXPECT_EQ(0, g_sum);  // Works for an empty container;
 805
 806   g_sum = 0;
 807   v.push_back(1);
 808   ForEach(v, Accumulate);
 809   EXPECT_EQ(1, g_sum);  // Works for a container with one element.
 810
 811   g_sum = 0;
 812   v.push_back(20);
 813   v.push_back(300);
 814   ForEach(v, Accumulate);
 815   EXPECT_EQ(321, g_sum);
 816 }
 817
 818 // Tests GetElementOr().
 819 TEST(ContainerUtilityTest, GetElementOr) {
 820   std::vector<char> a;
 821   EXPECT_EQ('x', GetElementOr(a, 0, 'x'));
 822
 823   a.push_back('a');
 824   a.push_back('b');
 825   EXPECT_EQ('a', GetElementOr(a, 0, 'x'));
 826   EXPECT_EQ('b', GetElementOr(a, 1, 'x'));
 827   EXPECT_EQ('x', GetElementOr(a, -2, 'x'));
 828   EXPECT_EQ('x', GetElementOr(a, 2, 'x'));
 829 }
 830
 831 TEST(ContainerUtilityDeathTest, ShuffleRange) {
 832   std::vector<int> a;
 833   a.push_back(0);
 834   a.push_back(1);
 835   a.push_back(2);
 836   testing::internal::Random random(1);
 837
 838   EXPECT_DEATH_IF_SUPPORTED(
 839       ShuffleRange(&random, -1, 1, &a),
 840       "Invalid shuffle range start -1: must be in range \\[0, 3\\]");
 841   EXPECT_DEATH_IF_SUPPORTED(
 842       ShuffleRange(&random, 4, 4, &a),
 843       "Invalid shuffle range start 4: must be in range \\[0, 3\\]");
 844   EXPECT_DEATH_IF_SUPPORTED(
 845       ShuffleRange(&random, 3, 2, &a),
 846       "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");
 847   EXPECT_DEATH_IF_SUPPORTED(
 848       ShuffleRange(&random, 3, 4, &a),
 849       "Invalid shuffle range finish 4: must be in range \\[3, 3\\]");
 850 }
 851
 852 class VectorShuffleTest : public Test {
 853  protected:
 854   static const int kVectorSize = 20;
 855
 856   VectorShuffleTest() : random_(1) {
 857     for (int i = 0; i < kVectorSize; i++) {
 858       vector_.push_back(i);
 859     }
 860   }
 861
 862   static bool VectorIsCorrupt(const TestingVector& vector) {
 863     if (kVectorSize != static_cast<int>(vector.size())) {
 864       return true;
 865     }
 866
 867     bool found_in_vector[kVectorSize] = { false };
 868     for (size_t i = 0; i < vector.size(); i++) {
 869       const int e = vector[i];
 870       if (e < 0 || e >= kVectorSize || found_in_vector[e]) {
 871         return true;
 872       }
 873       found_in_vector[e] = true;
 874     }
 875
 876     // Vector size is correct, elements' range is correct, no
 877     // duplicate elements.  Therefore no corruption has occurred.
 878     return false;
 879   }
 880
 881   static bool VectorIsNotCorrupt(const TestingVector& vector) {
 882     return !VectorIsCorrupt(vector);
 883   }
 884
 885   static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) {
 886     for (int i = begin; i < end; i++) {
 887       if (i != vector[i]) {
 888         return true;
 889       }
 890     }
 891     return false;
 892   }
 893
 894   static bool RangeIsUnshuffled(
 895       const TestingVector& vector, int begin, int end) {
 896     return !RangeIsShuffled(vector, begin, end);
 897   }
 898
 899   static bool VectorIsShuffled(const TestingVector& vector) {
 900     return RangeIsShuffled(vector, 0, static_cast<int>(vector.size()));
 901   }
 902
 903   static bool VectorIsUnshuffled(const TestingVector& vector) {
 904     return !VectorIsShuffled(vector);
 905   }
 906
 907   testing::internal::Random random_;
 908   TestingVector vector_;
 909 };  // class VectorShuffleTest
 910
 911 const int VectorShuffleTest::kVectorSize;
 912
 913 TEST_F(VectorShuffleTest, HandlesEmptyRange) {
 914   // Tests an empty range at the beginning...
 915   ShuffleRange(&random_, 0, 0, &vector_);
 916   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 917   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 918
 919   // ...in the middle...
 920   ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
 921   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 922   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 923
 924   // ...at the end...
 925   ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_);
 926   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 927   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 928
 929   // ...and past the end.
 930   ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_);
 931   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 932   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 933 }
 934
 935 TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
 936   // Tests a size one range at the beginning...
 937   ShuffleRange(&random_, 0, 1, &vector_);
 938   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 939   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 940
 941   // ...in the middle...
 942   ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
 943   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 944   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 945
 946   // ...and at the end.
 947   ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_);
 948   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 949   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 950 }
 951
 952 // Because we use our own random number generator and a fixed seed,
 953 // we can guarantee that the following "random" tests will succeed.
 954
 955 TEST_F(VectorShuffleTest, ShufflesEntireVector) {
 956   Shuffle(&random_, &vector_);
 957   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 958   EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_;
 959
 960   // Tests the first and last elements in particular to ensure that
 961   // there are no off-by-one problems in our shuffle algorithm.
 962   EXPECT_NE(0, vector_[0]);
 963   EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]);
 964 }
 965
 966 TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
 967   const int kRangeSize = kVectorSize/2;
 968
 969   ShuffleRange(&random_, 0, kRangeSize, &vector_);
 970
 971   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 972   EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize);
 973   EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize);
 974 }
 975
 976 TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
 977   const int kRangeSize = kVectorSize / 2;
 978   ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_);
 979
 980   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 981   EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
 982   EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);
 983 }
 984
 985 TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
 986   int kRangeSize = kVectorSize/3;
 987   ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
 988
 989   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
 990   EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
 991   EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
 992   EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize);
 993 }
 994
 995 TEST_F(VectorShuffleTest, ShufflesRepeatably) {
 996   TestingVector vector2;
 997   for (int i = 0; i < kVectorSize; i++) {
 998     vector2.push_back(i);
 999   }
1000
1001   random_.Reseed(1234);
1002   Shuffle(&random_, &vector_);
1003   random_.Reseed(1234);
1004   Shuffle(&random_, &vector2);
1005
1006   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
1007   ASSERT_PRED1(VectorIsNotCorrupt, vector2);
1008
1009   for (int i = 0; i < kVectorSize; i++) {
1010     EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i;
1011   }
1012 }
1013
1014 // Tests the size of the AssertHelper class.
1015
1016 TEST(AssertHelperTest, AssertHelperIsSmall) {
1017   // To avoid breaking clients that use lots of assertions in one
1018   // function, we cannot grow the size of AssertHelper.
1019   EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));
1020 }
1021
1022 // Tests String::EndsWithCaseInsensitive().
1023 TEST(StringTest, EndsWithCaseInsensitive) {
1024   EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR"));
1025   EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar"));
1026   EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", ""));
1027   EXPECT_TRUE(String::EndsWithCaseInsensitive("", ""));
1028
1029   EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo"));
1030   EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo"));
1031   EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo"));
1032 }
1033
1034 // C++Builder's preprocessor is buggy; it fails to expand macros that
1035 // appear in macro parameters after wide char literals.  Provide an alias
1036 // for NULL as a workaround.
1037 static const wchar_t* const kNull = NULL;
1038
1039 // Tests String::CaseInsensitiveWideCStringEquals
1040 TEST(StringTest, CaseInsensitiveWideCStringEquals) {
1041   EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL));
1042   EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L""));
1043   EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull));
1044   EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar"));
1045   EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull));
1046   EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar"));
1047   EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR"));
1048   EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
1049 }
1050
1051 #if GTEST_OS_WINDOWS
1052
1053 // Tests String::ShowWideCString().
1054 TEST(StringTest, ShowWideCString) {
1055   EXPECT_STREQ("(null)",
1056                String::ShowWideCString(NULL).c_str());
1057   EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
1058   EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
1059 }
1060
1061 # if GTEST_OS_WINDOWS_MOBILE
1062 TEST(StringTest, AnsiAndUtf16Null) {
1063   EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
1064   EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
1065 }
1066
1067 TEST(StringTest, AnsiAndUtf16ConvertBasic) {
1068   const char* ansi = String::Utf16ToAnsi(L"str");
1069   EXPECT_STREQ("str", ansi);
1070   delete [] ansi;
1071   const WCHAR* utf16 = String::AnsiToUtf16("str");
1072   EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
1073   delete [] utf16;
1074 }
1075
1076 TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
1077   const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
1078   EXPECT_STREQ(".:\\ \"*?", ansi);
1079   delete [] ansi;
1080   const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
1081   EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
1082   delete [] utf16;
1083 }
1084 # endif  // GTEST_OS_WINDOWS_MOBILE
1085
1086 #endif  // GTEST_OS_WINDOWS
1087
1088 // Tests TestProperty construction.
1089 TEST(TestPropertyTest, StringValue) {
1090   TestProperty property("key", "1");
1091   EXPECT_STREQ("key", property.key());
1092   EXPECT_STREQ("1", property.value());
1093 }
1094
1095 // Tests TestProperty replacing a value.
1096 TEST(TestPropertyTest, ReplaceStringValue) {
1097   TestProperty property("key", "1");
1098   EXPECT_STREQ("1", property.value());
1099   property.SetValue("2");
1100   EXPECT_STREQ("2", property.value());
1101 }
1102
1103 // AddFatalFailure() and AddNonfatalFailure() must be stand-alone
1104 // functions (i.e. their definitions cannot be inlined at the call
1105 // sites), or C++Builder won't compile the code.
1106 static void AddFatalFailure() {
1107   FAIL() << "Expected fatal failure.";
1108 }
1109
1110 static void AddNonfatalFailure() {
1111   ADD_FAILURE() << "Expected non-fatal failure.";
1112 }
1113
1114 class ScopedFakeTestPartResultReporterTest : public Test {
1115  public:  // Must be public and not protected due to a bug in g++ 3.4.2.
1116   enum FailureMode {
1117     FATAL_FAILURE,
1118     NONFATAL_FAILURE
1119   };
1120   static void AddFailure(FailureMode failure) {
1121     if (failure == FATAL_FAILURE) {
1122       AddFatalFailure();
1123     } else {
1124       AddNonfatalFailure();
1125     }
1126   }
1127 };
1128
1129 // Tests that ScopedFakeTestPartResultReporter intercepts test
1130 // failures.
1131 TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {
1132   TestPartResultArray results;
1133   {
1134     ScopedFakeTestPartResultReporter reporter(
1135         ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
1136         &results);
1137     AddFailure(NONFATAL_FAILURE);
1138     AddFailure(FATAL_FAILURE);
1139   }
1140
1141   EXPECT_EQ(2, results.size());
1142   EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
1143   EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
1144 }
1145
1146 TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
1147   TestPartResultArray results;
1148   {
1149     // Tests, that the deprecated constructor still works.
1150     ScopedFakeTestPartResultReporter reporter(&results);
1151     AddFailure(NONFATAL_FAILURE);
1152   }
1153   EXPECT_EQ(1, results.size());
1154 }
1155
1156 #if GTEST_IS_THREADSAFE
1157
1158 class ScopedFakeTestPartResultReporterWithThreadsTest
1159   : public ScopedFakeTestPartResultReporterTest {
1160  protected:
1161   static void AddFailureInOtherThread(FailureMode failure) {
1162     ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
1163     thread.Join();
1164   }
1165 };
1166
1167 TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,
1168        InterceptsTestFailuresInAllThreads) {
1169   TestPartResultArray results;
1170   {
1171     ScopedFakeTestPartResultReporter reporter(
1172         ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results);
1173     AddFailure(NONFATAL_FAILURE);
1174     AddFailure(FATAL_FAILURE);
1175     AddFailureInOtherThread(NONFATAL_FAILURE);
1176     AddFailureInOtherThread(FATAL_FAILURE);
1177   }
1178
1179   EXPECT_EQ(4, results.size());
1180   EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
1181   EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
1182   EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed());
1183   EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed());
1184 }
1185
1186 #endif  // GTEST_IS_THREADSAFE
1187
1188 // Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}.  Makes sure that they
1189 // work even if the failure is generated in a called function rather than
1190 // the current context.
1191
1192 typedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest;
1193
1194 TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {
1195   EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure.");
1196 }
1197
1198 #if GTEST_HAS_GLOBAL_STRING
1199 TEST_F(ExpectFatalFailureTest, AcceptsStringObject) {
1200   EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure."));
1201 }
1202 #endif
1203
1204 TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {
1205   EXPECT_FATAL_FAILURE(AddFatalFailure(),
1206                        ::std::string("Expected fatal failure."));
1207 }
1208
1209 TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
1210   // We have another test below to verify that the macro catches fatal
1211   // failures generated on another thread.
1212   EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(),
1213                                       "Expected fatal failure.");
1214 }
1215
1216 #ifdef __BORLANDC__
1217 // Silences warnings: "Condition is always true"
1218 # pragma option push -w-ccc
1219 #endif
1220
1221 // Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
1222 // function even when the statement in it contains ASSERT_*.
1223
1224 int NonVoidFunction() {
1225   EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
1226   EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
1227   return 0;
1228 }
1229
1230 TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {
1231   NonVoidFunction();
1232 }
1233
1234 // Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the
1235 // current function even though 'statement' generates a fatal failure.
1236
1237 void DoesNotAbortHelper(bool* aborted) {
1238   EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
1239   EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
1240
1241   *aborted = false;
1242 }
1243
1244 #ifdef __BORLANDC__
1245 // Restores warnings after previous "#pragma option push" suppressed them.
1246 # pragma option pop
1247 #endif
1248
1249 TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
1250   bool aborted = true;
1251   DoesNotAbortHelper(&aborted);
1252   EXPECT_FALSE(aborted);
1253 }
1254
1255 // Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a
1256 // statement that contains a macro which expands to code containing an
1257 // unprotected comma.
1258
1259 static int global_var = 0;
1260 #define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++
1261
1262 TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
1263 #ifndef __BORLANDC__
1264   // ICE's in C++Builder.
1265   EXPECT_FATAL_FAILURE({
1266     GTEST_USE_UNPROTECTED_COMMA_;
1267     AddFatalFailure();
1268   }, "");
1269 #endif
1270
1271   EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
1272     GTEST_USE_UNPROTECTED_COMMA_;
1273     AddFatalFailure();
1274   }, "");
1275 }
1276
1277 // Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
1278
1279 typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
1280
1281 TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
1282   EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
1283                           "Expected non-fatal failure.");
1284 }
1285
1286 #if GTEST_HAS_GLOBAL_STRING
1287 TEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) {
1288   EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
1289                           ::string("Expected non-fatal failure."));
1290 }
1291 #endif
1292
1293 TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
1294   EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
1295                           ::std::string("Expected non-fatal failure."));
1296 }
1297
1298 TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
1299   // We have another test below to verify that the macro catches
1300   // non-fatal failures generated on another thread.
1301   EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(),
1302                                          "Expected non-fatal failure.");
1303 }
1304
1305 // Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a
1306 // statement that contains a macro which expands to code containing an
1307 // unprotected comma.
1308 TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
1309   EXPECT_NONFATAL_FAILURE({
1310     GTEST_USE_UNPROTECTED_COMMA_;
1311     AddNonfatalFailure();
1312   }, "");
1313
1314   EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
1315     GTEST_USE_UNPROTECTED_COMMA_;
1316     AddNonfatalFailure();
1317   }, "");
1318 }
1319
1320 #if GTEST_IS_THREADSAFE
1321
1322 typedef ScopedFakeTestPartResultReporterWithThreadsTest
1323     ExpectFailureWithThreadsTest;
1324
1325 TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {
1326   EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE),
1327                                       "Expected fatal failure.");
1328 }
1329
1330 TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {
1331   EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
1332       AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure.");
1333 }
1334
1335 #endif  // GTEST_IS_THREADSAFE
1336
1337 // Tests the TestProperty class.
1338
1339 TEST(TestPropertyTest, ConstructorWorks) {
1340   const TestProperty property("key", "value");
1341   EXPECT_STREQ("key", property.key());
1342   EXPECT_STREQ("value", property.value());
1343 }
1344
1345 TEST(TestPropertyTest, SetValue) {
1346   TestProperty property("key", "value_1");
1347   EXPECT_STREQ("key", property.key());
1348   property.SetValue("value_2");
1349   EXPECT_STREQ("key", property.key());
1350   EXPECT_STREQ("value_2", property.value());
1351 }
1352
1353 // Tests the TestResult class
1354
1355 // The test fixture for testing TestResult.
1356 class TestResultTest : public Test {
1357  protected:
1358   typedef std::vector<TestPartResult> TPRVector;
1359
1360   // We make use of 2 TestPartResult objects,
1361   TestPartResult * pr1, * pr2;
1362
1363   // ... and 3 TestResult objects.
1364   TestResult * r0, * r1, * r2;
1365
1366   virtual void SetUp() {
1367     // pr1 is for success.
1368     pr1 = new TestPartResult(TestPartResult::kSuccess,
1369                              "foo/bar.cc",
1370                              10,
1371                              "Success!");
1372
1373     // pr2 is for fatal failure.
1374     pr2 = new TestPartResult(TestPartResult::kFatalFailure,
1375                              "foo/bar.cc",
1376                              -1,  // This line number means "unknown"
1377                              "Failure!");
1378
1379     // Creates the TestResult objects.
1380     r0 = new TestResult();
1381     r1 = new TestResult();
1382     r2 = new TestResult();
1383
1384     // In order to test TestResult, we need to modify its internal
1385     // state, in particular the TestPartResult vector it holds.
1386     // test_part_results() returns a const reference to this vector.
1387     // We cast it to a non-const object s.t. it can be modified
1388     TPRVector* results1 = const_cast<TPRVector*>(
1389         &TestResultAccessor::test_part_results(*r1));
1390     TPRVector* results2 = const_cast<TPRVector*>(
1391         &TestResultAccessor::test_part_results(*r2));
1392
1393     // r0 is an empty TestResult.
1394
1395     // r1 contains a single SUCCESS TestPartResult.
1396     results1->push_back(*pr1);
1397
1398     // r2 contains a SUCCESS, and a FAILURE.
1399     results2->push_back(*pr1);
1400     results2->push_back(*pr2);
1401   }
1402
1403   virtual void TearDown() {
1404     delete pr1;
1405     delete pr2;
1406
1407     delete r0;
1408     delete r1;
1409     delete r2;
1410   }
1411
1412   // Helper that compares two TestPartResults.
1413   static void CompareTestPartResult(const TestPartResult& expected,
1414                                     const TestPartResult& actual) {
1415     EXPECT_EQ(expected.type(), actual.type());
1416     EXPECT_STREQ(expected.file_name(), actual.file_name());
1417     EXPECT_EQ(expected.line_number(), actual.line_number());
1418     EXPECT_STREQ(expected.summary(), actual.summary());
1419     EXPECT_STREQ(expected.message(), actual.message());
1420     EXPECT_EQ(expected.passed(), actual.passed());
1421     EXPECT_EQ(expected.failed(), actual.failed());
1422     EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed());
1423     EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed());
1424   }
1425 };
1426
1427 // Tests TestResult::total_part_count().
1428 TEST_F(TestResultTest, total_part_count) {
1429   ASSERT_EQ(0, r0->total_part_count());
1430   ASSERT_EQ(1, r1->total_part_count());
1431   ASSERT_EQ(2, r2->total_part_count());
1432 }
1433
1434 // Tests TestResult::Passed().
1435 TEST_F(TestResultTest, Passed) {
1436   ASSERT_TRUE(r0->Passed());
1437   ASSERT_TRUE(r1->Passed());
1438   ASSERT_FALSE(r2->Passed());
1439 }
1440
1441 // Tests TestResult::Failed().
1442 TEST_F(TestResultTest, Failed) {
1443   ASSERT_FALSE(r0->Failed());
1444   ASSERT_FALSE(r1->Failed());
1445   ASSERT_TRUE(r2->Failed());
1446 }
1447
1448 // Tests TestResult::GetTestPartResult().
1449
1450 typedef TestResultTest TestResultDeathTest;
1451
1452 TEST_F(TestResultDeathTest, GetTestPartResult) {
1453   CompareTestPartResult(*pr1, r2->GetTestPartResult(0));
1454   CompareTestPartResult(*pr2, r2->GetTestPartResult(1));
1455   EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), "");
1456   EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), "");
1457 }
1458
1459 // Tests TestResult has no properties when none are added.
1460 TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {
1461   TestResult test_result;
1462   ASSERT_EQ(0, test_result.test_property_count());
1463 }
1464
1465 // Tests TestResult has the expected property when added.
1466 TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {
1467   TestResult test_result;
1468   TestProperty property("key_1", "1");
1469   TestResultAccessor::RecordProperty(&test_result, "testcase", property);
1470   ASSERT_EQ(1, test_result.test_property_count());
1471   const TestProperty& actual_property = test_result.GetTestProperty(0);
1472   EXPECT_STREQ("key_1", actual_property.key());
1473   EXPECT_STREQ("1", actual_property.value());
1474 }
1475
1476 // Tests TestResult has multiple properties when added.
1477 TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {
1478   TestResult test_result;
1479   TestProperty property_1("key_1", "1");
1480   TestProperty property_2("key_2", "2");
1481   TestResultAccessor::RecordProperty(&test_result, "testcase", property_1);
1482   TestResultAccessor::RecordProperty(&test_result, "testcase", property_2);
1483   ASSERT_EQ(2, test_result.test_property_count());
1484   const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
1485   EXPECT_STREQ("key_1", actual_property_1.key());
1486   EXPECT_STREQ("1", actual_property_1.value());
1487
1488   const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
1489   EXPECT_STREQ("key_2", actual_property_2.key());
1490   EXPECT_STREQ("2", actual_property_2.value());
1491 }
1492
1493 // Tests TestResult::RecordProperty() overrides values for duplicate keys.
1494 TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {
1495   TestResult test_result;
1496   TestProperty property_1_1("key_1", "1");
1497   TestProperty property_2_1("key_2", "2");
1498   TestProperty property_1_2("key_1", "12");
1499   TestProperty property_2_2("key_2", "22");
1500   TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_1);
1501   TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_1);
1502   TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_2);
1503   TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_2);
1504
1505   ASSERT_EQ(2, test_result.test_property_count());
1506   const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
1507   EXPECT_STREQ("key_1", actual_property_1.key());
1508   EXPECT_STREQ("12", actual_property_1.value());
1509
1510   const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
1511   EXPECT_STREQ("key_2", actual_property_2.key());
1512   EXPECT_STREQ("22", actual_property_2.value());
1513 }
1514
1515 // Tests TestResult::GetTestProperty().
1516 TEST(TestResultPropertyTest, GetTestProperty) {
1517   TestResult test_result;
1518   TestProperty property_1("key_1", "1");
1519   TestProperty property_2("key_2", "2");
1520   TestProperty property_3("key_3", "3");
1521   TestResultAccessor::RecordProperty(&test_result, "testcase", property_1);
1522   TestResultAccessor::RecordProperty(&test_result, "testcase", property_2);
1523   TestResultAccessor::RecordProperty(&test_result, "testcase", property_3);
1524
1525   const TestProperty& fetched_property_1 = test_result.GetTestProperty(0);
1526   const TestProperty& fetched_property_2 = test_result.GetTestProperty(1);
1527   const TestProperty& fetched_property_3 = test_result.GetTestProperty(2);
1528
1529   EXPECT_STREQ("key_1", fetched_property_1.key());
1530   EXPECT_STREQ("1", fetched_property_1.value());
1531
1532   EXPECT_STREQ("key_2", fetched_property_2.key());
1533   EXPECT_STREQ("2", fetched_property_2.value());
1534
1535   EXPECT_STREQ("key_3", fetched_property_3.key());
1536   EXPECT_STREQ("3", fetched_property_3.value());
1537
1538   EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), "");
1539   EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), "");
1540 }
1541
1542 // Tests the Test class.
1543 //
1544 // It's difficult to test every public method of this class (we are
1545 // already stretching the limit of Google Test by using it to test itself!).
1546 // Fortunately, we don't have to do that, as we are already testing
1547 // the functionalities of the Test class extensively by using Google Test
1548 // alone.
1549 //
1550 // Therefore, this section only contains one test.
1551
1552 // Tests that GTestFlagSaver works on Windows and Mac.
1553
1554 class GTestFlagSaverTest : public Test {
1555  protected:
1556   // Saves the Google Test flags such that we can restore them later, and
1557   // then sets them to their default values.  This will be called
1558   // before the first test in this test case is run.
1559   static void SetUpTestCase() {
1560     saver_ = new GTestFlagSaver;
1561
1562     GTEST_FLAG(also_run_disabled_tests) = false;
1563     GTEST_FLAG(break_on_failure) = false;
1564     GTEST_FLAG(catch_exceptions) = false;
1565     GTEST_FLAG(death_test_use_fork) = false;
1566     GTEST_FLAG(color) = "auto";
1567     GTEST_FLAG(filter) = "";
1568     GTEST_FLAG(list_tests) = false;
1569     GTEST_FLAG(output) = "";
1570     GTEST_FLAG(print_time) = true;
1571     GTEST_FLAG(random_seed) = 0;
1572     GTEST_FLAG(repeat) = 1;
1573     GTEST_FLAG(shuffle) = false;
1574     GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
1575     GTEST_FLAG(stream_result_to) = "";
1576     GTEST_FLAG(throw_on_failure) = false;
1577   }
1578
1579   // Restores the Google Test flags that the tests have modified.  This will
1580   // be called after the last test in this test case is run.
1581   static void TearDownTestCase() {
1582     delete saver_;
1583     saver_ = NULL;
1584   }
1585
1586   // Verifies that the Google Test flags have their default values, and then
1587   // modifies each of them.
1588   void VerifyAndModifyFlags() {
1589     EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
1590     EXPECT_FALSE(GTEST_FLAG(break_on_failure));
1591     EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
1592     EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
1593     EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
1594     EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
1595     EXPECT_FALSE(GTEST_FLAG(list_tests));
1596     EXPECT_STREQ("", GTEST_FLAG(output).c_str());
1597     EXPECT_TRUE(GTEST_FLAG(print_time));
1598     EXPECT_EQ(0, GTEST_FLAG(random_seed));
1599     EXPECT_EQ(1, GTEST_FLAG(repeat));
1600     EXPECT_FALSE(GTEST_FLAG(shuffle));
1601     EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
1602     EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
1603     EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
1604
1605     GTEST_FLAG(also_run_disabled_tests) = true;
1606     GTEST_FLAG(break_on_failure) = true;
1607     GTEST_FLAG(catch_exceptions) = true;
1608     GTEST_FLAG(color) = "no";
1609     GTEST_FLAG(death_test_use_fork) = true;
1610     GTEST_FLAG(filter) = "abc";
1611     GTEST_FLAG(list_tests) = true;
1612     GTEST_FLAG(output) = "xml:foo.xml";
1613     GTEST_FLAG(print_time) = false;
1614     GTEST_FLAG(random_seed) = 1;
1615     GTEST_FLAG(repeat) = 100;
1616     GTEST_FLAG(shuffle) = true;
1617     GTEST_FLAG(stack_trace_depth) = 1;
1618     GTEST_FLAG(stream_result_to) = "localhost:1234";
1619     GTEST_FLAG(throw_on_failure) = true;
1620   }
1621
1622  private:
1623   // For saving Google Test flags during this test case.
1624   static GTestFlagSaver* saver_;
1625 };
1626
1627 GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL;
1628
1629 // Google Test doesn't guarantee the order of tests.  The following two
1630 // tests are designed to work regardless of their order.
1631
1632 // Modifies the Google Test flags in the test body.
1633 TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
1634   VerifyAndModifyFlags();
1635 }
1636
1637 // Verifies that the Google Test flags in the body of the previous test were
1638 // restored to their original values.
1639 TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
1640   VerifyAndModifyFlags();
1641 }
1642
1643 // Sets an environment variable with the given name to the given
1644 // value.  If the value argument is "", unsets the environment
1645 // variable.  The caller must ensure that both arguments are not NULL.
1646 static void SetEnv(const char* name, const char* value) {
1647 #if GTEST_OS_WINDOWS_MOBILE
1648   // Environment variables are not supported on Windows CE.
1649   return;
1650 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
1651   // C++Builder's putenv only stores a pointer to its parameter; we have to
1652   // ensure that the string remains valid as long as it might be needed.
1653   // We use an std::map to do so.
1654   static std::map<std::string, std::string*> added_env;
1655
1656   // Because putenv stores a pointer to the string buffer, we can't delete the
1657   // previous string (if present) until after it's replaced.
1658   std::string *prev_env = NULL;
1659   if (added_env.find(name) != added_env.end()) {
1660     prev_env = added_env[name];
1661   }
1662   added_env[name] = new std::string(
1663       (Message() << name << "=" << value).GetString());
1664
1665   // The standard signature of putenv accepts a 'char*' argument. Other
1666   // implementations, like C++Builder's, accept a 'const char*'.
1667   // We cast away the 'const' since that would work for both variants.
1668   putenv(const_cast<char*>(added_env[name]->c_str()));
1669   delete prev_env;
1670 #elif GTEST_OS_WINDOWS  // If we are on Windows proper.
1671   _putenv((Message() << name << "=" << value).GetString().c_str());
1672 #else
1673   if (*value == '\0') {
1674     unsetenv(name);
1675   } else {
1676     setenv(name, value, 1);
1677   }
1678 #endif  // GTEST_OS_WINDOWS_MOBILE
1679 }
1680
1681 #if !GTEST_OS_WINDOWS_MOBILE
1682 // Environment variables are not supported on Windows CE.
1683
1684 using testing::internal::Int32FromGTestEnv;
1685
1686 // Tests Int32FromGTestEnv().
1687
1688 // Tests that Int32FromGTestEnv() returns the default value when the
1689 // environment variable is not set.
1690 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
1691   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");
1692   EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
1693 }
1694
1695 # if !defined(GTEST_GET_INT32_FROM_ENV_)
1696
1697 // Tests that Int32FromGTestEnv() returns the default value when the
1698 // environment variable overflows as an Int32.
1699 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
1700   printf("(expecting 2 warnings)\n");
1701
1702   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");
1703   EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));
1704
1705   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");
1706   EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));
1707 }
1708
1709 // Tests that Int32FromGTestEnv() returns the default value when the
1710 // environment variable does not represent a valid decimal integer.
1711 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
1712   printf("(expecting 2 warnings)\n");
1713
1714   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");
1715   EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));
1716
1717   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");
1718   EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
1719 }
1720
1721 # endif  // !defined(GTEST_GET_INT32_FROM_ENV_)
1722
1723 // Tests that Int32FromGTestEnv() parses and returns the value of the
1724 // environment variable when it represents a valid decimal integer in
1725 // the range of an Int32.
1726 TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
1727   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123");
1728   EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));
1729
1730   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");
1731   EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));
1732 }
1733 #endif  // !GTEST_OS_WINDOWS_MOBILE
1734
1735 // Tests ParseInt32Flag().
1736
1737 // Tests that ParseInt32Flag() returns false and doesn't change the
1738 // output value when the flag has wrong format
1739 TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
1740   Int32 value = 123;
1741   EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
1742   EXPECT_EQ(123, value);
1743
1744   EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
1745   EXPECT_EQ(123, value);
1746 }
1747
1748 // Tests that ParseInt32Flag() returns false and doesn't change the
1749 // output value when the flag overflows as an Int32.
1750 TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
1751   printf("(expecting 2 warnings)\n");
1752
1753   Int32 value = 123;
1754   EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
1755   EXPECT_EQ(123, value);
1756
1757   EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
1758   EXPECT_EQ(123, value);
1759 }
1760
1761 // Tests that ParseInt32Flag() returns false and doesn't change the
1762 // output value when the flag does not represent a valid decimal
1763 // integer.
1764 TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
1765   printf("(expecting 2 warnings)\n");
1766
1767   Int32 value = 123;
1768   EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
1769   EXPECT_EQ(123, value);
1770
1771   EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
1772   EXPECT_EQ(123, value);
1773 }
1774
1775 // Tests that ParseInt32Flag() parses the value of the flag and
1776 // returns true when the flag represents a valid decimal integer in
1777 // the range of an Int32.
1778 TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
1779   Int32 value = 123;
1780   EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
1781   EXPECT_EQ(456, value);
1782
1783   EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789",
1784                              "abc", &value));
1785   EXPECT_EQ(-789, value);
1786 }
1787
1788 // Tests that Int32FromEnvOrDie() parses the value of the var or
1789 // returns the correct default.
1790 // Environment variables are not supported on Windows CE.
1791 #if !GTEST_OS_WINDOWS_MOBILE
1792 TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
1793   EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
1794   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123");
1795   EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
1796   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123");
1797   EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
1798 }
1799 #endif  // !GTEST_OS_WINDOWS_MOBILE
1800
1801 // Tests that Int32FromEnvOrDie() aborts with an error message
1802 // if the variable is not an Int32.
1803 TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
1804   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
1805   EXPECT_DEATH_IF_SUPPORTED(
1806       Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
1807       ".*");
1808 }
1809
1810 // Tests that Int32FromEnvOrDie() aborts with an error message
1811 // if the variable cannot be represented by an Int32.
1812 TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
1813   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
1814   EXPECT_DEATH_IF_SUPPORTED(
1815       Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
1816       ".*");
1817 }
1818
1819 // Tests that ShouldRunTestOnShard() selects all tests
1820 // where there is 1 shard.
1821 TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
1822   EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0));
1823   EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1));
1824   EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2));
1825   EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3));
1826   EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4));
1827 }
1828
1829 class ShouldShardTest : public testing::Test {
1830  protected:
1831   virtual void SetUp() {
1832     index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";
1833     total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";
1834   }
1835
1836   virtual void TearDown() {
1837     SetEnv(index_var_, "");
1838     SetEnv(total_var_, "");
1839   }
1840
1841   const char* index_var_;
1842   const char* total_var_;
1843 };
1844
1845 // Tests that sharding is disabled if neither of the environment variables
1846 // are set.
1847 TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {
1848   SetEnv(index_var_, "");
1849   SetEnv(total_var_, "");
1850
1851   EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
1852   EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1853 }
1854
1855 // Tests that sharding is not enabled if total_shards  == 1.
1856 TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
1857   SetEnv(index_var_, "0");
1858   SetEnv(total_var_, "1");
1859   EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
1860   EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1861 }
1862
1863 // Tests that sharding is enabled if total_shards > 1 and
1864 // we are not in a death test subprocess.
1865 // Environment variables are not supported on Windows CE.
1866 #if !GTEST_OS_WINDOWS_MOBILE
1867 TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
1868   SetEnv(index_var_, "4");
1869   SetEnv(total_var_, "22");
1870   EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
1871   EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1872
1873   SetEnv(index_var_, "8");
1874   SetEnv(total_var_, "9");
1875   EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
1876   EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1877
1878   SetEnv(index_var_, "0");
1879   SetEnv(total_var_, "9");
1880   EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
1881   EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1882 }
1883 #endif  // !GTEST_OS_WINDOWS_MOBILE
1884
1885 // Tests that we exit in error if the sharding values are not valid.
1886
1887 typedef ShouldShardTest ShouldShardDeathTest;
1888
1889 TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {
1890   SetEnv(index_var_, "4");
1891   SetEnv(total_var_, "4");
1892   EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1893
1894   SetEnv(index_var_, "4");
1895   SetEnv(total_var_, "-2");
1896   EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1897
1898   SetEnv(index_var_, "5");
1899   SetEnv(total_var_, "");
1900   EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1901
1902   SetEnv(index_var_, "");
1903   SetEnv(total_var_, "5");
1904   EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1905 }
1906
1907 // Tests that ShouldRunTestOnShard is a partition when 5
1908 // shards are used.
1909 TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
1910   // Choose an arbitrary number of tests and shards.
1911   const int num_tests = 17;
1912   const int num_shards = 5;
1913
1914   // Check partitioning: each test should be on exactly 1 shard.
1915   for (int test_id = 0; test_id < num_tests; test_id++) {
1916     int prev_selected_shard_index = -1;
1917     for (int shard_index = 0; shard_index < num_shards; shard_index++) {
1918       if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) {
1919         if (prev_selected_shard_index < 0) {
1920           prev_selected_shard_index = shard_index;
1921         } else {
1922           ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
1923             << shard_index << " are both selected to run test " << test_id;
1924         }
1925       }
1926     }
1927   }
1928
1929   // Check balance: This is not required by the sharding protocol, but is a
1930   // desirable property for performance.
1931   for (int shard_index = 0; shard_index < num_shards; shard_index++) {
1932     int num_tests_on_shard = 0;
1933     for (int test_id = 0; test_id < num_tests; test_id++) {
1934       num_tests_on_shard +=
1935         ShouldRunTestOnShard(num_shards, shard_index, test_id);
1936     }
1937     EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
1938   }
1939 }
1940
1941 // For the same reason we are not explicitly testing everything in the
1942 // Test class, there are no separate tests for the following classes
1943 // (except for some trivial cases):
1944 //
1945 //   TestCase, UnitTest, UnitTestResultPrinter.
1946 //
1947 // Similarly, there are no separate tests for the following macros:
1948 //
1949 //   TEST, TEST_F, RUN_ALL_TESTS
1950
1951 TEST(UnitTestTest, CanGetOriginalWorkingDir) {
1952   ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL);
1953   EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), "");
1954 }
1955
1956 TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
1957   EXPECT_LT(0, UnitTest::GetInstance()->start_timestamp());
1958   EXPECT_LE(UnitTest::GetInstance()->start_timestamp(), GetTimeInMillis());
1959 }
1960
1961 // When a property using a reserved key is supplied to this function, it
1962 // tests that a non-fatal failure is added, a fatal failure is not added,
1963 // and that the property is not recorded.
1964 void ExpectNonFatalFailureRecordingPropertyWithReservedKey(
1965     const TestResult& test_result, const char* key) {
1966   EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key");
1967   ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key
1968                                                   << "' recorded unexpectedly.";
1969 }
1970
1971 void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
1972     const char* key) {
1973   const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
1974   ASSERT_TRUE(test_info != NULL);
1975   ExpectNonFatalFailureRecordingPropertyWithReservedKey(*test_info->result(),
1976                                                         key);
1977 }
1978
1979 void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
1980     const char* key) {
1981   const TestCase* test_case = UnitTest::GetInstance()->current_test_case();
1982   ASSERT_TRUE(test_case != NULL);
1983   ExpectNonFatalFailureRecordingPropertyWithReservedKey(
1984       test_case->ad_hoc_test_result(), key);
1985 }
1986
1987 void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
1988     const char* key) {
1989   ExpectNonFatalFailureRecordingPropertyWithReservedKey(
1990       UnitTest::GetInstance()->ad_hoc_test_result(), key);
1991 }
1992
1993 // Tests that property recording functions in UnitTest outside of tests
1994 // functions correcly.  Creating a separate instance of UnitTest ensures it
1995 // is in a state similar to the UnitTest's singleton's between tests.
1996 class UnitTestRecordPropertyTest :
1997     public testing::internal::UnitTestRecordPropertyTestHelper {
1998  public:
1999   static void SetUpTestCase() {
2000     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
2001         "disabled");
2002     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
2003         "errors");
2004     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
2005         "failures");
2006     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
2007         "name");
2008     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
2009         "tests");
2010     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
2011         "time");
2012
2013     Test::RecordProperty("test_case_key_1", "1");
2014     const TestCase* test_case = UnitTest::GetInstance()->current_test_case();
2015     ASSERT_TRUE(test_case != NULL);
2016
2017     ASSERT_EQ(1, test_case->ad_hoc_test_result().test_property_count());
2018     EXPECT_STREQ("test_case_key_1",
2019                  test_case->ad_hoc_test_result().GetTestProperty(0).key());
2020     EXPECT_STREQ("1",
2021                  test_case->ad_hoc_test_result().GetTestProperty(0).value());
2022   }
2023 };
2024
2025 // Tests TestResult has the expected property when added.
2026 TEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) {
2027   UnitTestRecordProperty("key_1", "1");
2028
2029   ASSERT_EQ(1, unit_test_.ad_hoc_test_result().test_property_count());
2030
2031   EXPECT_STREQ("key_1",
2032                unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
2033   EXPECT_STREQ("1",
2034                unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
2035 }
2036
2037 // Tests TestResult has multiple properties when added.
2038 TEST_F(UnitTestRecordPropertyTest, MultiplePropertiesFoundWhenAdded) {
2039   UnitTestRecordProperty("key_1", "1");
2040   UnitTestRecordProperty("key_2", "2");
2041
2042   ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count());
2043
2044   EXPECT_STREQ("key_1",
2045                unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
2046   EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
2047
2048   EXPECT_STREQ("key_2",
2049                unit_test_.ad_hoc_test_result().GetTestProperty(1).key());
2050   EXPECT_STREQ("2", unit_test_.ad_hoc_test_result().GetTestProperty(1).value());
2051 }
2052
2053 // Tests TestResult::RecordProperty() overrides values for duplicate keys.
2054 TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) {
2055   UnitTestRecordProperty("key_1", "1");
2056   UnitTestRecordProperty("key_2", "2");
2057   UnitTestRecordProperty("key_1", "12");
2058   UnitTestRecordProperty("key_2", "22");
2059
2060   ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count());
2061
2062   EXPECT_STREQ("key_1",
2063                unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
2064   EXPECT_STREQ("12",
2065                unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
2066
2067   EXPECT_STREQ("key_2",
2068                unit_test_.ad_hoc_test_result().GetTestProperty(1).key());
2069   EXPECT_STREQ("22",
2070                unit_test_.ad_hoc_test_result().GetTestProperty(1).value());
2071 }
2072
2073 TEST_F(UnitTestRecordPropertyTest,
2074        AddFailureInsideTestsWhenUsingTestCaseReservedKeys) {
2075   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
2076       "name");
2077   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
2078       "value_param");
2079   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
2080       "type_param");
2081   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
2082       "status");
2083   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
2084       "time");
2085   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
2086       "classname");
2087 }
2088
2089 TEST_F(UnitTestRecordPropertyTest,
2090        AddRecordWithReservedKeysGeneratesCorrectPropertyList) {
2091   EXPECT_NONFATAL_FAILURE(
2092       Test::RecordProperty("name", "1"),
2093       "'classname', 'name', 'status', 'time', 'type_param', 'value_param',"
2094       " 'file', and 'line' are reserved");
2095 }
2096
2097 class UnitTestRecordPropertyTestEnvironment : public Environment {
2098  public:
2099   virtual void TearDown() {
2100     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2101         "tests");
2102     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2103         "failures");
2104     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2105         "disabled");
2106     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2107         "errors");
2108     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2109         "name");
2110     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2111         "timestamp");
2112     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2113         "time");
2114     ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
2115         "random_seed");
2116   }
2117 };
2118
2119 // This will test property recording outside of any test or test case.
2120 static Environment* record_property_env =
2121     AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment);
2122
2123 // This group of tests is for predicate assertions (ASSERT_PRED*, etc)
2124 // of various arities.  They do not attempt to be exhaustive.  Rather,
2125 // view them as smoke tests that can be easily reviewed and verified.
2126 // A more complete set of tests for predicate assertions can be found
2127 // in gtest_pred_impl_unittest.cc.
2128
2129 // First, some predicates and predicate-formatters needed by the tests.
2130
2131 // Returns true iff the argument is an even number.
2132 bool IsEven(int n) {
2133   return (n % 2) == 0;
2134 }
2135
2136 // A functor that returns true iff the argument is an even number.
2137 struct IsEvenFunctor {
2138   bool operator()(int n) { return IsEven(n); }
2139 };
2140
2141 // A predicate-formatter function that asserts the argument is an even
2142 // number.
2143 AssertionResult AssertIsEven(const char* expr, int n) {
2144   if (IsEven(n)) {
2145     return AssertionSuccess();
2146   }
2147
2148   Message msg;
2149   msg << expr << " evaluates to " << n << ", which is not even.";
2150   return AssertionFailure(msg);
2151 }
2152
2153 // A predicate function that returns AssertionResult for use in
2154 // EXPECT/ASSERT_TRUE/FALSE.
2155 AssertionResult ResultIsEven(int n) {
2156   if (IsEven(n))
2157     return AssertionSuccess() << n << " is even";
2158   else
2159     return AssertionFailure() << n << " is odd";
2160 }
2161
2162 // A predicate function that returns AssertionResult but gives no
2163 // explanation why it succeeds. Needed for testing that
2164 // EXPECT/ASSERT_FALSE handles such functions correctly.
2165 AssertionResult ResultIsEvenNoExplanation(int n) {
2166   if (IsEven(n))
2167     return AssertionSuccess();
2168   else
2169     return AssertionFailure() << n << " is odd";
2170 }
2171
2172 // A predicate-formatter functor that asserts the argument is an even
2173 // number.
2174 struct AssertIsEvenFunctor {
2175   AssertionResult operator()(const char* expr, int n) {
2176     return AssertIsEven(expr, n);
2177   }
2178 };
2179
2180 // Returns true iff the sum of the arguments is an even number.
2181 bool SumIsEven2(int n1, int n2) {
2182   return IsEven(n1 + n2);
2183 }
2184
2185 // A functor that returns true iff the sum of the arguments is an even
2186 // number.
2187 struct SumIsEven3Functor {
2188   bool operator()(int n1, int n2, int n3) {
2189     return IsEven(n1 + n2 + n3);
2190   }
2191 };
2192
2193 // A predicate-formatter function that asserts the sum of the
2194 // arguments is an even number.
2195 AssertionResult AssertSumIsEven4(
2196     const char* e1, const char* e2, const char* e3, const char* e4,
2197     int n1, int n2, int n3, int n4) {
2198   const int sum = n1 + n2 + n3 + n4;
2199   if (IsEven(sum)) {
2200     return AssertionSuccess();
2201   }
2202
2203   Message msg;
2204   msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
2205       << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
2206       << ") evaluates to " << sum << ", which is not even.";
2207   return AssertionFailure(msg);
2208 }
2209
2210 // A predicate-formatter functor that asserts the sum of the arguments
2211 // is an even number.
2212 struct AssertSumIsEven5Functor {
2213   AssertionResult operator()(
2214       const char* e1, const char* e2, const char* e3, const char* e4,
2215       const char* e5, int n1, int n2, int n3, int n4, int n5) {
2216     const int sum = n1 + n2 + n3 + n4 + n5;
2217     if (IsEven(sum)) {
2218       return AssertionSuccess();
2219     }
2220
2221     Message msg;
2222     msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
2223         << " ("
2224         << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
2225         << ") evaluates to " << sum << ", which is not even.";
2226     return AssertionFailure(msg);
2227   }
2228 };
2229
2230
2231 // Tests unary predicate assertions.
2232
2233 // Tests unary predicate assertions that don't use a custom formatter.
2234 TEST(Pred1Test, WithoutFormat) {
2235   // Success cases.
2236   EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!";
2237   ASSERT_PRED1(IsEven, 4);
2238
2239   // Failure cases.
2240   EXPECT_NONFATAL_FAILURE({  // NOLINT
2241     EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
2242   }, "This failure is expected.");
2243   EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
2244                        "evaluates to false");
2245 }
2246
2247 // Tests unary predicate assertions that use a custom formatter.
2248 TEST(Pred1Test, WithFormat) {
2249   // Success cases.
2250   EXPECT_PRED_FORMAT1(AssertIsEven, 2);
2251   ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
2252     << "This failure is UNEXPECTED!";
2253
2254   // Failure cases.
2255   const int n = 5;
2256   EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
2257                           "n evaluates to 5, which is not even.");
2258   EXPECT_FATAL_FAILURE({  // NOLINT
2259     ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
2260   }, "This failure is expected.");
2261 }
2262
2263 // Tests that unary predicate assertions evaluates their arguments
2264 // exactly once.
2265 TEST(Pred1Test, SingleEvaluationOnFailure) {
2266   // A success case.
2267   static int n = 0;
2268   EXPECT_PRED1(IsEven, n++);
2269   EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
2270
2271   // A failure case.
2272   EXPECT_FATAL_FAILURE({  // NOLINT
2273     ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
2274         << "This failure is expected.";
2275   }, "This failure is expected.");
2276   EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
2277 }
2278
2279
2280 // Tests predicate assertions whose arity is >= 2.
2281
2282 // Tests predicate assertions that don't use a custom formatter.
2283 TEST(PredTest, WithoutFormat) {
2284   // Success cases.
2285   ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!";
2286   EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8);
2287
2288   // Failure cases.
2289   const int n1 = 1;
2290   const int n2 = 2;
2291   EXPECT_NONFATAL_FAILURE({  // NOLINT
2292     EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
2293   }, "This failure is expected.");
2294   EXPECT_FATAL_FAILURE({  // NOLINT
2295     ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
2296   }, "evaluates to false");
2297 }
2298
2299 // Tests predicate assertions that use a custom formatter.
2300 TEST(PredTest, WithFormat) {
2301   // Success cases.
2302   ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
2303     "This failure is UNEXPECTED!";
2304   EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
2305
2306   // Failure cases.
2307   const int n1 = 1;
2308   const int n2 = 2;
2309   const int n3 = 4;
2310   const int n4 = 6;
2311   EXPECT_NONFATAL_FAILURE({  // NOLINT
2312     EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
2313   }, "evaluates to 13, which is not even.");
2314   EXPECT_FATAL_FAILURE({  // NOLINT
2315     ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
2316         << "This failure is expected.";
2317   }, "This failure is expected.");
2318 }
2319
2320 // Tests that predicate assertions evaluates their arguments
2321 // exactly once.
2322 TEST(PredTest, SingleEvaluationOnFailure) {
2323   // A success case.
2324   int n1 = 0;
2325   int n2 = 0;
2326   EXPECT_PRED2(SumIsEven2, n1++, n2++);
2327   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2328   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2329
2330   // Another success case.
2331   n1 = n2 = 0;
2332   int n3 = 0;
2333   int n4 = 0;
2334   int n5 = 0;
2335   ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
2336                       n1++, n2++, n3++, n4++, n5++)
2337                         << "This failure is UNEXPECTED!";
2338   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2339   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2340   EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
2341   EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
2342   EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once.";
2343
2344   // A failure case.
2345   n1 = n2 = n3 = 0;
2346   EXPECT_NONFATAL_FAILURE({  // NOLINT
2347     EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
2348         << "This failure is expected.";
2349   }, "This failure is expected.");
2350   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2351   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2352   EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
2353
2354   // Another failure case.
2355   n1 = n2 = n3 = n4 = 0;
2356   EXPECT_NONFATAL_FAILURE({  // NOLINT
2357     EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
2358   }, "evaluates to 1, which is not even.");
2359   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2360   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2361   EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
2362   EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
2363 }
2364
2365
2366 // Some helper functions for testing using overloaded/template
2367 // functions with ASSERT_PREDn and EXPECT_PREDn.
2368
2369 bool IsPositive(double x) {
2370   return x > 0;
2371 }
2372
2373 template <typename T>
2374 bool IsNegative(T x) {
2375   return x < 0;
2376 }
2377
2378 template <typename T1, typename T2>
2379 bool GreaterThan(T1 x1, T2 x2) {
2380   return x1 > x2;
2381 }
2382
2383 // Tests that overloaded functions can be used in *_PRED* as long as
2384 // their types are explicitly specified.
2385 TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
2386   // C++Builder requires C-style casts rather than static_cast.
2387   EXPECT_PRED1((bool (*)(int))(IsPositive), 5);  // NOLINT
2388   ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0);  // NOLINT
2389 }
2390
2391 // Tests that template functions can be used in *_PRED* as long as
2392 // their types are explicitly specified.
2393 TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
2394   EXPECT_PRED1(IsNegative<int>, -5);
2395   // Makes sure that we can handle templates with more than one
2396   // parameter.
2397   ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
2398 }
2399
2400
2401 // Some helper functions for testing using overloaded/template
2402 // functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
2403
2404 AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
2405   return n > 0 ? AssertionSuccess() :
2406       AssertionFailure(Message() << "Failure");
2407 }
2408
2409 AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
2410   return x > 0 ? AssertionSuccess() :
2411       AssertionFailure(Message() << "Failure");
2412 }
2413
2414 template <typename T>
2415 AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
2416   return x < 0 ? AssertionSuccess() :
2417       AssertionFailure(Message() << "Failure");
2418 }
2419
2420 template <typename T1, typename T2>
2421 AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
2422                              const T1& x1, const T2& x2) {
2423   return x1 == x2 ? AssertionSuccess() :
2424       AssertionFailure(Message() << "Failure");
2425 }
2426
2427 // Tests that overloaded functions can be used in *_PRED_FORMAT*
2428 // without explicitly specifying their types.
2429 TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {
2430   EXPECT_PRED_FORMAT1(IsPositiveFormat, 5);
2431   ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0);
2432 }
2433
2434 // Tests that template functions can be used in *_PRED_FORMAT* without
2435 // explicitly specifying their types.
2436 TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
2437   EXPECT_PRED_FORMAT1(IsNegativeFormat, -5);
2438   ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
2439 }
2440
2441
2442 // Tests string assertions.
2443
2444 // Tests ASSERT_STREQ with non-NULL arguments.
2445 TEST(StringAssertionTest, ASSERT_STREQ) {
2446   const char * const p1 = "good";
2447   ASSERT_STREQ(p1, p1);
2448
2449   // Let p2 have the same content as p1, but be at a different address.
2450   const char p2[] = "good";
2451   ASSERT_STREQ(p1, p2);
2452
2453   EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
2454                        "  \"bad\"\n  \"good\"");
2455 }
2456
2457 // Tests ASSERT_STREQ with NULL arguments.
2458 TEST(StringAssertionTest, ASSERT_STREQ_Null) {
2459   ASSERT_STREQ(static_cast<const char *>(NULL), NULL);
2460   EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"),
2461                        "non-null");
2462 }
2463
2464 // Tests ASSERT_STREQ with NULL arguments.
2465 TEST(StringAssertionTest, ASSERT_STREQ_Null2) {
2466   EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL),
2467                        "non-null");
2468 }
2469
2470 // Tests ASSERT_STRNE.
2471 TEST(StringAssertionTest, ASSERT_STRNE) {
2472   ASSERT_STRNE("hi", "Hi");
2473   ASSERT_STRNE("Hi", NULL);
2474   ASSERT_STRNE(NULL, "Hi");
2475   ASSERT_STRNE("", NULL);
2476   ASSERT_STRNE(NULL, "");
2477   ASSERT_STRNE("", "Hi");
2478   ASSERT_STRNE("Hi", "");
2479   EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
2480                        "\"Hi\" vs \"Hi\"");
2481 }
2482
2483 // Tests ASSERT_STRCASEEQ.
2484 TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
2485   ASSERT_STRCASEEQ("hi", "Hi");
2486   ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL);
2487
2488   ASSERT_STRCASEEQ("", "");
2489   EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
2490                        "Ignoring case");
2491 }
2492
2493 // Tests ASSERT_STRCASENE.
2494 TEST(StringAssertionTest, ASSERT_STRCASENE) {
2495   ASSERT_STRCASENE("hi1", "Hi2");
2496   ASSERT_STRCASENE("Hi", NULL);
2497   ASSERT_STRCASENE(NULL, "Hi");
2498   ASSERT_STRCASENE("", NULL);
2499   ASSERT_STRCASENE(NULL, "");
2500   ASSERT_STRCASENE("", "Hi");
2501   ASSERT_STRCASENE("Hi", "");
2502   EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
2503                        "(ignoring case)");
2504 }
2505
2506 // Tests *_STREQ on wide strings.
2507 TEST(StringAssertionTest, STREQ_Wide) {
2508   // NULL strings.
2509   ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL);
2510
2511   // Empty strings.
2512   ASSERT_STREQ(L"", L"");
2513
2514   // Non-null vs NULL.
2515   EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL),
2516                           "non-null");
2517
2518   // Equal strings.
2519   EXPECT_STREQ(L"Hi", L"Hi");
2520
2521   // Unequal strings.
2522   EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
2523                           "Abc");
2524
2525   // Strings containing wide characters.
2526   EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
2527                           "abc");
2528
2529   // The streaming variation.
2530   EXPECT_NONFATAL_FAILURE({  // NOLINT
2531     EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
2532   }, "Expected failure");
2533 }
2534
2535 // Tests *_STRNE on wide strings.
2536 TEST(StringAssertionTest, STRNE_Wide) {
2537   // NULL strings.
2538   EXPECT_NONFATAL_FAILURE({  // NOLINT
2539     EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL);
2540   }, "");
2541
2542   // Empty strings.
2543   EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
2544                           "L\"\"");
2545
2546   // Non-null vs NULL.
2547   ASSERT_STRNE(L"non-null", NULL);
2548
2549   // Equal strings.
2550   EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
2551                           "L\"Hi\"");
2552
2553   // Unequal strings.
2554   EXPECT_STRNE(L"abc", L"Abc");
2555
2556   // Strings containing wide characters.
2557   EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
2558                           "abc");
2559
2560   // The streaming variation.
2561   ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen";
2562 }
2563
2564 // Tests for ::testing::IsSubstring().
2565
2566 // Tests that IsSubstring() returns the correct result when the input
2567 // argument type is const char*.
2568 TEST(IsSubstringTest, ReturnsCorrectResultForCString) {
2569   EXPECT_FALSE(IsSubstring("", "", NULL, "a"));
2570   EXPECT_FALSE(IsSubstring("", "", "b", NULL));
2571   EXPECT_FALSE(IsSubstring("", "", "needle", "haystack"));
2572
2573   EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL));
2574   EXPECT_TRUE(IsSubstring("", "", "needle", "two needles"));
2575 }
2576
2577 // Tests that IsSubstring() returns the correct result when the input
2578 // argument type is const wchar_t*.
2579 TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
2580   EXPECT_FALSE(IsSubstring("", "", kNull, L"a"));
2581   EXPECT_FALSE(IsSubstring("", "", L"b", kNull));
2582   EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack"));
2583
2584   EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL));
2585   EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles"));
2586 }
2587
2588 // Tests that IsSubstring() generates the correct message when the input
2589 // argument type is const char*.
2590 TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
2591   EXPECT_STREQ("Value of: needle_expr\n"
2592                "  Actual: \"needle\"\n"
2593                "Expected: a substring of haystack_expr\n"
2594                "Which is: \"haystack\"",
2595                IsSubstring("needle_expr", "haystack_expr",
2596                            "needle", "haystack").failure_message());
2597 }
2598
2599 // Tests that IsSubstring returns the correct result when the input
2600 // argument type is ::std::string.
2601 TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {
2602   EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob"));
2603   EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world")));
2604 }
2605
2606 #if GTEST_HAS_STD_WSTRING
2607 // Tests that IsSubstring returns the correct result when the input
2608 // argument type is ::std::wstring.
2609 TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
2610   EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
2611   EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack")));
2612 }
2613
2614 // Tests that IsSubstring() generates the correct message when the input
2615 // argument type is ::std::wstring.
2616 TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
2617   EXPECT_STREQ("Value of: needle_expr\n"
2618                "  Actual: L\"needle\"\n"
2619                "Expected: a substring of haystack_expr\n"
2620                "Which is: L\"haystack\"",
2621                IsSubstring(
2622                    "needle_expr", "haystack_expr",
2623                    ::std::wstring(L"needle"), L"haystack").failure_message());
2624 }
2625
2626 #endif  // GTEST_HAS_STD_WSTRING
2627
2628 // Tests for ::testing::IsNotSubstring().
2629
2630 // Tests that IsNotSubstring() returns the correct result when the input
2631 // argument type is const char*.
2632 TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {
2633   EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack"));
2634   EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles"));
2635 }
2636
2637 // Tests that IsNotSubstring() returns the correct result when the input
2638 // argument type is const wchar_t*.
2639 TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
2640   EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack"));
2641   EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles"));
2642 }
2643
2644 // Tests that IsNotSubstring() generates the correct message when the input
2645 // argument type is const wchar_t*.
2646 TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
2647   EXPECT_STREQ("Value of: needle_expr\n"
2648                "  Actual: L\"needle\"\n"
2649                "Expected: not a substring of haystack_expr\n"
2650                "Which is: L\"two needles\"",
2651                IsNotSubstring(
2652                    "needle_expr", "haystack_expr",
2653                    L"needle", L"two needles").failure_message());
2654 }
2655
2656 // Tests that IsNotSubstring returns the correct result when the input
2657 // argument type is ::std::string.
2658 TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
2659   EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob"));
2660   EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world")));
2661 }
2662
2663 // Tests that IsNotSubstring() generates the correct message when the input
2664 // argument type is ::std::string.
2665 TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
2666   EXPECT_STREQ("Value of: needle_expr\n"
2667                "  Actual: \"needle\"\n"
2668                "Expected: not a substring of haystack_expr\n"
2669                "Which is: \"two needles\"",
2670                IsNotSubstring(
2671                    "needle_expr", "haystack_expr",
2672                    ::std::string("needle"), "two needles").failure_message());
2673 }
2674
2675 #if GTEST_HAS_STD_WSTRING
2676
2677 // Tests that IsNotSubstring returns the correct result when the input
2678 // argument type is ::std::wstring.
2679 TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {
2680   EXPECT_FALSE(
2681       IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
2682   EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack")));
2683 }
2684
2685 #endif  // GTEST_HAS_STD_WSTRING
2686
2687 // Tests floating-point assertions.
2688
2689 template <typename RawType>
2690 class FloatingPointTest : public Test {
2691  protected:
2692   // Pre-calculated numbers to be used by the tests.
2693   struct TestValues {
2694     RawType close_to_positive_zero;
2695     RawType close_to_negative_zero;
2696     RawType further_from_negative_zero;
2697
2698     RawType close_to_one;
2699     RawType further_from_one;
2700
2701     RawType infinity;
2702     RawType close_to_infinity;
2703     RawType further_from_infinity;
2704
2705     RawType nan1;
2706     RawType nan2;
2707   };
2708
2709   typedef typename testing::internal::FloatingPoint<RawType> Floating;
2710   typedef typename Floating::Bits Bits;
2711
2712   virtual void SetUp() {
2713     const size_t max_ulps = Floating::kMaxUlps;
2714
2715     // The bits that represent 0.0.
2716     const Bits zero_bits = Floating(0).bits();
2717
2718     // Makes some numbers close to 0.0.
2719     values_.close_to_positive_zero = Floating::ReinterpretBits(
2720         zero_bits + max_ulps/2);
2721     values_.close_to_negative_zero = -Floating::ReinterpretBits(
2722         zero_bits + max_ulps - max_ulps/2);
2723     values_.further_from_negative_zero = -Floating::ReinterpretBits(
2724         zero_bits + max_ulps + 1 - max_ulps/2);
2725
2726     // The bits that represent 1.0.
2727     const Bits one_bits = Floating(1).bits();
2728
2729     // Makes some numbers close to 1.0.
2730     values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
2731     values_.further_from_one = Floating::ReinterpretBits(
2732         one_bits + max_ulps + 1);
2733
2734     // +infinity.
2735     values_.infinity = Floating::Infinity();
2736
2737     // The bits that represent +infinity.
2738     const Bits infinity_bits = Floating(values_.infinity).bits();
2739
2740     // Makes some numbers close to infinity.
2741     values_.close_to_infinity = Floating::ReinterpretBits(
2742         infinity_bits - max_ulps);
2743     values_.further_from_infinity = Floating::ReinterpretBits(
2744         infinity_bits - max_ulps - 1);
2745
2746     // Makes some NAN's.  Sets the most significant bit of the fraction so that
2747     // our NaN's are quiet; trying to process a signaling NaN would raise an
2748     // exception if our environment enables floating point exceptions.
2749     values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
2750         | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
2751     values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
2752         | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
2753   }
2754
2755   void TestSize() {
2756     EXPECT_EQ(sizeof(RawType), sizeof(Bits));
2757   }
2758
2759   static TestValues values_;
2760 };
2761
2762 template <typename RawType>
2763 typename FloatingPointTest<RawType>::TestValues
2764     FloatingPointTest<RawType>::values_;
2765
2766 // Instantiates FloatingPointTest for testing *_FLOAT_EQ.
2767 typedef FloatingPointTest<float> FloatTest;
2768
2769 // Tests that the size of Float::Bits matches the size of float.
2770 TEST_F(FloatTest, Size) {
2771   TestSize();
2772 }
2773
2774 // Tests comparing with +0 and -0.
2775 TEST_F(FloatTest, Zeros) {
2776   EXPECT_FLOAT_EQ(0.0, -0.0);
2777   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
2778                           "1.0");
2779   EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
2780                        "1.5");
2781 }
2782
2783 // Tests comparing numbers close to 0.
2784 //
2785 // This ensures that *_FLOAT_EQ handles the sign correctly and no
2786 // overflow occurs when comparing numbers whose absolute value is very
2787 // small.
2788 TEST_F(FloatTest, AlmostZeros) {
2789   // In C++Builder, names within local classes (such as used by
2790   // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2791   // scoping class.  Use a static local alias as a workaround.
2792   // We use the assignment syntax since some compilers, like Sun Studio,
2793   // don't allow initializing references using construction syntax
2794   // (parentheses).
2795   static const FloatTest::TestValues& v = this->values_;
2796
2797   EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero);
2798   EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
2799   EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
2800
2801   EXPECT_FATAL_FAILURE({  // NOLINT
2802     ASSERT_FLOAT_EQ(v.close_to_positive_zero,
2803                     v.further_from_negative_zero);
2804   }, "v.further_from_negative_zero");
2805 }
2806
2807 // Tests comparing numbers close to each other.
2808 TEST_F(FloatTest, SmallDiff) {
2809   EXPECT_FLOAT_EQ(1.0, values_.close_to_one);
2810   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one),
2811                           "values_.further_from_one");
2812 }
2813
2814 // Tests comparing numbers far apart.
2815 TEST_F(FloatTest, LargeDiff) {
2816   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
2817                           "3.0");
2818 }
2819
2820 // Tests comparing with infinity.
2821 //
2822 // This ensures that no overflow occurs when comparing numbers whose
2823 // absolute value is very large.
2824 TEST_F(FloatTest, Infinity) {
2825   EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);
2826   EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);
2827 #if !GTEST_OS_SYMBIAN
2828   // Nokia's STLport crashes if we try to output infinity or NaN.
2829   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),
2830                           "-values_.infinity");
2831
2832   // This is interesting as the representations of infinity and nan1
2833   // are only 1 DLP apart.
2834   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1),
2835                           "values_.nan1");
2836 #endif  // !GTEST_OS_SYMBIAN
2837 }
2838
2839 // Tests that comparing with NAN always returns false.
2840 TEST_F(FloatTest, NaN) {
2841 #if !GTEST_OS_SYMBIAN
2842 // Nokia's STLport crashes if we try to output infinity or NaN.
2843
2844   // In C++Builder, names within local classes (such as used by
2845   // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2846   // scoping class.  Use a static local alias as a workaround.
2847   // We use the assignment syntax since some compilers, like Sun Studio,
2848   // don't allow initializing references using construction syntax
2849   // (parentheses).
2850   static const FloatTest::TestValues& v = this->values_;
2851
2852   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
2853                           "v.nan1");
2854   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
2855                           "v.nan2");
2856   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
2857                           "v.nan1");
2858
2859   EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
2860                        "v.infinity");
2861 #endif  // !GTEST_OS_SYMBIAN
2862 }
2863
2864 // Tests that *_FLOAT_EQ are reflexive.
2865 TEST_F(FloatTest, Reflexive) {
2866   EXPECT_FLOAT_EQ(0.0, 0.0);
2867   EXPECT_FLOAT_EQ(1.0, 1.0);
2868   ASSERT_FLOAT_EQ(values_.infinity, values_.infinity);
2869 }
2870
2871 // Tests that *_FLOAT_EQ are commutative.
2872 TEST_F(FloatTest, Commutative) {
2873   // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one).
2874   EXPECT_FLOAT_EQ(values_.close_to_one, 1.0);
2875
2876   // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one).
2877   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0),
2878                           "1.0");
2879 }
2880
2881 // Tests EXPECT_NEAR.
2882 TEST_F(FloatTest, EXPECT_NEAR) {
2883   EXPECT_NEAR(-1.0f, -1.1f, 0.2f);
2884   EXPECT_NEAR(2.0f, 3.0f, 1.0f);
2885   EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f),  // NOLINT
2886                           "The difference between 1.0f and 1.5f is 0.5, "
2887                           "which exceeds 0.25f");
2888   // To work around a bug in gcc 2.95.0, there is intentionally no
2889   // space after the first comma in the previous line.
2890 }
2891
2892 // Tests ASSERT_NEAR.
2893 TEST_F(FloatTest, ASSERT_NEAR) {
2894   ASSERT_NEAR(-1.0f, -1.1f, 0.2f);
2895   ASSERT_NEAR(2.0f, 3.0f, 1.0f);
2896   EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f),  // NOLINT
2897                        "The difference between 1.0f and 1.5f is 0.5, "
2898                        "which exceeds 0.25f");
2899   // To work around a bug in gcc 2.95.0, there is intentionally no
2900   // space after the first comma in the previous line.
2901 }
2902
2903 // Tests the cases where FloatLE() should succeed.
2904 TEST_F(FloatTest, FloatLESucceeds) {
2905   EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f);  // When val1 < val2,
2906   ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f);  // val1 == val2,
2907
2908   // or when val1 is greater than, but almost equals to, val2.
2909   EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f);
2910 }
2911
2912 // Tests the cases where FloatLE() should fail.
2913 TEST_F(FloatTest, FloatLEFails) {
2914   // When val1 is greater than val2 by a large margin,
2915   EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f),
2916                           "(2.0f) <= (1.0f)");
2917
2918   // or by a small yet non-negligible margin,
2919   EXPECT_NONFATAL_FAILURE({  // NOLINT
2920     EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
2921   }, "(values_.further_from_one) <= (1.0f)");
2922
2923 #if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
2924   // Nokia's STLport crashes if we try to output infinity or NaN.
2925   // C++Builder gives bad results for ordered comparisons involving NaNs
2926   // due to compiler bugs.
2927   EXPECT_NONFATAL_FAILURE({  // NOLINT
2928     EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
2929   }, "(values_.nan1) <= (values_.infinity)");
2930   EXPECT_NONFATAL_FAILURE({  // NOLINT
2931     EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
2932   }, "(-values_.infinity) <= (values_.nan1)");
2933   EXPECT_FATAL_FAILURE({  // NOLINT
2934     ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
2935   }, "(values_.nan1) <= (values_.nan1)");
2936 #endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
2937 }
2938
2939 // Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
2940 typedef FloatingPointTest<double> DoubleTest;
2941
2942 // Tests that the size of Double::Bits matches the size of double.
2943 TEST_F(DoubleTest, Size) {
2944   TestSize();
2945 }
2946
2947 // Tests comparing with +0 and -0.
2948 TEST_F(DoubleTest, Zeros) {
2949   EXPECT_DOUBLE_EQ(0.0, -0.0);
2950   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
2951                           "1.0");
2952   EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
2953                        "1.0");
2954 }
2955
2956 // Tests comparing numbers close to 0.
2957 //
2958 // This ensures that *_DOUBLE_EQ handles the sign correctly and no
2959 // overflow occurs when comparing numbers whose absolute value is very
2960 // small.
2961 TEST_F(DoubleTest, AlmostZeros) {
2962   // In C++Builder, names within local classes (such as used by
2963   // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2964   // scoping class.  Use a static local alias as a workaround.
2965   // We use the assignment syntax since some compilers, like Sun Studio,
2966   // don't allow initializing references using construction syntax
2967   // (parentheses).
2968   static const DoubleTest::TestValues& v = this->values_;
2969
2970   EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero);
2971   EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
2972   EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
2973
2974   EXPECT_FATAL_FAILURE({  // NOLINT
2975     ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
2976                      v.further_from_negative_zero);
2977   }, "v.further_from_negative_zero");
2978 }
2979
2980 // Tests comparing numbers close to each other.
2981 TEST_F(DoubleTest, SmallDiff) {
2982   EXPECT_DOUBLE_EQ(1.0, values_.close_to_one);
2983   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one),
2984                           "values_.further_from_one");
2985 }
2986
2987 // Tests comparing numbers far apart.
2988 TEST_F(DoubleTest, LargeDiff) {
2989   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
2990                           "3.0");
2991 }
2992
2993 // Tests comparing with infinity.
2994 //
2995 // This ensures that no overflow occurs when comparing numbers whose
2996 // absolute value is very large.
2997 TEST_F(DoubleTest, Infinity) {
2998   EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);
2999   EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);
3000 #if !GTEST_OS_SYMBIAN
3001   // Nokia's STLport crashes if we try to output infinity or NaN.
3002   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),
3003                           "-values_.infinity");
3004
3005   // This is interesting as the representations of infinity_ and nan1_
3006   // are only 1 DLP apart.
3007   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1),
3008                           "values_.nan1");
3009 #endif  // !GTEST_OS_SYMBIAN
3010 }
3011
3012 // Tests that comparing with NAN always returns false.
3013 TEST_F(DoubleTest, NaN) {
3014 #if !GTEST_OS_SYMBIAN
3015   // In C++Builder, names within local classes (such as used by
3016   // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
3017   // scoping class.  Use a static local alias as a workaround.
3018   // We use the assignment syntax since some compilers, like Sun Studio,
3019   // don't allow initializing references using construction syntax
3020   // (parentheses).
3021   static const DoubleTest::TestValues& v = this->values_;
3022
3023   // Nokia's STLport crashes if we try to output infinity or NaN.
3024   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
3025                           "v.nan1");
3026   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
3027   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
3028   EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
3029                        "v.infinity");
3030 #endif  // !GTEST_OS_SYMBIAN
3031 }
3032
3033 // Tests that *_DOUBLE_EQ are reflexive.
3034 TEST_F(DoubleTest, Reflexive) {
3035   EXPECT_DOUBLE_EQ(0.0, 0.0);
3036   EXPECT_DOUBLE_EQ(1.0, 1.0);
3037 #if !GTEST_OS_SYMBIAN
3038   // Nokia's STLport crashes if we try to output infinity or NaN.
3039   ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity);
3040 #endif  // !GTEST_OS_SYMBIAN
3041 }
3042
3043 // Tests that *_DOUBLE_EQ are commutative.
3044 TEST_F(DoubleTest, Commutative) {
3045   // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one).
3046   EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0);
3047
3048   // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one).
3049   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0),
3050                           "1.0");
3051 }
3052
3053 // Tests EXPECT_NEAR.
3054 TEST_F(DoubleTest, EXPECT_NEAR) {
3055   EXPECT_NEAR(-1.0, -1.1, 0.2);
3056   EXPECT_NEAR(2.0, 3.0, 1.0);
3057   EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25),  // NOLINT
3058                           "The difference between 1.0 and 1.5 is 0.5, "
3059                           "which exceeds 0.25");
3060   // To work around a bug in gcc 2.95.0, there is intentionally no
3061   // space after the first comma in the previous statement.
3062 }
3063
3064 // Tests ASSERT_NEAR.
3065 TEST_F(DoubleTest, ASSERT_NEAR) {
3066   ASSERT_NEAR(-1.0, -1.1, 0.2);
3067   ASSERT_NEAR(2.0, 3.0, 1.0);
3068   EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25),  // NOLINT
3069                        "The difference between 1.0 and 1.5 is 0.5, "
3070                        "which exceeds 0.25");
3071   // To work around a bug in gcc 2.95.0, there is intentionally no
3072   // space after the first comma in the previous statement.
3073 }
3074
3075 // Tests the cases where DoubleLE() should succeed.
3076 TEST_F(DoubleTest, DoubleLESucceeds) {
3077   EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0);  // When val1 < val2,
3078   ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0);  // val1 == val2,
3079
3080   // or when val1 is greater than, but almost equals to, val2.
3081   EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0);
3082 }
3083
3084 // Tests the cases where DoubleLE() should fail.
3085 TEST_F(DoubleTest, DoubleLEFails) {
3086   // When val1 is greater than val2 by a large margin,
3087   EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0),
3088                           "(2.0) <= (1.0)");
3089
3090   // or by a small yet non-negligible margin,
3091   EXPECT_NONFATAL_FAILURE({  // NOLINT
3092     EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
3093   }, "(values_.further_from_one) <= (1.0)");
3094
3095 #if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
3096   // Nokia's STLport crashes if we try to output infinity or NaN.
3097   // C++Builder gives bad results for ordered comparisons involving NaNs
3098   // due to compiler bugs.
3099   EXPECT_NONFATAL_FAILURE({  // NOLINT
3100     EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
3101   }, "(values_.nan1) <= (values_.infinity)");
3102   EXPECT_NONFATAL_FAILURE({  // NOLINT
3103     EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
3104   }, " (-values_.infinity) <= (values_.nan1)");
3105   EXPECT_FATAL_FAILURE({  // NOLINT
3106     ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
3107   }, "(values_.nan1) <= (values_.nan1)");
3108 #endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
3109 }
3110
3111
3112 // Verifies that a test or test case whose name starts with DISABLED_ is
3113 // not run.
3114
3115 // A test whose name starts with DISABLED_.
3116 // Should not run.
3117 TEST(DisabledTest, DISABLED_TestShouldNotRun) {
3118   FAIL() << "Unexpected failure: Disabled test should not be run.";
3119 }
3120
3121 // A test whose name does not start with DISABLED_.
3122 // Should run.
3123 TEST(DisabledTest, NotDISABLED_TestShouldRun) {
3124   EXPECT_EQ(1, 1);
3125 }
3126
3127 // A test case whose name starts with DISABLED_.
3128 // Should not run.
3129 TEST(DISABLED_TestCase, TestShouldNotRun) {
3130   FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
3131 }
3132
3133 // A test case and test whose names start with DISABLED_.
3134 // Should not run.
3135 TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {
3136   FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
3137 }
3138
3139 // Check that when all tests in a test case are disabled, SetUpTestCase() and
3140 // TearDownTestCase() are not called.
3141 class DisabledTestsTest : public Test {
3142  protected:
3143   static void SetUpTestCase() {
3144     FAIL() << "Unexpected failure: All tests disabled in test case. "
3145               "SetUpTestCase() should not be called.";
3146   }
3147
3148   static void TearDownTestCase() {
3149     FAIL() << "Unexpected failure: All tests disabled in test case. "
3150               "TearDownTestCase() should not be called.";
3151   }
3152 };
3153
3154 TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {
3155   FAIL() << "Unexpected failure: Disabled test should not be run.";
3156 }
3157
3158 TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
3159   FAIL() << "Unexpected failure: Disabled test should not be run.";
3160 }
3161
3162 // Tests that disabled typed tests aren't run.
3163
3164 #if GTEST_HAS_TYPED_TEST
3165
3166 template <typename T>
3167 class TypedTest : public Test {
3168 };
3169
3170 typedef testing::Types<int, double> NumericTypes;
3171 TYPED_TEST_CASE(TypedTest, NumericTypes);
3172
3173 TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
3174   FAIL() << "Unexpected failure: Disabled typed test should not run.";
3175 }
3176
3177 template <typename T>
3178 class DISABLED_TypedTest : public Test {
3179 };
3180
3181 TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes);
3182
3183 TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
3184   FAIL() << "Unexpected failure: Disabled typed test should not run.";
3185 }
3186
3187 #endif  // GTEST_HAS_TYPED_TEST
3188
3189 // Tests that disabled type-parameterized tests aren't run.
3190
3191 #if GTEST_HAS_TYPED_TEST_P
3192
3193 template <typename T>
3194 class TypedTestP : public Test {
3195 };
3196
3197 TYPED_TEST_CASE_P(TypedTestP);
3198
3199 TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {
3200   FAIL() << "Unexpected failure: "
3201          << "Disabled type-parameterized test should not run.";
3202 }
3203
3204 REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun);
3205
3206 INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes);
3207
3208 template <typename T>
3209 class DISABLED_TypedTestP : public Test {
3210 };
3211
3212 TYPED_TEST_CASE_P(DISABLED_TypedTestP);
3213
3214 TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {
3215   FAIL() << "Unexpected failure: "
3216          << "Disabled type-parameterized test should not run.";
3217 }
3218
3219 REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun);
3220
3221 INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes);
3222
3223 #endif  // GTEST_HAS_TYPED_TEST_P
3224
3225 // Tests that assertion macros evaluate their arguments exactly once.
3226
3227 class SingleEvaluationTest : public Test {
3228  public:  // Must be public and not protected due to a bug in g++ 3.4.2.
3229   // This helper function is needed by the FailedASSERT_STREQ test
3230   // below.  It's public to work around C++Builder's bug with scoping local
3231   // classes.
3232   static void CompareAndIncrementCharPtrs() {
3233     ASSERT_STREQ(p1_++, p2_++);
3234   }
3235
3236   // This helper function is needed by the FailedASSERT_NE test below.  It's
3237   // public to work around C++Builder's bug with scoping local classes.
3238   static void CompareAndIncrementInts() {
3239     ASSERT_NE(a_++, b_++);
3240   }
3241
3242  protected:
3243   SingleEvaluationTest() {
3244     p1_ = s1_;
3245     p2_ = s2_;
3246     a_ = 0;
3247     b_ = 0;
3248   }
3249
3250   static const char* const s1_;
3251   static const char* const s2_;
3252   static const char* p1_;
3253   static const char* p2_;
3254
3255   static int a_;
3256   static int b_;
3257 };
3258
3259 const char* const SingleEvaluationTest::s1_ = "01234";
3260 const char* const SingleEvaluationTest::s2_ = "abcde";
3261 const char* SingleEvaluationTest::p1_;
3262 const char* SingleEvaluationTest::p2_;
3263 int SingleEvaluationTest::a_;
3264 int SingleEvaluationTest::b_;
3265
3266 // Tests that when ASSERT_STREQ fails, it evaluates its arguments
3267 // exactly once.
3268 TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {
3269   EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(),
3270                        "p2_++");
3271   EXPECT_EQ(s1_ + 1, p1_);
3272   EXPECT_EQ(s2_ + 1, p2_);
3273 }
3274
3275 // Tests that string assertion arguments are evaluated exactly once.
3276 TEST_F(SingleEvaluationTest, ASSERT_STR) {
3277   // successful EXPECT_STRNE
3278   EXPECT_STRNE(p1_++, p2_++);
3279   EXPECT_EQ(s1_ + 1, p1_);
3280   EXPECT_EQ(s2_ + 1, p2_);
3281
3282   // failed EXPECT_STRCASEEQ
3283   EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
3284                           "Ignoring case");
3285   EXPECT_EQ(s1_ + 2, p1_);
3286   EXPECT_EQ(s2_ + 2, p2_);
3287 }
3288
3289 // Tests that when ASSERT_NE fails, it evaluates its arguments exactly
3290 // once.
3291 TEST_F(SingleEvaluationTest, FailedASSERT_NE) {
3292   EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(),
3293                        "(a_++) != (b_++)");
3294   EXPECT_EQ(1, a_);
3295   EXPECT_EQ(1, b_);
3296 }
3297
3298 // Tests that assertion arguments are evaluated exactly once.
3299 TEST_F(SingleEvaluationTest, OtherCases) {
3300   // successful EXPECT_TRUE
3301   EXPECT_TRUE(0 == a_++);  // NOLINT
3302   EXPECT_EQ(1, a_);
3303
3304   // failed EXPECT_TRUE
3305   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++");
3306   EXPECT_EQ(2, a_);
3307
3308   // successful EXPECT_GT
3309   EXPECT_GT(a_++, b_++);
3310   EXPECT_EQ(3, a_);
3311   EXPECT_EQ(1, b_);
3312
3313   // failed EXPECT_LT
3314   EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)");
3315   EXPECT_EQ(4, a_);
3316   EXPECT_EQ(2, b_);
3317
3318   // successful ASSERT_TRUE
3319   ASSERT_TRUE(0 < a_++);  // NOLINT
3320   EXPECT_EQ(5, a_);
3321
3322   // successful ASSERT_GT
3323   ASSERT_GT(a_++, b_++);
3324   EXPECT_EQ(6, a_);
3325   EXPECT_EQ(3, b_);
3326 }
3327
3328 #if GTEST_HAS_EXCEPTIONS
3329
3330 void ThrowAnInteger() {
3331   throw 1;
3332 }
3333
3334 // Tests that assertion arguments are evaluated exactly once.
3335 TEST_F(SingleEvaluationTest, ExceptionTests) {
3336   // successful EXPECT_THROW
3337   EXPECT_THROW({  // NOLINT
3338     a_++;
3339     ThrowAnInteger();
3340   }, int);
3341   EXPECT_EQ(1, a_);
3342
3343   // failed EXPECT_THROW, throws different
3344   EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
3345     a_++;
3346     ThrowAnInteger();
3347   }, bool), "throws a different type");
3348   EXPECT_EQ(2, a_);
3349
3350   // failed EXPECT_THROW, throws nothing
3351   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");
3352   EXPECT_EQ(3, a_);
3353
3354   // successful EXPECT_NO_THROW
3355   EXPECT_NO_THROW(a_++);
3356   EXPECT_EQ(4, a_);
3357
3358   // failed EXPECT_NO_THROW
3359   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({  // NOLINT
3360     a_++;
3361     ThrowAnInteger();
3362   }), "it throws");
3363   EXPECT_EQ(5, a_);
3364
3365   // successful EXPECT_ANY_THROW
3366   EXPECT_ANY_THROW({  // NOLINT
3367     a_++;
3368     ThrowAnInteger();
3369   });
3370   EXPECT_EQ(6, a_);
3371
3372   // failed EXPECT_ANY_THROW
3373   EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
3374   EXPECT_EQ(7, a_);
3375 }
3376
3377 #endif  // GTEST_HAS_EXCEPTIONS
3378
3379 // Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.
3380 class NoFatalFailureTest : public Test {
3381  protected:
3382   void Succeeds() {}
3383   void FailsNonFatal() {
3384     ADD_FAILURE() << "some non-fatal failure";
3385   }
3386   void Fails() {
3387     FAIL() << "some fatal failure";
3388   }
3389
3390   void DoAssertNoFatalFailureOnFails() {
3391     ASSERT_NO_FATAL_FAILURE(Fails());
3392     ADD_FAILURE() << "should not reach here.";
3393   }
3394
3395   void DoExpectNoFatalFailureOnFails() {
3396     EXPECT_NO_FATAL_FAILURE(Fails());
3397     ADD_FAILURE() << "other failure";
3398   }
3399 };
3400
3401 TEST_F(NoFatalFailureTest, NoFailure) {
3402   EXPECT_NO_FATAL_FAILURE(Succeeds());
3403   ASSERT_NO_FATAL_FAILURE(Succeeds());
3404 }
3405
3406 TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
3407   EXPECT_NONFATAL_FAILURE(
3408       EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
3409       "some non-fatal failure");
3410   EXPECT_NONFATAL_FAILURE(
3411       ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
3412       "some non-fatal failure");
3413 }
3414
3415 TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
3416   TestPartResultArray gtest_failures;
3417   {
3418     ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
3419     DoAssertNoFatalFailureOnFails();
3420   }
3421   ASSERT_EQ(2, gtest_failures.size());
3422   EXPECT_EQ(TestPartResult::kFatalFailure,
3423             gtest_failures.GetTestPartResult(0).type());
3424   EXPECT_EQ(TestPartResult::kFatalFailure,
3425             gtest_failures.GetTestPartResult(1).type());
3426   EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
3427                       gtest_failures.GetTestPartResult(0).message());
3428   EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
3429                       gtest_failures.GetTestPartResult(1).message());
3430 }
3431
3432 TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {
3433   TestPartResultArray gtest_failures;
3434   {
3435     ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
3436     DoExpectNoFatalFailureOnFails();
3437   }
3438   ASSERT_EQ(3, gtest_failures.size());
3439   EXPECT_EQ(TestPartResult::kFatalFailure,
3440             gtest_failures.GetTestPartResult(0).type());
3441   EXPECT_EQ(TestPartResult::kNonFatalFailure,
3442             gtest_failures.GetTestPartResult(1).type());
3443   EXPECT_EQ(TestPartResult::kNonFatalFailure,
3444             gtest_failures.GetTestPartResult(2).type());
3445   EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
3446                       gtest_failures.GetTestPartResult(0).message());
3447   EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
3448                       gtest_failures.GetTestPartResult(1).message());
3449   EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure",
3450                       gtest_failures.GetTestPartResult(2).message());
3451 }
3452
3453 TEST_F(NoFatalFailureTest, MessageIsStreamable) {
3454   TestPartResultArray gtest_failures;
3455   {
3456     ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
3457     EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";
3458   }
3459   ASSERT_EQ(2, gtest_failures.size());
3460   EXPECT_EQ(TestPartResult::kNonFatalFailure,
3461             gtest_failures.GetTestPartResult(0).type());
3462   EXPECT_EQ(TestPartResult::kNonFatalFailure,
3463             gtest_failures.GetTestPartResult(1).type());
3464   EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo",
3465                       gtest_failures.GetTestPartResult(0).message());
3466   EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message",
3467                       gtest_failures.GetTestPartResult(1).message());
3468 }
3469
3470 // Tests non-string assertions.
3471
3472 std::string EditsToString(const std::vector<EditType>& edits) {
3473   std::string out;
3474   for (size_t i = 0; i < edits.size(); ++i) {
3475     static const char kEdits[] = " +-/";
3476     out.append(1, kEdits[edits[i]]);
3477   }
3478   return out;
3479 }
3480
3481 std::vector<size_t> CharsToIndices(const std::string& str) {
3482   std::vector<size_t> out;
3483   for (size_t i = 0; i < str.size(); ++i) {
3484     out.push_back(str[i]);
3485   }
3486   return out;
3487 }
3488
3489 std::vector<std::string> CharsToLines(const std::string& str) {
3490   std::vector<std::string> out;
3491   for (size_t i = 0; i < str.size(); ++i) {
3492     out.push_back(str.substr(i, 1));
3493   }
3494   return out;
3495 }
3496
3497 TEST(EditDistance, TestCases) {
3498   struct Case {
3499     int line;
3500     const char* left;
3501     const char* right;
3502     const char* expected_edits;
3503     const char* expected_diff;
3504   };
3505   static const Case kCases[] = {
3506       // No change.
3507       {__LINE__, "A", "A", " ", ""},
3508       {__LINE__, "ABCDE", "ABCDE", "     ", ""},
3509       // Simple adds.
3510       {__LINE__, "X", "XA", " +", "@@ +1,2 @@\n X\n+A\n"},
3511       {__LINE__, "X", "XABCD", " ++++", "@@ +1,5 @@\n X\n+A\n+B\n+C\n+D\n"},
3512       // Simple removes.
3513       {__LINE__, "XA", "X", " -", "@@ -1,2 @@\n X\n-A\n"},
3514       {__LINE__, "XABCD", "X", " ----", "@@ -1,5 @@\n X\n-A\n-B\n-C\n-D\n"},
3515       // Simple replaces.
3516       {__LINE__, "A", "a", "/", "@@ -1,1 +1,1 @@\n-A\n+a\n"},
3517       {__LINE__, "ABCD", "abcd", "////",
3518        "@@ -1,4 +1,4 @@\n-A\n-B\n-C\n-D\n+a\n+b\n+c\n+d\n"},
3519       // Path finding.
3520       {__LINE__, "ABCDEFGH", "ABXEGH1", "  -/ -  +",
3521        "@@ -1,8 +1,7 @@\n A\n B\n-C\n-D\n+X\n E\n-F\n G\n H\n+1\n"},
3522       {__LINE__, "AAAABCCCC", "ABABCDCDC", "- /   + / ",
3523        "@@ -1,9 +1,9 @@\n-A\n A\n-A\n+B\n A\n B\n C\n+D\n C\n-C\n+D\n C\n"},
3524       {__LINE__, "ABCDE", "BCDCD", "-   +/",
3525        "@@ -1,5 +1,5 @@\n-A\n B\n C\n D\n-E\n+C\n+D\n"},
3526       {__LINE__, "ABCDEFGHIJKL", "BCDCDEFGJKLJK", "- ++     --   ++",
3527        "@@ -1,4 +1,5 @@\n-A\n B\n+C\n+D\n C\n D\n"
3528        "@@ -6,7 +7,7 @@\n F\n G\n-H\n-I\n J\n K\n L\n+J\n+K\n"},
3529       {}};
3530   for (const Case* c = kCases; c->left; ++c) {
3531     EXPECT_TRUE(c->expected_edits ==
3532                 EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
3533                                                     CharsToIndices(c->right))))
3534         << "Left <" << c->left << "> Right <" << c->right << "> Edits <"
3535         << EditsToString(CalculateOptimalEdits(
3536                CharsToIndices(c->left), CharsToIndices(c->right))) << ">";
3537     EXPECT_TRUE(c->expected_diff == CreateUnifiedDiff(CharsToLines(c->left),
3538                                                       CharsToLines(c->right)))
3539         << "Left <" << c->left << "> Right <" << c->right << "> Diff <"
3540         << CreateUnifiedDiff(CharsToLines(c->left), CharsToLines(c->right))
3541         << ">";
3542   }
3543 }
3544
3545 // Tests EqFailure(), used for implementing *EQ* assertions.
3546 TEST(AssertionTest, EqFailure) {
3547   const std::string foo_val("5"), bar_val("6");
3548   const std::string msg1(
3549       EqFailure("foo", "bar", foo_val, bar_val, false)
3550       .failure_message());
3551   EXPECT_STREQ(
3552       "Expected equality of these values:\n"
3553       "  foo\n"
3554       "    Which is: 5\n"
3555       "  bar\n"
3556       "    Which is: 6",
3557       msg1.c_str());
3558
3559   const std::string msg2(
3560       EqFailure("foo", "6", foo_val, bar_val, false)
3561       .failure_message());
3562   EXPECT_STREQ(
3563       "Expected equality of these values:\n"
3564       "  foo\n"
3565       "    Which is: 5\n"
3566       "  6",
3567       msg2.c_str());
3568
3569   const std::string msg3(
3570       EqFailure("5", "bar", foo_val, bar_val, false)
3571       .failure_message());
3572   EXPECT_STREQ(
3573       "Expected equality of these values:\n"
3574       "  5\n"
3575       "  bar\n"
3576       "    Which is: 6",
3577       msg3.c_str());
3578
3579   const std::string msg4(
3580       EqFailure("5", "6", foo_val, bar_val, false).failure_message());
3581   EXPECT_STREQ(
3582       "Expected equality of these values:\n"
3583       "  5\n"
3584       "  6",
3585       msg4.c_str());
3586
3587   const std::string msg5(
3588       EqFailure("foo", "bar",
3589                 std::string("\"x\""), std::string("\"y\""),
3590                 true).failure_message());
3591   EXPECT_STREQ(
3592       "Expected equality of these values:\n"
3593       "  foo\n"
3594       "    Which is: \"x\"\n"
3595       "  bar\n"
3596       "    Which is: \"y\"\n"
3597       "Ignoring case",
3598       msg5.c_str());
3599 }
3600
3601 TEST(AssertionTest, EqFailureWithDiff) {
3602   const std::string left(
3603       "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15");
3604   const std::string right(
3605       "1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14");
3606   const std::string msg1(
3607       EqFailure("left", "right", left, right, false).failure_message());
3608   EXPECT_STREQ(
3609       "Expected equality of these values:\n"
3610       "  left\n"
3611       "    Which is: "
3612       "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n"
3613       "  right\n"
3614       "    Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
3615       "With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n"
3616       "@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n",
3617       msg1.c_str());
3618 }
3619
3620 // Tests AppendUserMessage(), used for implementing the *EQ* macros.
3621 TEST(AssertionTest, AppendUserMessage) {
3622   const std::string foo("foo");
3623
3624   Message msg;
3625   EXPECT_STREQ("foo",
3626                AppendUserMessage(foo, msg).c_str());
3627
3628   msg << "bar";
3629   EXPECT_STREQ("foo\nbar",
3630                AppendUserMessage(foo, msg).c_str());
3631 }
3632
3633 #ifdef __BORLANDC__
3634 // Silences warnings: "Condition is always true", "Unreachable code"
3635 # pragma option push -w-ccc -w-rch
3636 #endif
3637
3638 // Tests ASSERT_TRUE.
3639 TEST(AssertionTest, ASSERT_TRUE) {
3640   ASSERT_TRUE(2 > 1);  // NOLINT
3641   EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
3642                        "2 < 1");
3643 }
3644
3645 // Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult.
3646 TEST(AssertionTest, AssertTrueWithAssertionResult) {
3647   ASSERT_TRUE(ResultIsEven(2));
3648 #ifndef __BORLANDC__
3649   // ICE's in C++Builder.
3650   EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)),
3651                        "Value of: ResultIsEven(3)\n"
3652                        "  Actual: false (3 is odd)\n"
3653                        "Expected: true");
3654 #endif
3655   ASSERT_TRUE(ResultIsEvenNoExplanation(2));
3656   EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)),
3657                        "Value of: ResultIsEvenNoExplanation(3)\n"
3658                        "  Actual: false (3 is odd)\n"
3659                        "Expected: true");
3660 }
3661
3662 // Tests ASSERT_FALSE.
3663 TEST(AssertionTest, ASSERT_FALSE) {
3664   ASSERT_FALSE(2 < 1);  // NOLINT
3665   EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1),
3666                        "Value of: 2 > 1\n"
3667                        "  Actual: true\n"
3668                        "Expected: false");
3669 }
3670
3671 // Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult.
3672 TEST(AssertionTest, AssertFalseWithAssertionResult) {
3673   ASSERT_FALSE(ResultIsEven(3));
3674 #ifndef __BORLANDC__
3675   // ICE's in C++Builder.
3676   EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)),
3677                        "Value of: ResultIsEven(2)\n"
3678                        "  Actual: true (2 is even)\n"
3679                        "Expected: false");
3680 #endif
3681   ASSERT_FALSE(ResultIsEvenNoExplanation(3));
3682   EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)),
3683                        "Value of: ResultIsEvenNoExplanation(2)\n"
3684                        "  Actual: true\n"
3685                        "Expected: false");
3686 }
3687
3688 #ifdef __BORLANDC__
3689 // Restores warnings after previous "#pragma option push" suppressed them
3690 # pragma option pop
3691 #endif
3692
3693 // Tests using ASSERT_EQ on double values.  The purpose is to make
3694 // sure that the specialization we did for integer and anonymous enums
3695 // isn't used for double arguments.
3696 TEST(ExpectTest, ASSERT_EQ_Double) {
3697   // A success.
3698   ASSERT_EQ(5.6, 5.6);
3699
3700   // A failure.
3701   EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
3702                        "5.1");
3703 }
3704
3705 // Tests ASSERT_EQ.
3706 TEST(AssertionTest, ASSERT_EQ) {
3707   ASSERT_EQ(5, 2 + 3);
3708   EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
3709                        "Expected equality of these values:\n"
3710                        "  5\n"
3711                        "  2*3\n"
3712                        "    Which is: 6");
3713 }
3714
3715 // Tests ASSERT_EQ(NULL, pointer).
3716 #if GTEST_CAN_COMPARE_NULL
3717 TEST(AssertionTest, ASSERT_EQ_NULL) {
3718   // A success.
3719   const char* p = NULL;
3720   // Some older GCC versions may issue a spurious warning in this or the next
3721   // assertion statement. This warning should not be suppressed with
3722   // static_cast since the test verifies the ability to use bare NULL as the
3723   // expected parameter to the macro.
3724   ASSERT_EQ(NULL, p);
3725
3726   // A failure.
3727   static int n = 0;
3728   EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
3729                        "  &n\n    Which is:");
3730 }
3731 #endif  // GTEST_CAN_COMPARE_NULL
3732
3733 // Tests ASSERT_EQ(0, non_pointer).  Since the literal 0 can be
3734 // treated as a null pointer by the compiler, we need to make sure
3735 // that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as
3736 // ASSERT_EQ(static_cast<void*>(NULL), non_pointer).
3737 TEST(ExpectTest, ASSERT_EQ_0) {
3738   int n = 0;
3739
3740   // A success.
3741   ASSERT_EQ(0, n);
3742
3743   // A failure.
3744   EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
3745                        "  0\n  5.6");
3746 }
3747
3748 // Tests ASSERT_NE.
3749 TEST(AssertionTest, ASSERT_NE) {
3750   ASSERT_NE(6, 7);
3751   EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'),
3752                        "Expected: ('a') != ('a'), "
3753                        "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
3754 }
3755
3756 // Tests ASSERT_LE.
3757 TEST(AssertionTest, ASSERT_LE) {
3758   ASSERT_LE(2, 3);
3759   ASSERT_LE(2, 2);
3760   EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
3761                        "Expected: (2) <= (0), actual: 2 vs 0");
3762 }
3763
3764 // Tests ASSERT_LT.
3765 TEST(AssertionTest, ASSERT_LT) {
3766   ASSERT_LT(2, 3);
3767   EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
3768                        "Expected: (2) < (2), actual: 2 vs 2");
3769 }
3770
3771 // Tests ASSERT_GE.
3772 TEST(AssertionTest, ASSERT_GE) {
3773   ASSERT_GE(2, 1);
3774   ASSERT_GE(2, 2);
3775   EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
3776                        "Expected: (2) >= (3), actual: 2 vs 3");
3777 }
3778
3779 // Tests ASSERT_GT.
3780 TEST(AssertionTest, ASSERT_GT) {
3781   ASSERT_GT(2, 1);
3782   EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
3783                        "Expected: (2) > (2), actual: 2 vs 2");
3784 }
3785
3786 #if GTEST_HAS_EXCEPTIONS
3787
3788 void ThrowNothing() {}
3789
3790 // Tests ASSERT_THROW.
3791 TEST(AssertionTest, ASSERT_THROW) {
3792   ASSERT_THROW(ThrowAnInteger(), int);
3793
3794 # ifndef __BORLANDC__
3795
3796   // ICE's in C++Builder 2007 and 2009.
3797   EXPECT_FATAL_FAILURE(
3798       ASSERT_THROW(ThrowAnInteger(), bool),
3799       "Expected: ThrowAnInteger() throws an exception of type bool.\n"
3800       "  Actual: it throws a different type.");
3801 # endif
3802
3803   EXPECT_FATAL_FAILURE(
3804       ASSERT_THROW(ThrowNothing(), bool),
3805       "Expected: ThrowNothing() throws an exception of type bool.\n"
3806       "  Actual: it throws nothing.");
3807 }
3808
3809 // Tests ASSERT_NO_THROW.
3810 TEST(AssertionTest, ASSERT_NO_THROW) {
3811   ASSERT_NO_THROW(ThrowNothing());
3812   EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
3813                        "Expected: ThrowAnInteger() doesn't throw an exception."
3814                        "\n  Actual: it throws.");
3815 }
3816
3817 // Tests ASSERT_ANY_THROW.
3818 TEST(AssertionTest, ASSERT_ANY_THROW) {
3819   ASSERT_ANY_THROW(ThrowAnInteger());
3820   EXPECT_FATAL_FAILURE(
3821       ASSERT_ANY_THROW(ThrowNothing()),
3822       "Expected: ThrowNothing() throws an exception.\n"
3823       "  Actual: it doesn't.");
3824 }
3825
3826 #endif  // GTEST_HAS_EXCEPTIONS
3827
3828 // Makes sure we deal with the precedence of <<.  This test should
3829 // compile.
3830 TEST(AssertionTest, AssertPrecedence) {
3831   ASSERT_EQ(1 < 2, true);
3832   bool false_value = false;
3833   ASSERT_EQ(true && false_value, false);
3834 }
3835
3836 // A subroutine used by the following test.
3837 void TestEq1(int x) {
3838   ASSERT_EQ(1, x);
3839 }
3840
3841 // Tests calling a test subroutine that's not part of a fixture.
3842 TEST(AssertionTest, NonFixtureSubroutine) {
3843   EXPECT_FATAL_FAILURE(TestEq1(2),
3844                        "  x\n    Which is: 2");
3845 }
3846
3847 // An uncopyable class.
3848 class Uncopyable {
3849  public:
3850   explicit Uncopyable(int a_value) : value_(a_value) {}
3851
3852   int value() const { return value_; }
3853   bool operator==(const Uncopyable& rhs) const {
3854     return value() == rhs.value();
3855   }
3856  private:
3857   // This constructor deliberately has no implementation, as we don't
3858   // want this class to be copyable.
3859   Uncopyable(const Uncopyable&);  // NOLINT
3860
3861   int value_;
3862 };
3863
3864 ::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) {
3865   return os << value.value();
3866 }
3867
3868
3869 bool IsPositiveUncopyable(const Uncopyable& x) {
3870   return x.value() > 0;
3871 }
3872
3873 // A subroutine used by the following test.
3874 void TestAssertNonPositive() {
3875   Uncopyable y(-1);
3876   ASSERT_PRED1(IsPositiveUncopyable, y);
3877 }
3878 // A subroutine used by the following test.
3879 void TestAssertEqualsUncopyable() {
3880   Uncopyable x(5);
3881   Uncopyable y(-1);
3882   ASSERT_EQ(x, y);
3883 }
3884
3885 // Tests that uncopyable objects can be used in assertions.
3886 TEST(AssertionTest, AssertWorksWithUncopyableObject) {
3887   Uncopyable x(5);
3888   ASSERT_PRED1(IsPositiveUncopyable, x);
3889   ASSERT_EQ(x, x);
3890   EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
3891     "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
3892   EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
3893                        "Expected equality of these values:\n"
3894                        "  x\n    Which is: 5\n  y\n    Which is: -1");
3895 }
3896
3897 // Tests that uncopyable objects can be used in expects.
3898 TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
3899   Uncopyable x(5);
3900   EXPECT_PRED1(IsPositiveUncopyable, x);
3901   Uncopyable y(-1);
3902   EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
3903     "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
3904   EXPECT_EQ(x, x);
3905   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
3906                           "Expected equality of these values:\n"
3907                           "  x\n    Which is: 5\n  y\n    Which is: -1");
3908 }
3909
3910 enum NamedEnum {
3911   kE1 = 0,
3912   kE2 = 1
3913 };
3914
3915 TEST(AssertionTest, NamedEnum) {
3916   EXPECT_EQ(kE1, kE1);
3917   EXPECT_LT(kE1, kE2);
3918   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0");
3919   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 1");
3920 }
3921
3922 // The version of gcc used in XCode 2.2 has a bug and doesn't allow
3923 // anonymous enums in assertions.  Therefore the following test is not
3924 // done on Mac.
3925 // Sun Studio and HP aCC also reject this code.
3926 #if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC)
3927
3928 // Tests using assertions with anonymous enums.
3929 enum {
3930   kCaseA = -1,
3931
3932 # if GTEST_OS_LINUX
3933
3934   // We want to test the case where the size of the anonymous enum is
3935   // larger than sizeof(int), to make sure our implementation of the
3936   // assertions doesn't truncate the enums.  However, MSVC
3937   // (incorrectly) doesn't allow an enum value to exceed the range of
3938   // an int, so this has to be conditionally compiled.
3939   //
3940   // On Linux, kCaseB and kCaseA have the same value when truncated to
3941   // int size.  We want to test whether this will confuse the
3942   // assertions.
3943   kCaseB = testing::internal::kMaxBiggestInt,
3944
3945 # else
3946
3947   kCaseB = INT_MAX,
3948
3949 # endif  // GTEST_OS_LINUX
3950
3951   kCaseC = 42
3952 };
3953
3954 TEST(AssertionTest, AnonymousEnum) {
3955 # if GTEST_OS_LINUX
3956
3957   EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
3958
3959 # endif  // GTEST_OS_LINUX
3960
3961   EXPECT_EQ(kCaseA, kCaseA);
3962   EXPECT_NE(kCaseA, kCaseB);
3963   EXPECT_LT(kCaseA, kCaseB);
3964   EXPECT_LE(kCaseA, kCaseB);
3965   EXPECT_GT(kCaseB, kCaseA);
3966   EXPECT_GE(kCaseA, kCaseA);
3967   EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
3968                           "(kCaseA) >= (kCaseB)");
3969   EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
3970                           "-1 vs 42");
3971
3972   ASSERT_EQ(kCaseA, kCaseA);
3973   ASSERT_NE(kCaseA, kCaseB);
3974   ASSERT_LT(kCaseA, kCaseB);
3975   ASSERT_LE(kCaseA, kCaseB);
3976   ASSERT_GT(kCaseB, kCaseA);
3977   ASSERT_GE(kCaseA, kCaseA);
3978
3979 # ifndef __BORLANDC__
3980
3981   // ICE's in C++Builder.
3982   EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
3983                        "  kCaseB\n    Which is: ");
3984   EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
3985                        "\n    Which is: 42");
3986 # endif
3987
3988   EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
3989                        "\n    Which is: -1");
3990 }
3991
3992 #endif  // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
3993
3994 #if GTEST_OS_WINDOWS
3995
3996 static HRESULT UnexpectedHRESULTFailure() {
3997   return E_UNEXPECTED;
3998 }
3999
4000 static HRESULT OkHRESULTSuccess() {
4001   return S_OK;
4002 }
4003
4004 static HRESULT FalseHRESULTSuccess() {
4005   return S_FALSE;
4006 }
4007
4008 // HRESULT assertion tests test both zero and non-zero
4009 // success codes as well as failure message for each.
4010 //
4011 // Windows CE doesn't support message texts.
4012 TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
4013   EXPECT_HRESULT_SUCCEEDED(S_OK);
4014   EXPECT_HRESULT_SUCCEEDED(S_FALSE);
4015
4016   EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
4017     "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
4018     "  Actual: 0x8000FFFF");
4019 }
4020
4021 TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
4022   ASSERT_HRESULT_SUCCEEDED(S_OK);
4023   ASSERT_HRESULT_SUCCEEDED(S_FALSE);
4024
4025   EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
4026     "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
4027     "  Actual: 0x8000FFFF");
4028 }
4029
4030 TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
4031   EXPECT_HRESULT_FAILED(E_UNEXPECTED);
4032
4033   EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
4034     "Expected: (OkHRESULTSuccess()) fails.\n"
4035     "  Actual: 0x0");
4036   EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
4037     "Expected: (FalseHRESULTSuccess()) fails.\n"
4038     "  Actual: 0x1");
4039 }
4040
4041 TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
4042   ASSERT_HRESULT_FAILED(E_UNEXPECTED);
4043
4044 # ifndef __BORLANDC__
4045
4046   // ICE's in C++Builder 2007 and 2009.
4047   EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
4048     "Expected: (OkHRESULTSuccess()) fails.\n"
4049     "  Actual: 0x0");
4050 # endif
4051
4052   EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
4053     "Expected: (FalseHRESULTSuccess()) fails.\n"
4054     "  Actual: 0x1");
4055 }
4056
4057 // Tests that streaming to the HRESULT macros works.
4058 TEST(HRESULTAssertionTest, Streaming) {
4059   EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
4060   ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
4061   EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
4062   ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
4063
4064   EXPECT_NONFATAL_FAILURE(
4065       EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
4066       "expected failure");
4067
4068 # ifndef __BORLANDC__
4069
4070   // ICE's in C++Builder 2007 and 2009.
4071   EXPECT_FATAL_FAILURE(
4072       ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
4073       "expected failure");
4074 # endif
4075
4076   EXPECT_NONFATAL_FAILURE(
4077       EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
4078       "expected failure");
4079
4080   EXPECT_FATAL_FAILURE(
4081       ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
4082       "expected failure");
4083 }
4084
4085 #endif  // GTEST_OS_WINDOWS
4086
4087 #ifdef __BORLANDC__
4088 // Silences warnings: "Condition is always true", "Unreachable code"
4089 # pragma option push -w-ccc -w-rch
4090 #endif
4091
4092 // Tests that the assertion macros behave like single statements.
4093 TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
4094   if (AlwaysFalse())
4095     ASSERT_TRUE(false) << "This should never be executed; "
4096                           "It's a compilation test only.";
4097
4098   if (AlwaysTrue())
4099     EXPECT_FALSE(false);
4100   else
4101     ;  // NOLINT
4102
4103   if (AlwaysFalse())
4104     ASSERT_LT(1, 3);
4105
4106   if (AlwaysFalse())
4107     ;  // NOLINT
4108   else
4109     EXPECT_GT(3, 2) << "";
4110 }
4111
4112 #if GTEST_HAS_EXCEPTIONS
4113 // Tests that the compiler will not complain about unreachable code in the
4114 // EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros.
4115 TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
4116   int n = 0;
4117
4118   EXPECT_THROW(throw 1, int);
4119   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), "");
4120   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), "");
4121   EXPECT_NO_THROW(n++);
4122   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), "");
4123   EXPECT_ANY_THROW(throw 1);
4124   EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), "");
4125 }
4126
4127 TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
4128   if (AlwaysFalse())
4129     EXPECT_THROW(ThrowNothing(), bool);
4130
4131   if (AlwaysTrue())
4132     EXPECT_THROW(ThrowAnInteger(), int);
4133   else
4134     ;  // NOLINT
4135
4136   if (AlwaysFalse())
4137     EXPECT_NO_THROW(ThrowAnInteger());
4138
4139   if (AlwaysTrue())
4140     EXPECT_NO_THROW(ThrowNothing());
4141   else
4142     ;  // NOLINT
4143
4144   if (AlwaysFalse())
4145     EXPECT_ANY_THROW(ThrowNothing());
4146
4147   if (AlwaysTrue())
4148     EXPECT_ANY_THROW(ThrowAnInteger());
4149   else
4150     ;  // NOLINT
4151 }
4152 #endif  // GTEST_HAS_EXCEPTIONS
4153
4154 TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {
4155   if (AlwaysFalse())
4156     EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "
4157                                     << "It's a compilation test only.";
4158   else
4159     ;  // NOLINT
4160
4161   if (AlwaysFalse())
4162     ASSERT_NO_FATAL_FAILURE(FAIL()) << "";
4163   else
4164     ;  // NOLINT
4165
4166   if (AlwaysTrue())
4167     EXPECT_NO_FATAL_FAILURE(SUCCEED());
4168   else
4169     ;  // NOLINT
4170
4171   if (AlwaysFalse())
4172     ;  // NOLINT
4173   else
4174     ASSERT_NO_FATAL_FAILURE(SUCCEED());
4175 }
4176
4177 // Tests that the assertion macros work well with switch statements.
4178 TEST(AssertionSyntaxTest, WorksWithSwitch) {
4179   switch (0) {
4180     case 1:
4181       break;
4182     default:
4183       ASSERT_TRUE(true);
4184   }
4185
4186   switch (0)
4187     case 0:
4188       EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
4189
4190   // Binary assertions are implemented using a different code path
4191   // than the Boolean assertions.  Hence we test them separately.
4192   switch (0) {
4193     case 1:
4194     default:
4195       ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler";
4196   }
4197
4198   switch (0)
4199     case 0:
4200       EXPECT_NE(1, 2);
4201 }
4202
4203 #if GTEST_HAS_EXCEPTIONS
4204
4205 void ThrowAString() {
4206     throw "std::string";
4207 }
4208
4209 // Test that the exception assertion macros compile and work with const
4210 // type qualifier.
4211 TEST(AssertionSyntaxTest, WorksWithConst) {
4212     ASSERT_THROW(ThrowAString(), const char*);
4213
4214     EXPECT_THROW(ThrowAString(), const char*);
4215 }
4216
4217 #endif  // GTEST_HAS_EXCEPTIONS
4218
4219 }  // namespace
4220
4221 namespace testing {
4222
4223 // Tests that Google Test tracks SUCCEED*.
4224 TEST(SuccessfulAssertionTest, SUCCEED) {
4225   SUCCEED();
4226   SUCCEED() << "OK";
4227   EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
4228 }
4229
4230 // Tests that Google Test doesn't track successful EXPECT_*.
4231 TEST(SuccessfulAssertionTest, EXPECT) {
4232   EXPECT_TRUE(true);
4233   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
4234 }
4235
4236 // Tests that Google Test doesn't track successful EXPECT_STR*.
4237 TEST(SuccessfulAssertionTest, EXPECT_STR) {
4238   EXPECT_STREQ("", "");
4239   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
4240 }
4241
4242 // Tests that Google Test doesn't track successful ASSERT_*.
4243 TEST(SuccessfulAssertionTest, ASSERT) {
4244   ASSERT_TRUE(true);
4245   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
4246 }
4247
4248 // Tests that Google Test doesn't track successful ASSERT_STR*.
4249 TEST(SuccessfulAssertionTest, ASSERT_STR) {
4250   ASSERT_STREQ("", "");
4251   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
4252 }
4253
4254 }  // namespace testing
4255
4256 namespace {
4257
4258 // Tests the message streaming variation of assertions.
4259
4260 TEST(AssertionWithMessageTest, EXPECT) {
4261   EXPECT_EQ(1, 1) << "This should succeed.";
4262   EXPECT_NONFATAL_FAILURE(EXPECT_NE(1, 1) << "Expected failure #1.",
4263                           "Expected failure #1");
4264   EXPECT_LE(1, 2) << "This should succeed.";
4265   EXPECT_NONFATAL_FAILURE(EXPECT_LT(1, 0) << "Expected failure #2.",
4266                           "Expected failure #2.");
4267   EXPECT_GE(1, 0) << "This should succeed.";
4268   EXPECT_NONFATAL_FAILURE(EXPECT_GT(1, 2) << "Expected failure #3.",
4269                           "Expected failure #3.");
4270
4271   EXPECT_STREQ("1", "1") << "This should succeed.";
4272   EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("1", "1") << "Expected failure #4.",
4273                           "Expected failure #4.");
4274   EXPECT_STRCASEEQ("a", "A") << "This should succeed.";
4275   EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("a", "A") << "Expected failure #5.",
4276                           "Expected failure #5.");
4277
4278   EXPECT_FLOAT_EQ(1, 1) << "This should succeed.";
4279   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1, 1.2) << "Expected failure #6.",
4280                           "Expected failure #6.");
4281   EXPECT_NEAR(1, 1.1, 0.2) << "This should succeed.";
4282 }
4283
4284 TEST(AssertionWithMessageTest, ASSERT) {
4285   ASSERT_EQ(1, 1) << "This should succeed.";
4286   ASSERT_NE(1, 2) << "This should succeed.";
4287   ASSERT_LE(1, 2) << "This should succeed.";
4288   ASSERT_LT(1, 2) << "This should succeed.";
4289   ASSERT_GE(1, 0) << "This should succeed.";
4290   EXPECT_FATAL_FAILURE(ASSERT_GT(1, 2) << "Expected failure.",
4291                        "Expected failure.");
4292 }
4293
4294 TEST(AssertionWithMessageTest, ASSERT_STR) {
4295   ASSERT_STREQ("1", "1") << "This should succeed.";
4296   ASSERT_STRNE("1", "2") << "This should succeed.";
4297   ASSERT_STRCASEEQ("a", "A") << "This should succeed.";
4298   EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("a", "A") << "Expected failure.",
4299                        "Expected failure.");
4300 }
4301
4302 TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
4303   ASSERT_FLOAT_EQ(1, 1) << "This should succeed.";
4304   ASSERT_DOUBLE_EQ(1, 1) << "This should succeed.";
4305   EXPECT_FATAL_FAILURE(ASSERT_NEAR(1,1.2, 0.1) << "Expect failure.",  // NOLINT
4306                        "Expect failure.");
4307   // To work around a bug in gcc 2.95.0, there is intentionally no
4308   // space after the first comma in the previous statement.
4309 }
4310
4311 // Tests using ASSERT_FALSE with a streamed message.
4312 TEST(AssertionWithMessageTest, ASSERT_FALSE) {
4313   ASSERT_FALSE(false) << "This shouldn't fail.";
4314   EXPECT_FATAL_FAILURE({  // NOLINT
4315     ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
4316                        << " evaluates to " << true;
4317   }, "Expected failure");
4318 }
4319
4320 // Tests using FAIL with a streamed message.
4321 TEST(AssertionWithMessageTest, FAIL) {
4322   EXPECT_FATAL_FAILURE(FAIL() << 0,
4323                        "0");
4324 }
4325
4326 // Tests using SUCCEED with a streamed message.
4327 TEST(AssertionWithMessageTest, SUCCEED) {
4328   SUCCEED() << "Success == " << 1;
4329 }
4330
4331 // Tests using ASSERT_TRUE with a streamed message.
4332 TEST(AssertionWithMessageTest, ASSERT_TRUE) {
4333   ASSERT_TRUE(true) << "This should succeed.";
4334   ASSERT_TRUE(true) << true;
4335   EXPECT_FATAL_FAILURE({  // NOLINT
4336     ASSERT_TRUE(false) << static_cast<const char *>(NULL)
4337                        << static_cast<char *>(NULL);
4338   }, "(null)(null)");
4339 }
4340
4341 #if GTEST_OS_WINDOWS
4342 // Tests using wide strings in assertion messages.
4343 TEST(AssertionWithMessageTest, WideStringMessage) {
4344   EXPECT_NONFATAL_FAILURE({  // NOLINT
4345     EXPECT_TRUE(false) << L"This failure is expected.\x8119";
4346   }, "This failure is expected.");
4347   EXPECT_FATAL_FAILURE({  // NOLINT
4348     ASSERT_EQ(1, 2) << "This failure is "
4349                     << L"expected too.\x8120";
4350   }, "This failure is expected too.");
4351 }
4352 #endif  // GTEST_OS_WINDOWS
4353
4354 // Tests EXPECT_TRUE.
4355 TEST(ExpectTest, EXPECT_TRUE) {
4356   EXPECT_TRUE(true) << "Intentional success";
4357   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #1.",
4358                           "Intentional failure #1.");
4359   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #2.",
4360                           "Intentional failure #2.");
4361   EXPECT_TRUE(2 > 1);  // NOLINT
4362   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1),
4363                           "Value of: 2 < 1\n"
4364                           "  Actual: false\n"
4365                           "Expected: true");
4366   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
4367                           "2 > 3");
4368 }
4369
4370 // Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult.
4371 TEST(ExpectTest, ExpectTrueWithAssertionResult) {
4372   EXPECT_TRUE(ResultIsEven(2));
4373   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)),
4374                           "Value of: ResultIsEven(3)\n"
4375                           "  Actual: false (3 is odd)\n"
4376                           "Expected: true");
4377   EXPECT_TRUE(ResultIsEvenNoExplanation(2));
4378   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)),
4379                           "Value of: ResultIsEvenNoExplanation(3)\n"
4380                           "  Actual: false (3 is odd)\n"
4381                           "Expected: true");
4382 }
4383
4384 // Tests EXPECT_FALSE with a streamed message.
4385 TEST(ExpectTest, EXPECT_FALSE) {
4386   EXPECT_FALSE(2 < 1);  // NOLINT
4387   EXPECT_FALSE(false) << "Intentional success";
4388   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #1.",
4389                           "Intentional failure #1.");
4390   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #2.",
4391                           "Intentional failure #2.");
4392   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1),
4393                           "Value of: 2 > 1\n"
4394                           "  Actual: true\n"
4395                           "Expected: false");
4396   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
4397                           "2 < 3");
4398 }
4399
4400 // Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
4401 TEST(ExpectTest, ExpectFalseWithAssertionResult) {
4402   EXPECT_FALSE(ResultIsEven(3));
4403   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)),
4404                           "Value of: ResultIsEven(2)\n"
4405                           "  Actual: true (2 is even)\n"
4406                           "Expected: false");
4407   EXPECT_FALSE(ResultIsEvenNoExplanation(3));
4408   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)),
4409                           "Value of: ResultIsEvenNoExplanation(2)\n"
4410                           "  Actual: true\n"
4411                           "Expected: false");
4412 }
4413
4414 #ifdef __BORLANDC__
4415 // Restores warnings after previous "#pragma option push" suppressed them
4416 # pragma option pop
4417 #endif
4418
4419 // Tests EXPECT_EQ.
4420 TEST(ExpectTest, EXPECT_EQ) {
4421   EXPECT_EQ(5, 2 + 3);
4422   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
4423                           "Expected equality of these values:\n"
4424                           "  5\n"
4425                           "  2*3\n"
4426                           "    Which is: 6");
4427   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
4428                           "2 - 3");
4429 }
4430
4431 // Tests using EXPECT_EQ on double values.  The purpose is to make
4432 // sure that the specialization we did for integer and anonymous enums
4433 // isn't used for double arguments.
4434 TEST(ExpectTest, EXPECT_EQ_Double) {
4435   // A success.
4436   EXPECT_EQ(5.6, 5.6);
4437
4438   // A failure.
4439   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
4440                           "5.1");
4441 }
4442
4443 #if GTEST_CAN_COMPARE_NULL
4444 // Tests EXPECT_EQ(NULL, pointer).
4445 TEST(ExpectTest, EXPECT_EQ_NULL) {
4446   // A success.
4447   const char* p = NULL;
4448   // Some older GCC versions may issue a spurious warning in this or the next
4449   // assertion statement. This warning should not be suppressed with
4450   // static_cast since the test verifies the ability to use bare NULL as the
4451   // expected parameter to the macro.
4452   EXPECT_EQ(NULL, p);
4453
4454   // A failure.
4455   int n = 0;
4456   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
4457                           "  &n\n    Which is:");
4458 }
4459 #endif  // GTEST_CAN_COMPARE_NULL
4460
4461 // Tests EXPECT_EQ(0, non_pointer).  Since the literal 0 can be
4462 // treated as a null pointer by the compiler, we need to make sure
4463 // that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as
4464 // EXPECT_EQ(static_cast<void*>(NULL), non_pointer).
4465 TEST(ExpectTest, EXPECT_EQ_0) {
4466   int n = 0;
4467
4468   // A success.
4469   EXPECT_EQ(0, n);
4470
4471   // A failure.
4472   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
4473                           "  0\n  5.6");
4474 }
4475
4476 // Tests EXPECT_NE.
4477 TEST(ExpectTest, EXPECT_NE) {
4478   EXPECT_NE(6, 7);
4479
4480   EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
4481                           "Expected: ('a') != ('a'), "
4482                           "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
4483   EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
4484                           "2");
4485   char* const p0 = NULL;
4486   EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
4487                           "p0");
4488   // Only way to get the Nokia compiler to compile the cast
4489   // is to have a separate void* variable first. Putting
4490   // the two casts on the same line doesn't work, neither does
4491   // a direct C-style to char*.
4492   void* pv1 = (void*)0x1234;  // NOLINT
4493   char* const p1 = reinterpret_cast<char*>(pv1);
4494   EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
4495                           "p1");
4496 }
4497
4498 // Tests EXPECT_LE.
4499 TEST(ExpectTest, EXPECT_LE) {
4500   EXPECT_LE(2, 3);
4501   EXPECT_LE(2, 2);
4502   EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
4503                           "Expected: (2) <= (0), actual: 2 vs 0");
4504   EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
4505                           "(1.1) <= (0.9)");
4506 }
4507
4508 // Tests EXPECT_LT.
4509 TEST(ExpectTest, EXPECT_LT) {
4510   EXPECT_LT(2, 3);
4511   EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
4512                           "Expected: (2) < (2), actual: 2 vs 2");
4513   EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
4514                           "(2) < (1)");
4515 }
4516
4517 // Tests EXPECT_GE.
4518 TEST(ExpectTest, EXPECT_GE) {
4519   EXPECT_GE(2, 1);
4520   EXPECT_GE(2, 2);
4521   EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
4522                           "Expected: (2) >= (3), actual: 2 vs 3");
4523   EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
4524                           "(0.9) >= (1.1)");
4525 }
4526
4527 // Tests EXPECT_GT.
4528 TEST(ExpectTest, EXPECT_GT) {
4529   EXPECT_GT(2, 1);
4530   EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
4531                           "Expected: (2) > (2), actual: 2 vs 2");
4532   EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
4533                           "(2) > (3)");
4534 }
4535
4536 #if GTEST_HAS_EXCEPTIONS
4537
4538 // Tests EXPECT_THROW.
4539 TEST(ExpectTest, EXPECT_THROW) {
4540   EXPECT_THROW(ThrowAnInteger(), int);
4541   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
4542                           "Expected: ThrowAnInteger() throws an exception of "
4543                           "type bool.\n  Actual: it throws a different type.");
4544   EXPECT_NONFATAL_FAILURE(
4545       EXPECT_THROW(ThrowNothing(), bool),
4546       "Expected: ThrowNothing() throws an exception of type bool.\n"
4547       "  Actual: it throws nothing.");
4548 }
4549
4550 // Tests EXPECT_NO_THROW.
4551 TEST(ExpectTest, EXPECT_NO_THROW) {
4552   EXPECT_NO_THROW(ThrowNothing());
4553   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
4554                           "Expected: ThrowAnInteger() doesn't throw an "
4555                           "exception.\n  Actual: it throws.");
4556 }
4557
4558 // Tests EXPECT_ANY_THROW.
4559 TEST(ExpectTest, EXPECT_ANY_THROW) {
4560   EXPECT_ANY_THROW(ThrowAnInteger());
4561   EXPECT_NONFATAL_FAILURE(
4562       EXPECT_ANY_THROW(ThrowNothing()),
4563       "Expected: ThrowNothing() throws an exception.\n"
4564       "  Actual: it doesn't.");
4565 }
4566
4567 #endif  // GTEST_HAS_EXCEPTIONS
4568
4569 // Make sure we deal with the precedence of <<.
4570 TEST(ExpectTest, ExpectPrecedence) {
4571   EXPECT_EQ(1 < 2, true);
4572   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
4573                           "  true && false\n    Which is: false");
4574 }
4575
4576
4577 // Tests the StreamableToString() function.
4578
4579 // Tests using StreamableToString() on a scalar.
4580 TEST(StreamableToStringTest, Scalar) {
4581   EXPECT_STREQ("5", StreamableToString(5).c_str());
4582 }
4583
4584 // Tests using StreamableToString() on a non-char pointer.
4585 TEST(StreamableToStringTest, Pointer) {
4586   int n = 0;
4587   int* p = &n;
4588   EXPECT_STRNE("(null)", StreamableToString(p).c_str());
4589 }
4590
4591 // Tests using StreamableToString() on a NULL non-char pointer.
4592 TEST(StreamableToStringTest, NullPointer) {
4593   int* p = NULL;
4594   EXPECT_STREQ("(null)", StreamableToString(p).c_str());
4595 }
4596
4597 // Tests using StreamableToString() on a C string.
4598 TEST(StreamableToStringTest, CString) {
4599   EXPECT_STREQ("Foo", StreamableToString("Foo").c_str());
4600 }
4601
4602 // Tests using StreamableToString() on a NULL C string.
4603 TEST(StreamableToStringTest, NullCString) {
4604   char* p = NULL;
4605   EXPECT_STREQ("(null)", StreamableToString(p).c_str());
4606 }
4607
4608 // Tests using streamable values as assertion messages.
4609
4610 // Tests using std::string as an assertion message.
4611 TEST(StreamableTest, string) {
4612   static const std::string str(
4613       "This failure message is a std::string, and is expected.");
4614   EXPECT_FATAL_FAILURE(FAIL() << str,
4615                        str.c_str());
4616 }
4617
4618 // Tests that we can output strings containing embedded NULs.
4619 // Limited to Linux because we can only do this with std::string's.
4620 TEST(StreamableTest, stringWithEmbeddedNUL) {
4621   static const char char_array_with_nul[] =
4622       "Here's a NUL\0 and some more string";
4623   static const std::string string_with_nul(char_array_with_nul,
4624                                            sizeof(char_array_with_nul)
4625                                            - 1);  // drops the trailing NUL
4626   EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
4627                        "Here's a NUL\\0 and some more string");
4628 }
4629
4630 // Tests that we can output a NUL char.
4631 TEST(StreamableTest, NULChar) {
4632   EXPECT_FATAL_FAILURE({  // NOLINT
4633     FAIL() << "A NUL" << '\0' << " and some more string";
4634   }, "A NUL\\0 and some more string");
4635 }
4636
4637 // Tests using int as an assertion message.
4638 TEST(StreamableTest, int) {
4639   EXPECT_FATAL_FAILURE(FAIL() << 900913,
4640                        "900913");
4641 }
4642
4643 // Tests using NULL char pointer as an assertion message.
4644 //
4645 // In MSVC, streaming a NULL char * causes access violation.  Google Test
4646 // implemented a workaround (substituting "(null)" for NULL).  This
4647 // tests whether the workaround works.
4648 TEST(StreamableTest, NullCharPtr) {
4649   EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL),
4650                        "(null)");
4651 }
4652
4653 // Tests that basic IO manipulators (endl, ends, and flush) can be
4654 // streamed to testing::Message.
4655 TEST(StreamableTest, BasicIoManip) {
4656   EXPECT_FATAL_FAILURE({  // NOLINT
4657     FAIL() << "Line 1." << std::endl
4658            << "A NUL char " << std::ends << std::flush << " in line 2.";
4659   }, "Line 1.\nA NUL char \\0 in line 2.");
4660 }
4661
4662 // Tests the macros that haven't been covered so far.
4663
4664 void AddFailureHelper(bool* aborted) {
4665   *aborted = true;
4666   ADD_FAILURE() << "Intentional failure.";
4667   *aborted = false;
4668 }
4669
4670 // Tests ADD_FAILURE.
4671 TEST(MacroTest, ADD_FAILURE) {
4672   bool aborted = true;
4673   EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
4674                           "Intentional failure.");
4675   EXPECT_FALSE(aborted);
4676 }
4677
4678 // Tests ADD_FAILURE_AT.
4679 TEST(MacroTest, ADD_FAILURE_AT) {
4680   // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and
4681   // the failure message contains the user-streamed part.
4682   EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!");
4683
4684   // Verifies that the user-streamed part is optional.
4685   EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed");
4686
4687   // Unfortunately, we cannot verify that the failure message contains
4688   // the right file path and line number the same way, as
4689   // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and
4690   // line number.  Instead, we do that in googletest-output-test_.cc.
4691 }
4692
4693 // Tests FAIL.
4694 TEST(MacroTest, FAIL) {
4695   EXPECT_FATAL_FAILURE(FAIL(),
4696                        "Failed");
4697   EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
4698                        "Intentional failure.");
4699 }
4700
4701 // Tests SUCCEED
4702 TEST(MacroTest, SUCCEED) {
4703   SUCCEED();
4704   SUCCEED() << "Explicit success.";
4705 }
4706
4707 // Tests for EXPECT_EQ() and ASSERT_EQ().
4708 //
4709 // These tests fail *intentionally*, s.t. the failure messages can be
4710 // generated and tested.
4711 //
4712 // We have different tests for different argument types.
4713
4714 // Tests using bool values in {EXPECT|ASSERT}_EQ.
4715 TEST(EqAssertionTest, Bool) {
4716   EXPECT_EQ(true,  true);
4717   EXPECT_FATAL_FAILURE({
4718       bool false_value = false;
4719       ASSERT_EQ(false_value, true);
4720     }, "  false_value\n    Which is: false\n  true");
4721 }
4722
4723 // Tests using int values in {EXPECT|ASSERT}_EQ.
4724 TEST(EqAssertionTest, Int) {
4725   ASSERT_EQ(32, 32);
4726   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
4727                           "  32\n  33");
4728 }
4729
4730 // Tests using time_t values in {EXPECT|ASSERT}_EQ.
4731 TEST(EqAssertionTest, Time_T) {
4732   EXPECT_EQ(static_cast<time_t>(0),
4733             static_cast<time_t>(0));
4734   EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
4735                                  static_cast<time_t>(1234)),
4736                        "1234");
4737 }
4738
4739 // Tests using char values in {EXPECT|ASSERT}_EQ.
4740 TEST(EqAssertionTest, Char) {
4741   ASSERT_EQ('z', 'z');
4742   const char ch = 'b';
4743   EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
4744                           "  ch\n    Which is: 'b'");
4745   EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
4746                           "  ch\n    Which is: 'b'");
4747 }
4748
4749 // Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
4750 TEST(EqAssertionTest, WideChar) {
4751   EXPECT_EQ(L'b', L'b');
4752
4753   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
4754                           "Expected equality of these values:\n"
4755                           "  L'\0'\n"
4756                           "    Which is: L'\0' (0, 0x0)\n"
4757                           "  L'x'\n"
4758                           "    Which is: L'x' (120, 0x78)");
4759
4760   static wchar_t wchar;
4761   wchar = L'b';
4762   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
4763                           "wchar");
4764   wchar = 0x8119;
4765   EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
4766                        "  wchar\n    Which is: L'");
4767 }
4768
4769 // Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
4770 TEST(EqAssertionTest, StdString) {
4771   // Compares a const char* to an std::string that has identical
4772   // content.
4773   ASSERT_EQ("Test", ::std::string("Test"));
4774
4775   // Compares two identical std::strings.
4776   static const ::std::string str1("A * in the middle");
4777   static const ::std::string str2(str1);
4778   EXPECT_EQ(str1, str2);
4779
4780   // Compares a const char* to an std::string that has different
4781   // content
4782   EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
4783                           "\"test\"");
4784
4785   // Compares an std::string to a char* that has different content.
4786   char* const p1 = const_cast<char*>("foo");
4787   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
4788                           "p1");
4789
4790   // Compares two std::strings that have different contents, one of
4791   // which having a NUL character in the middle.  This should fail.
4792   static ::std::string str3(str1);
4793   str3.at(2) = '\0';
4794   EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
4795                        "  str3\n    Which is: \"A \\0 in the middle\"");
4796 }
4797
4798 #if GTEST_HAS_STD_WSTRING
4799
4800 // Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.
4801 TEST(EqAssertionTest, StdWideString) {
4802   // Compares two identical std::wstrings.
4803   const ::std::wstring wstr1(L"A * in the middle");
4804   const ::std::wstring wstr2(wstr1);
4805   ASSERT_EQ(wstr1, wstr2);
4806
4807   // Compares an std::wstring to a const wchar_t* that has identical
4808   // content.
4809   const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
4810   EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
4811
4812   // Compares an std::wstring to a const wchar_t* that has different
4813   // content.
4814   const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
4815   EXPECT_NONFATAL_FAILURE({  // NOLINT
4816     EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
4817   }, "kTestX8120");
4818
4819   // Compares two std::wstrings that have different contents, one of
4820   // which having a NUL character in the middle.
4821   ::std::wstring wstr3(wstr1);
4822   wstr3.at(2) = L'\0';
4823   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
4824                           "wstr3");
4825
4826   // Compares a wchar_t* to an std::wstring that has different
4827   // content.
4828   EXPECT_FATAL_FAILURE({  // NOLINT
4829     ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
4830   }, "");
4831 }
4832
4833 #endif  // GTEST_HAS_STD_WSTRING
4834
4835 #if GTEST_HAS_GLOBAL_STRING
4836 // Tests using ::string values in {EXPECT|ASSERT}_EQ.
4837 TEST(EqAssertionTest, GlobalString) {
4838   // Compares a const char* to a ::string that has identical content.
4839   EXPECT_EQ("Test", ::string("Test"));
4840
4841   // Compares two identical ::strings.
4842   const ::string str1("A * in the middle");
4843   const ::string str2(str1);
4844   ASSERT_EQ(str1, str2);
4845
4846   // Compares a ::string to a const char* that has different content.
4847   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"),
4848                           "test");
4849
4850   // Compares two ::strings that have different contents, one of which
4851   // having a NUL character in the middle.
4852   ::string str3(str1);
4853   str3.at(2) = '\0';
4854   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3),
4855                           "str3");
4856
4857   // Compares a ::string to a char* that has different content.
4858   EXPECT_FATAL_FAILURE({  // NOLINT
4859     ASSERT_EQ(::string("bar"), const_cast<char*>("foo"));
4860   }, "");
4861 }
4862
4863 #endif  // GTEST_HAS_GLOBAL_STRING
4864
4865 #if GTEST_HAS_GLOBAL_WSTRING
4866
4867 // Tests using ::wstring values in {EXPECT|ASSERT}_EQ.
4868 TEST(EqAssertionTest, GlobalWideString) {
4869   // Compares two identical ::wstrings.
4870   static const ::wstring wstr1(L"A * in the middle");
4871   static const ::wstring wstr2(wstr1);
4872   EXPECT_EQ(wstr1, wstr2);
4873
4874   // Compares a const wchar_t* to a ::wstring that has identical content.
4875   const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
4876   ASSERT_EQ(kTestX8119, ::wstring(kTestX8119));
4877
4878   // Compares a const wchar_t* to a ::wstring that has different
4879   // content.
4880   const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
4881   EXPECT_NONFATAL_FAILURE({  // NOLINT
4882     EXPECT_EQ(kTestX8120, ::wstring(kTestX8119));
4883   }, "Test\\x8119");
4884
4885   // Compares a wchar_t* to a ::wstring that has different content.
4886   wchar_t* const p1 = const_cast<wchar_t*>(L"foo");
4887   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")),
4888                           "bar");
4889
4890   // Compares two ::wstrings that have different contents, one of which
4891   // having a NUL character in the middle.
4892   static ::wstring wstr3;
4893   wstr3 = wstr1;
4894   wstr3.at(2) = L'\0';
4895   EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3),
4896                        "wstr3");
4897 }
4898
4899 #endif  // GTEST_HAS_GLOBAL_WSTRING
4900
4901 // Tests using char pointers in {EXPECT|ASSERT}_EQ.
4902 TEST(EqAssertionTest, CharPointer) {
4903   char* const p0 = NULL;
4904   // Only way to get the Nokia compiler to compile the cast
4905   // is to have a separate void* variable first. Putting
4906   // the two casts on the same line doesn't work, neither does
4907   // a direct C-style to char*.
4908   void* pv1 = (void*)0x1234;  // NOLINT
4909   void* pv2 = (void*)0xABC0;  // NOLINT
4910   char* const p1 = reinterpret_cast<char*>(pv1);
4911   char* const p2 = reinterpret_cast<char*>(pv2);
4912   ASSERT_EQ(p1, p1);
4913
4914   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
4915                           "  p2\n    Which is:");
4916   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
4917                           "  p2\n    Which is:");
4918   EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
4919                                  reinterpret_cast<char*>(0xABC0)),
4920                        "ABC0");
4921 }
4922
4923 // Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ.
4924 TEST(EqAssertionTest, WideCharPointer) {
4925   wchar_t* const p0 = NULL;
4926   // Only way to get the Nokia compiler to compile the cast
4927   // is to have a separate void* variable first. Putting
4928   // the two casts on the same line doesn't work, neither does
4929   // a direct C-style to char*.
4930   void* pv1 = (void*)0x1234;  // NOLINT
4931   void* pv2 = (void*)0xABC0;  // NOLINT
4932   wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1);
4933   wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
4934   EXPECT_EQ(p0, p0);
4935
4936   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
4937                           "  p2\n    Which is:");
4938   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
4939                           "  p2\n    Which is:");
4940   void* pv3 = (void*)0x1234;  // NOLINT
4941   void* pv4 = (void*)0xABC0;  // NOLINT
4942   const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
4943   const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
4944   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
4945                           "p4");
4946 }
4947
4948 // Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
4949 TEST(EqAssertionTest, OtherPointer) {
4950   ASSERT_EQ(static_cast<const int*>(NULL),
4951             static_cast<const int*>(NULL));
4952   EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL),
4953                                  reinterpret_cast<const int*>(0x1234)),
4954                        "0x1234");
4955 }
4956
4957 // A class that supports binary comparison operators but not streaming.
4958 class UnprintableChar {
4959  public:
4960   explicit UnprintableChar(char ch) : char_(ch) {}
4961
4962   bool operator==(const UnprintableChar& rhs) const {
4963     return char_ == rhs.char_;
4964   }
4965   bool operator!=(const UnprintableChar& rhs) const {
4966     return char_ != rhs.char_;
4967   }
4968   bool operator<(const UnprintableChar& rhs) const {
4969     return char_ < rhs.char_;
4970   }
4971   bool operator<=(const UnprintableChar& rhs) const {
4972     return char_ <= rhs.char_;
4973   }
4974   bool operator>(const UnprintableChar& rhs) const {
4975     return char_ > rhs.char_;
4976   }
4977   bool operator>=(const UnprintableChar& rhs) const {
4978     return char_ >= rhs.char_;
4979   }
4980
4981  private:
4982   char char_;
4983 };
4984
4985 // Tests that ASSERT_EQ() and friends don't require the arguments to
4986 // be printable.
4987 TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
4988   const UnprintableChar x('x'), y('y');
4989   ASSERT_EQ(x, x);
4990   EXPECT_NE(x, y);
4991   ASSERT_LT(x, y);
4992   EXPECT_LE(x, y);
4993   ASSERT_GT(y, x);
4994   EXPECT_GE(x, x);
4995
4996   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>");
4997   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>");
4998   EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>");
4999   EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>");
5000   EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>");
5001
5002   // Code tested by EXPECT_FATAL_FAILURE cannot reference local
5003   // variables, so we have to write UnprintableChar('x') instead of x.
5004 #ifndef __BORLANDC__
5005   // ICE's in C++Builder.
5006   EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')),
5007                        "1-byte object <78>");
5008   EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
5009                        "1-byte object <78>");
5010 #endif
5011   EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
5012                        "1-byte object <79>");
5013   EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
5014                        "1-byte object <78>");
5015   EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
5016                        "1-byte object <79>");
5017 }
5018
5019 // Tests the FRIEND_TEST macro.
5020
5021 // This class has a private member we want to test.  We will test it
5022 // both in a TEST and in a TEST_F.
5023 class Foo {
5024  public:
5025   Foo() {}
5026
5027  private:
5028   int Bar() const { return 1; }
5029
5030   // Declares the friend tests that can access the private member
5031   // Bar().
5032   FRIEND_TEST(FRIEND_TEST_Test, TEST);
5033   FRIEND_TEST(FRIEND_TEST_Test2, TEST_F);
5034 };
5035
5036 // Tests that the FRIEND_TEST declaration allows a TEST to access a
5037 // class's private members.  This should compile.
5038 TEST(FRIEND_TEST_Test, TEST) {
5039   ASSERT_EQ(1, Foo().Bar());
5040 }
5041
5042 // The fixture needed to test using FRIEND_TEST with TEST_F.
5043 class FRIEND_TEST_Test2 : public Test {
5044  protected:
5045   Foo foo;
5046 };
5047
5048 // Tests that the FRIEND_TEST declaration allows a TEST_F to access a
5049 // class's private members.  This should compile.
5050 TEST_F(FRIEND_TEST_Test2, TEST_F) {
5051   ASSERT_EQ(1, foo.Bar());
5052 }
5053
5054 // Tests the life cycle of Test objects.
5055
5056 // The test fixture for testing the life cycle of Test objects.
5057 //
5058 // This class counts the number of live test objects that uses this
5059 // fixture.
5060 class TestLifeCycleTest : public Test {
5061  protected:
5062   // Constructor.  Increments the number of test objects that uses
5063   // this fixture.
5064   TestLifeCycleTest() { count_++; }
5065
5066   // Destructor.  Decrements the number of test objects that uses this
5067   // fixture.
5068   ~TestLifeCycleTest() { count_--; }
5069
5070   // Returns the number of live test objects that uses this fixture.
5071   int count() const { return count_; }
5072
5073  private:
5074   static int count_;
5075 };
5076
5077 int TestLifeCycleTest::count_ = 0;
5078
5079 // Tests the life cycle of test objects.
5080 TEST_F(TestLifeCycleTest, Test1) {
5081   // There should be only one test object in this test case that's
5082   // currently alive.
5083   ASSERT_EQ(1, count());
5084 }
5085
5086 // Tests the life cycle of test objects.
5087 TEST_F(TestLifeCycleTest, Test2) {
5088   // After Test1 is done and Test2 is started, there should still be
5089   // only one live test object, as the object for Test1 should've been
5090   // deleted.
5091   ASSERT_EQ(1, count());
5092 }
5093
5094 }  // namespace
5095
5096 // Tests that the copy constructor works when it is NOT optimized away by
5097 // the compiler.
5098 TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {
5099   // Checks that the copy constructor doesn't try to dereference NULL pointers
5100   // in the source object.
5101   AssertionResult r1 = AssertionSuccess();
5102   AssertionResult r2 = r1;
5103   // The following line is added to prevent the compiler from optimizing
5104   // away the constructor call.
5105   r1 << "abc";
5106
5107   AssertionResult r3 = r1;
5108   EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));
5109   EXPECT_STREQ("abc", r1.message());
5110 }
5111
5112 // Tests that AssertionSuccess and AssertionFailure construct
5113 // AssertionResult objects as expected.
5114 TEST(AssertionResultTest, ConstructionWorks) {
5115   AssertionResult r1 = AssertionSuccess();
5116   EXPECT_TRUE(r1);
5117   EXPECT_STREQ("", r1.message());
5118
5119   AssertionResult r2 = AssertionSuccess() << "abc";
5120   EXPECT_TRUE(r2);
5121   EXPECT_STREQ("abc", r2.message());
5122
5123   AssertionResult r3 = AssertionFailure();
5124   EXPECT_FALSE(r3);
5125   EXPECT_STREQ("", r3.message());
5126
5127   AssertionResult r4 = AssertionFailure() << "def";
5128   EXPECT_FALSE(r4);
5129   EXPECT_STREQ("def", r4.message());
5130
5131   AssertionResult r5 = AssertionFailure(Message() << "ghi");
5132   EXPECT_FALSE(r5);
5133   EXPECT_STREQ("ghi", r5.message());
5134 }
5135
5136 // Tests that the negation flips the predicate result but keeps the message.
5137 TEST(AssertionResultTest, NegationWorks) {
5138   AssertionResult r1 = AssertionSuccess() << "abc";
5139   EXPECT_FALSE(!r1);
5140   EXPECT_STREQ("abc", (!r1).message());
5141
5142   AssertionResult r2 = AssertionFailure() << "def";
5143   EXPECT_TRUE(!r2);
5144   EXPECT_STREQ("def", (!r2).message());
5145 }
5146
5147 TEST(AssertionResultTest, StreamingWorks) {
5148   AssertionResult r = AssertionSuccess();
5149   r << "abc" << 'd' << 0 << true;
5150   EXPECT_STREQ("abcd0true", r.message());
5151 }
5152
5153 TEST(AssertionResultTest, CanStreamOstreamManipulators) {
5154   AssertionResult r = AssertionSuccess();
5155   r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
5156   EXPECT_STREQ("Data\n\\0Will be visible", r.message());
5157 }
5158
5159 // The next test uses explicit conversion operators -- a C++11 feature.
5160 #if GTEST_LANG_CXX11
5161
5162 TEST(AssertionResultTest, ConstructibleFromContextuallyConvertibleToBool) {
5163   struct ExplicitlyConvertibleToBool {
5164     explicit operator bool() const { return value; }
5165     bool value;
5166   };
5167   ExplicitlyConvertibleToBool v1 = {false};
5168   ExplicitlyConvertibleToBool v2 = {true};
5169   EXPECT_FALSE(v1);
5170   EXPECT_TRUE(v2);
5171 }
5172
5173 #endif  // GTEST_LANG_CXX11
5174
5175 struct ConvertibleToAssertionResult {
5176   operator AssertionResult() const { return AssertionResult(true); }
5177 };
5178
5179 TEST(AssertionResultTest, ConstructibleFromImplicitlyConvertible) {
5180   ConvertibleToAssertionResult obj;
5181   EXPECT_TRUE(obj);
5182 }
5183
5184 // Tests streaming a user type whose definition and operator << are
5185 // both in the global namespace.
5186 class Base {
5187  public:
5188   explicit Base(int an_x) : x_(an_x) {}
5189   int x() const { return x_; }
5190  private:
5191   int x_;
5192 };
5193 std::ostream& operator<<(std::ostream& os,
5194                          const Base& val) {
5195   return os << val.x();
5196 }
5197 std::ostream& operator<<(std::ostream& os,
5198                          const Base* pointer) {
5199   return os << "(" << pointer->x() << ")";
5200 }
5201
5202 TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
5203   Message msg;
5204   Base a(1);
5205
5206   msg << a << &a;  // Uses ::operator<<.
5207   EXPECT_STREQ("1(1)", msg.GetString().c_str());
5208 }
5209
5210 // Tests streaming a user type whose definition and operator<< are
5211 // both in an unnamed namespace.
5212 namespace {
5213 class MyTypeInUnnamedNameSpace : public Base {
5214  public:
5215   explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {}
5216 };
5217 std::ostream& operator<<(std::ostream& os,
5218                          const MyTypeInUnnamedNameSpace& val) {
5219   return os << val.x();
5220 }
5221 std::ostream& operator<<(std::ostream& os,
5222                          const MyTypeInUnnamedNameSpace* pointer) {
5223   return os << "(" << pointer->x() << ")";
5224 }
5225 }  // namespace
5226
5227 TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
5228   Message msg;
5229   MyTypeInUnnamedNameSpace a(1);
5230
5231   msg << a << &a;  // Uses <unnamed_namespace>::operator<<.
5232   EXPECT_STREQ("1(1)", msg.GetString().c_str());
5233 }
5234
5235 // Tests streaming a user type whose definition and operator<< are
5236 // both in a user namespace.
5237 namespace namespace1 {
5238 class MyTypeInNameSpace1 : public Base {
5239  public:
5240   explicit MyTypeInNameSpace1(int an_x): Base(an_x) {}
5241 };
5242 std::ostream& operator<<(std::ostream& os,
5243                          const MyTypeInNameSpace1& val) {
5244   return os << val.x();
5245 }
5246 std::ostream& operator<<(std::ostream& os,
5247                          const MyTypeInNameSpace1* pointer) {
5248   return os << "(" << pointer->x() << ")";
5249 }
5250 }  // namespace namespace1
5251
5252 TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
5253   Message msg;
5254   namespace1::MyTypeInNameSpace1 a(1);
5255
5256   msg << a << &a;  // Uses namespace1::operator<<.
5257   EXPECT_STREQ("1(1)", msg.GetString().c_str());
5258 }
5259
5260 // Tests streaming a user type whose definition is in a user namespace
5261 // but whose operator<< is in the global namespace.
5262 namespace namespace2 {
5263 class MyTypeInNameSpace2 : public ::Base {
5264  public:
5265   explicit MyTypeInNameSpace2(int an_x): Base(an_x) {}
5266 };
5267 }  // namespace namespace2
5268 std::ostream& operator<<(std::ostream& os,
5269                          const namespace2::MyTypeInNameSpace2& val) {
5270   return os << val.x();
5271 }
5272 std::ostream& operator<<(std::ostream& os,
5273                          const namespace2::MyTypeInNameSpace2* pointer) {
5274   return os << "(" << pointer->x() << ")";
5275 }
5276
5277 TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) {
5278   Message msg;
5279   namespace2::MyTypeInNameSpace2 a(1);
5280
5281   msg << a << &a;  // Uses ::operator<<.
5282   EXPECT_STREQ("1(1)", msg.GetString().c_str());
5283 }
5284
5285 // Tests streaming NULL pointers to testing::Message.
5286 TEST(MessageTest, NullPointers) {
5287   Message msg;
5288   char* const p1 = NULL;
5289   unsigned char* const p2 = NULL;
5290   int* p3 = NULL;
5291   double* p4 = NULL;
5292   bool* p5 = NULL;
5293   Message* p6 = NULL;
5294
5295   msg << p1 << p2 << p3 << p4 << p5 << p6;
5296   ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
5297                msg.GetString().c_str());
5298 }
5299
5300 // Tests streaming wide strings to testing::Message.
5301 TEST(MessageTest, WideStrings) {
5302   // Streams a NULL of type const wchar_t*.
5303   const wchar_t* const_wstr = NULL;
5304   EXPECT_STREQ("(null)",
5305                (Message() << const_wstr).GetString().c_str());
5306
5307   // Streams a NULL of type wchar_t*.
5308   wchar_t* wstr = NULL;
5309   EXPECT_STREQ("(null)",
5310                (Message() << wstr).GetString().c_str());
5311
5312   // Streams a non-NULL of type const wchar_t*.
5313   const_wstr = L"abc\x8119";
5314   EXPECT_STREQ("abc\xe8\x84\x99",
5315                (Message() << const_wstr).GetString().c_str());
5316
5317   // Streams a non-NULL of type wchar_t*.
5318   wstr = const_cast<wchar_t*>(const_wstr);
5319   EXPECT_STREQ("abc\xe8\x84\x99",
5320                (Message() << wstr).GetString().c_str());
5321 }
5322
5323
5324 // This line tests that we can define tests in the testing namespace.
5325 namespace testing {
5326
5327 // Tests the TestInfo class.
5328
5329 class TestInfoTest : public Test {
5330  protected:
5331   static const TestInfo* GetTestInfo(const char* test_name) {
5332     const TestCase* const test_case = GetUnitTestImpl()->
5333         GetTestCase("TestInfoTest", "", NULL, NULL);
5334
5335     for (int i = 0; i < test_case->total_test_count(); ++i) {
5336       const TestInfo* const test_info = test_case->GetTestInfo(i);
5337       if (strcmp(test_name, test_info->name()) == 0)
5338         return test_info;
5339     }
5340     return NULL;
5341   }
5342
5343   static const TestResult* GetTestResult(
5344       const TestInfo* test_info) {
5345     return test_info->result();
5346   }
5347 };
5348
5349 // Tests TestInfo::test_case_name() and TestInfo::name().
5350 TEST_F(TestInfoTest, Names) {
5351   const TestInfo* const test_info = GetTestInfo("Names");
5352
5353   ASSERT_STREQ("TestInfoTest", test_info->test_case_name());
5354   ASSERT_STREQ("Names", test_info->name());
5355 }
5356
5357 // Tests TestInfo::result().
5358 TEST_F(TestInfoTest, result) {
5359   const TestInfo* const test_info = GetTestInfo("result");
5360
5361   // Initially, there is no TestPartResult for this test.
5362   ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
5363
5364   // After the previous assertion, there is still none.
5365   ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
5366 }
5367
5368 #define VERIFY_CODE_LOCATION \
5369   const int expected_line = __LINE__ - 1; \
5370   const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \
5371   ASSERT_TRUE(test_info); \
5372   EXPECT_STREQ(__FILE__, test_info->file()); \
5373   EXPECT_EQ(expected_line, test_info->line())
5374
5375 TEST(CodeLocationForTEST, Verify) {
5376   VERIFY_CODE_LOCATION;
5377 }
5378
5379 class CodeLocationForTESTF : public Test {
5380 };
5381
5382 TEST_F(CodeLocationForTESTF, Verify) {
5383   VERIFY_CODE_LOCATION;
5384 }
5385
5386 class CodeLocationForTESTP : public TestWithParam<int> {
5387 };
5388
5389 TEST_P(CodeLocationForTESTP, Verify) {
5390   VERIFY_CODE_LOCATION;
5391 }
5392
5393 INSTANTIATE_TEST_CASE_P(, CodeLocationForTESTP, Values(0));
5394
5395 template <typename T>
5396 class CodeLocationForTYPEDTEST : public Test {
5397 };
5398
5399 TYPED_TEST_CASE(CodeLocationForTYPEDTEST, int);
5400
5401 TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
5402   VERIFY_CODE_LOCATION;
5403 }
5404
5405 template <typename T>
5406 class CodeLocationForTYPEDTESTP : public Test {
5407 };
5408
5409 TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP);
5410
5411 TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) {
5412   VERIFY_CODE_LOCATION;
5413 }
5414
5415 REGISTER_TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP, Verify);
5416
5417 INSTANTIATE_TYPED_TEST_CASE_P(My, CodeLocationForTYPEDTESTP, int);
5418
5419 #undef VERIFY_CODE_LOCATION
5420
5421 // Tests setting up and tearing down a test case.
5422
5423 class SetUpTestCaseTest : public Test {
5424  protected:
5425   // This will be called once before the first test in this test case
5426   // is run.
5427   static void SetUpTestCase() {
5428     printf("Setting up the test case . . .\n");
5429
5430     // Initializes some shared resource.  In this simple example, we
5431     // just create a C string.  More complex stuff can be done if
5432     // desired.
5433     shared_resource_ = "123";
5434
5435     // Increments the number of test cases that have been set up.
5436     counter_++;
5437
5438     // SetUpTestCase() should be called only once.
5439     EXPECT_EQ(1, counter_);
5440   }
5441
5442   // This will be called once after the last test in this test case is
5443   // run.
5444   static void TearDownTestCase() {
5445     printf("Tearing down the test case . . .\n");
5446
5447     // Decrements the number of test cases that have been set up.
5448     counter_--;
5449
5450     // TearDownTestCase() should be called only once.
5451     EXPECT_EQ(0, counter_);
5452
5453     // Cleans up the shared resource.
5454     shared_resource_ = NULL;
5455   }
5456
5457   // This will be called before each test in this test case.
5458   virtual void SetUp() {
5459     // SetUpTestCase() should be called only once, so counter_ should
5460     // always be 1.
5461     EXPECT_EQ(1, counter_);
5462   }
5463
5464   // Number of test cases that have been set up.
5465   static int counter_;
5466
5467   // Some resource to be shared by all tests in this test case.
5468   static const char* shared_resource_;
5469 };
5470
5471 int SetUpTestCaseTest::counter_ = 0;
5472 const char* SetUpTestCaseTest::shared_resource_ = NULL;
5473
5474 // A test that uses the shared resource.
5475 TEST_F(SetUpTestCaseTest, Test1) {
5476   EXPECT_STRNE(NULL, shared_resource_);
5477 }
5478
5479 // Another test that uses the shared resource.
5480 TEST_F(SetUpTestCaseTest, Test2) {
5481   EXPECT_STREQ("123", shared_resource_);
5482 }
5483
5484
5485 // The ParseFlagsTest test case tests ParseGoogleTestFlagsOnly.
5486
5487 // The Flags struct stores a copy of all Google Test flags.
5488 struct Flags {
5489   // Constructs a Flags struct where each flag has its default value.
5490   Flags() : also_run_disabled_tests(false),
5491             break_on_failure(false),
5492             catch_exceptions(false),
5493             death_test_use_fork(false),
5494             filter(""),
5495             list_tests(false),
5496             output(""),
5497             print_time(true),
5498             random_seed(0),
5499             repeat(1),
5500             shuffle(false),
5501             stack_trace_depth(kMaxStackTraceDepth),
5502             stream_result_to(""),
5503             throw_on_failure(false) {}
5504
5505   // Factory methods.
5506
5507   // Creates a Flags struct where the gtest_also_run_disabled_tests flag has
5508   // the given value.
5509   static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
5510     Flags flags;
5511     flags.also_run_disabled_tests = also_run_disabled_tests;
5512     return flags;
5513   }
5514
5515   // Creates a Flags struct where the gtest_break_on_failure flag has
5516   // the given value.
5517   static Flags BreakOnFailure(bool break_on_failure) {
5518     Flags flags;
5519     flags.break_on_failure = break_on_failure;
5520     return flags;
5521   }
5522
5523   // Creates a Flags struct where the gtest_catch_exceptions flag has
5524   // the given value.
5525   static Flags CatchExceptions(bool catch_exceptions) {
5526     Flags flags;
5527     flags.catch_exceptions = catch_exceptions;
5528     return flags;
5529   }
5530
5531   // Creates a Flags struct where the gtest_death_test_use_fork flag has
5532   // the given value.
5533   static Flags DeathTestUseFork(bool death_test_use_fork) {
5534     Flags flags;
5535     flags.death_test_use_fork = death_test_use_fork;
5536     return flags;
5537   }
5538
5539   // Creates a Flags struct where the gtest_filter flag has the given
5540   // value.
5541   static Flags Filter(const char* filter) {
5542     Flags flags;
5543     flags.filter = filter;
5544     return flags;
5545   }
5546
5547   // Creates a Flags struct where the gtest_list_tests flag has the
5548   // given value.
5549   static Flags ListTests(bool list_tests) {
5550     Flags flags;
5551     flags.list_tests = list_tests;
5552     return flags;
5553   }
5554
5555   // Creates a Flags struct where the gtest_output flag has the given
5556   // value.
5557   static Flags Output(const char* output) {
5558     Flags flags;
5559     flags.output = output;
5560     return flags;
5561   }
5562
5563   // Creates a Flags struct where the gtest_print_time flag has the given
5564   // value.
5565   static Flags PrintTime(bool print_time) {
5566     Flags flags;
5567     flags.print_time = print_time;
5568     return flags;
5569   }
5570
5571   // Creates a Flags struct where the gtest_random_seed flag has the given
5572   // value.
5573   static Flags RandomSeed(Int32 random_seed) {
5574     Flags flags;
5575     flags.random_seed = random_seed;
5576     return flags;
5577   }
5578
5579   // Creates a Flags struct where the gtest_repeat flag has the given
5580   // value.
5581   static Flags Repeat(Int32 repeat) {
5582     Flags flags;
5583     flags.repeat = repeat;
5584     return flags;
5585   }
5586
5587   // Creates a Flags struct where the gtest_shuffle flag has the given
5588   // value.
5589   static Flags Shuffle(bool shuffle) {
5590     Flags flags;
5591     flags.shuffle = shuffle;
5592     return flags;
5593   }
5594
5595   // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has
5596   // the given value.
5597   static Flags StackTraceDepth(Int32 stack_trace_depth) {
5598     Flags flags;
5599     flags.stack_trace_depth = stack_trace_depth;
5600     return flags;
5601   }
5602
5603   // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has
5604   // the given value.
5605   static Flags StreamResultTo(const char* stream_result_to) {
5606     Flags flags;
5607     flags.stream_result_to = stream_result_to;
5608     return flags;
5609   }
5610
5611   // Creates a Flags struct where the gtest_throw_on_failure flag has
5612   // the given value.
5613   static Flags ThrowOnFailure(bool throw_on_failure) {
5614     Flags flags;
5615     flags.throw_on_failure = throw_on_failure;
5616     return flags;
5617   }
5618
5619   // These fields store the flag values.
5620   bool also_run_disabled_tests;
5621   bool break_on_failure;
5622   bool catch_exceptions;
5623   bool death_test_use_fork;
5624   const char* filter;
5625   bool list_tests;
5626   const char* output;
5627   bool print_time;
5628   Int32 random_seed;
5629   Int32 repeat;
5630   bool shuffle;
5631   Int32 stack_trace_depth;
5632   const char* stream_result_to;
5633   bool throw_on_failure;
5634 };
5635
5636 // Fixture for testing ParseGoogleTestFlagsOnly().
5637 class ParseFlagsTest : public Test {
5638  protected:
5639   // Clears the flags before each test.
5640   virtual void SetUp() {
5641     GTEST_FLAG(also_run_disabled_tests) = false;
5642     GTEST_FLAG(break_on_failure) = false;
5643     GTEST_FLAG(catch_exceptions) = false;
5644     GTEST_FLAG(death_test_use_fork) = false;
5645     GTEST_FLAG(filter) = "";
5646     GTEST_FLAG(list_tests) = false;
5647     GTEST_FLAG(output) = "";
5648     GTEST_FLAG(print_time) = true;
5649     GTEST_FLAG(random_seed) = 0;
5650     GTEST_FLAG(repeat) = 1;
5651     GTEST_FLAG(shuffle) = false;
5652     GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
5653     GTEST_FLAG(stream_result_to) = "";
5654     GTEST_FLAG(throw_on_failure) = false;
5655   }
5656
5657   // Asserts that two narrow or wide string arrays are equal.
5658   template <typename CharType>
5659   static void AssertStringArrayEq(size_t size1, CharType** array1,
5660                                   size_t size2, CharType** array2) {
5661     ASSERT_EQ(size1, size2) << " Array sizes different.";
5662
5663     for (size_t i = 0; i != size1; i++) {
5664       ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;
5665     }
5666   }
5667
5668   // Verifies that the flag values match the expected values.
5669   static void CheckFlags(const Flags& expected) {
5670     EXPECT_EQ(expected.also_run_disabled_tests,
5671               GTEST_FLAG(also_run_disabled_tests));
5672     EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
5673     EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
5674     EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
5675     EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
5676     EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
5677     EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
5678     EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
5679     EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
5680     EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
5681     EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
5682     EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
5683     EXPECT_STREQ(expected.stream_result_to,
5684                  GTEST_FLAG(stream_result_to).c_str());
5685     EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
5686   }
5687
5688   // Parses a command line (specified by argc1 and argv1), then
5689   // verifies that the flag values are expected and that the
5690   // recognized flags are removed from the command line.
5691   template <typename CharType>
5692   static void TestParsingFlags(int argc1, const CharType** argv1,
5693                                int argc2, const CharType** argv2,
5694                                const Flags& expected, bool should_print_help) {
5695     const bool saved_help_flag = ::testing::internal::g_help_flag;
5696     ::testing::internal::g_help_flag = false;
5697
5698 # if GTEST_HAS_STREAM_REDIRECTION
5699     CaptureStdout();
5700 # endif
5701
5702     // Parses the command line.
5703     internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
5704
5705 # if GTEST_HAS_STREAM_REDIRECTION
5706     const std::string captured_stdout = GetCapturedStdout();
5707 # endif
5708
5709     // Verifies the flag values.
5710     CheckFlags(expected);
5711
5712     // Verifies that the recognized flags are removed from the command
5713     // line.
5714     AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
5715
5716     // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the
5717     // help message for the flags it recognizes.
5718     EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
5719
5720 # if GTEST_HAS_STREAM_REDIRECTION
5721     const char* const expected_help_fragment =
5722         "This program contains tests written using";
5723     if (should_print_help) {
5724       EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
5725     } else {
5726       EXPECT_PRED_FORMAT2(IsNotSubstring,
5727                           expected_help_fragment, captured_stdout);
5728     }
5729 # endif  // GTEST_HAS_STREAM_REDIRECTION
5730
5731     ::testing::internal::g_help_flag = saved_help_flag;
5732   }
5733
5734   // This macro wraps TestParsingFlags s.t. the user doesn't need
5735   // to specify the array sizes.
5736
5737 # define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
5738   TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
5739                    sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
5740                    expected, should_print_help)
5741 };
5742
5743 // Tests parsing an empty command line.
5744 TEST_F(ParseFlagsTest, Empty) {
5745   const char* argv[] = {
5746     NULL
5747   };
5748
5749   const char* argv2[] = {
5750     NULL
5751   };
5752
5753   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
5754 }
5755
5756 // Tests parsing a command line that has no flag.
5757 TEST_F(ParseFlagsTest, NoFlag) {
5758   const char* argv[] = {
5759     "foo.exe",
5760     NULL
5761   };
5762
5763   const char* argv2[] = {
5764     "foo.exe",
5765     NULL
5766   };
5767
5768   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
5769 }
5770
5771 // Tests parsing a bad --gtest_filter flag.
5772 TEST_F(ParseFlagsTest, FilterBad) {
5773   const char* argv[] = {
5774     "foo.exe",
5775     "--gtest_filter",
5776     NULL
5777   };
5778
5779   const char* argv2[] = {
5780     "foo.exe",
5781     "--gtest_filter",
5782     NULL
5783   };
5784
5785   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
5786 }
5787
5788 // Tests parsing an empty --gtest_filter flag.
5789 TEST_F(ParseFlagsTest, FilterEmpty) {
5790   const char* argv[] = {
5791     "foo.exe",
5792     "--gtest_filter=",
5793     NULL
5794   };
5795
5796   const char* argv2[] = {
5797     "foo.exe",
5798     NULL
5799   };
5800
5801   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
5802 }
5803
5804 // Tests parsing a non-empty --gtest_filter flag.
5805 TEST_F(ParseFlagsTest, FilterNonEmpty) {
5806   const char* argv[] = {
5807     "foo.exe",
5808     "--gtest_filter=abc",
5809     NULL
5810   };
5811
5812   const char* argv2[] = {
5813     "foo.exe",
5814     NULL
5815   };
5816
5817   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
5818 }
5819
5820 // Tests parsing --gtest_break_on_failure.
5821 TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
5822   const char* argv[] = {
5823     "foo.exe",
5824     "--gtest_break_on_failure",
5825     NULL
5826 };
5827
5828   const char* argv2[] = {
5829     "foo.exe",
5830     NULL
5831   };
5832
5833   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
5834 }
5835
5836 // Tests parsing --gtest_break_on_failure=0.
5837 TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
5838   const char* argv[] = {
5839     "foo.exe",
5840     "--gtest_break_on_failure=0",
5841     NULL
5842   };
5843
5844   const char* argv2[] = {
5845     "foo.exe",
5846     NULL
5847   };
5848
5849   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
5850 }
5851
5852 // Tests parsing --gtest_break_on_failure=f.
5853 TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
5854   const char* argv[] = {
5855     "foo.exe",
5856     "--gtest_break_on_failure=f",
5857     NULL
5858   };
5859
5860   const char* argv2[] = {
5861     "foo.exe",
5862     NULL
5863   };
5864
5865   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
5866 }
5867
5868 // Tests parsing --gtest_break_on_failure=F.
5869 TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
5870   const char* argv[] = {
5871     "foo.exe",
5872     "--gtest_break_on_failure=F",
5873     NULL
5874   };
5875
5876   const char* argv2[] = {
5877     "foo.exe",
5878     NULL
5879   };
5880
5881   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
5882 }
5883
5884 // Tests parsing a --gtest_break_on_failure flag that has a "true"
5885 // definition.
5886 TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
5887   const char* argv[] = {
5888     "foo.exe",
5889     "--gtest_break_on_failure=1",
5890     NULL
5891   };
5892
5893   const char* argv2[] = {
5894     "foo.exe",
5895     NULL
5896   };
5897
5898   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
5899 }
5900
5901 // Tests parsing --gtest_catch_exceptions.
5902 TEST_F(ParseFlagsTest, CatchExceptions) {
5903   const char* argv[] = {
5904     "foo.exe",
5905     "--gtest_catch_exceptions",
5906     NULL
5907   };
5908
5909   const char* argv2[] = {
5910     "foo.exe",
5911     NULL
5912   };
5913
5914   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
5915 }
5916
5917 // Tests parsing --gtest_death_test_use_fork.
5918 TEST_F(ParseFlagsTest, DeathTestUseFork) {
5919   const char* argv[] = {
5920     "foo.exe",
5921     "--gtest_death_test_use_fork",
5922     NULL
5923   };
5924
5925   const char* argv2[] = {
5926     "foo.exe",
5927     NULL
5928   };
5929
5930   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false);
5931 }
5932
5933 // Tests having the same flag twice with different values.  The
5934 // expected behavior is that the one coming last takes precedence.
5935 TEST_F(ParseFlagsTest, DuplicatedFlags) {
5936   const char* argv[] = {
5937     "foo.exe",
5938     "--gtest_filter=a",
5939     "--gtest_filter=b",
5940     NULL
5941   };
5942
5943   const char* argv2[] = {
5944     "foo.exe",
5945     NULL
5946   };
5947
5948   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false);
5949 }
5950
5951 // Tests having an unrecognized flag on the command line.
5952 TEST_F(ParseFlagsTest, UnrecognizedFlag) {
5953   const char* argv[] = {
5954     "foo.exe",
5955     "--gtest_break_on_failure",
5956     "bar",  // Unrecognized by Google Test.
5957     "--gtest_filter=b",
5958     NULL
5959   };
5960
5961   const char* argv2[] = {
5962     "foo.exe",
5963     "bar",
5964     NULL
5965   };
5966
5967   Flags flags;
5968   flags.break_on_failure = true;
5969   flags.filter = "b";
5970   GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
5971 }
5972
5973 // Tests having a --gtest_list_tests flag
5974 TEST_F(ParseFlagsTest, ListTestsFlag) {
5975     const char* argv[] = {
5976       "foo.exe",
5977       "--gtest_list_tests",
5978       NULL
5979     };
5980
5981     const char* argv2[] = {
5982       "foo.exe",
5983       NULL
5984     };
5985
5986     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
5987 }
5988
5989 // Tests having a --gtest_list_tests flag with a "true" value
5990 TEST_F(ParseFlagsTest, ListTestsTrue) {
5991     const char* argv[] = {
5992       "foo.exe",
5993       "--gtest_list_tests=1",
5994       NULL
5995     };
5996
5997     const char* argv2[] = {
5998       "foo.exe",
5999       NULL
6000     };
6001
6002     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
6003 }
6004
6005 // Tests having a --gtest_list_tests flag with a "false" value
6006 TEST_F(ParseFlagsTest, ListTestsFalse) {
6007     const char* argv[] = {
6008       "foo.exe",
6009       "--gtest_list_tests=0",
6010       NULL
6011     };
6012
6013     const char* argv2[] = {
6014       "foo.exe",
6015       NULL
6016     };
6017
6018     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
6019 }
6020
6021 // Tests parsing --gtest_list_tests=f.
6022 TEST_F(ParseFlagsTest, ListTestsFalse_f) {
6023   const char* argv[] = {
6024     "foo.exe",
6025     "--gtest_list_tests=f",
6026     NULL
6027   };
6028
6029   const char* argv2[] = {
6030     "foo.exe",
6031     NULL
6032   };
6033
6034   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
6035 }
6036
6037 // Tests parsing --gtest_list_tests=F.
6038 TEST_F(ParseFlagsTest, ListTestsFalse_F) {
6039   const char* argv[] = {
6040     "foo.exe",
6041     "--gtest_list_tests=F",
6042     NULL
6043   };
6044
6045   const char* argv2[] = {
6046     "foo.exe",
6047     NULL
6048   };
6049
6050   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
6051 }
6052
6053 // Tests parsing --gtest_output (invalid).
6054 TEST_F(ParseFlagsTest, OutputEmpty) {
6055   const char* argv[] = {
6056     "foo.exe",
6057     "--gtest_output",
6058     NULL
6059   };
6060
6061   const char* argv2[] = {
6062     "foo.exe",
6063     "--gtest_output",
6064     NULL
6065   };
6066
6067   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
6068 }
6069
6070 // Tests parsing --gtest_output=xml
6071 TEST_F(ParseFlagsTest, OutputXml) {
6072   const char* argv[] = {
6073     "foo.exe",
6074     "--gtest_output=xml",
6075     NULL
6076   };
6077
6078   const char* argv2[] = {
6079     "foo.exe",
6080     NULL
6081   };
6082
6083   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
6084 }
6085
6086 // Tests parsing --gtest_output=xml:file
6087 TEST_F(ParseFlagsTest, OutputXmlFile) {
6088   const char* argv[] = {
6089     "foo.exe",
6090     "--gtest_output=xml:file",
6091     NULL
6092   };
6093
6094   const char* argv2[] = {
6095     "foo.exe",
6096     NULL
6097   };
6098
6099   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
6100 }
6101
6102 // Tests parsing --gtest_output=xml:directory/path/
6103 TEST_F(ParseFlagsTest, OutputXmlDirectory) {
6104   const char* argv[] = {
6105     "foo.exe",
6106     "--gtest_output=xml:directory/path/",
6107     NULL
6108   };
6109
6110   const char* argv2[] = {
6111     "foo.exe",
6112     NULL
6113   };
6114
6115   GTEST_TEST_PARSING_FLAGS_(argv, argv2,
6116                             Flags::Output("xml:directory/path/"), false);
6117 }
6118
6119 // Tests having a --gtest_print_time flag
6120 TEST_F(ParseFlagsTest, PrintTimeFlag) {
6121     const char* argv[] = {
6122       "foo.exe",
6123       "--gtest_print_time",
6124       NULL
6125     };
6126
6127     const char* argv2[] = {
6128       "foo.exe",
6129       NULL
6130     };
6131
6132     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
6133 }
6134
6135 // Tests having a --gtest_print_time flag with a "true" value
6136 TEST_F(ParseFlagsTest, PrintTimeTrue) {
6137     const char* argv[] = {
6138       "foo.exe",
6139       "--gtest_print_time=1",
6140       NULL
6141     };
6142
6143     const char* argv2[] = {
6144       "foo.exe",
6145       NULL
6146     };
6147
6148     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
6149 }
6150
6151 // Tests having a --gtest_print_time flag with a "false" value
6152 TEST_F(ParseFlagsTest, PrintTimeFalse) {
6153     const char* argv[] = {
6154       "foo.exe",
6155       "--gtest_print_time=0",
6156       NULL
6157     };
6158
6159     const char* argv2[] = {
6160       "foo.exe",
6161       NULL
6162     };
6163
6164     GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
6165 }
6166
6167 // Tests parsing --gtest_print_time=f.
6168 TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
6169   const char* argv[] = {
6170     "foo.exe",
6171     "--gtest_print_time=f",
6172     NULL
6173   };
6174
6175   const char* argv2[] = {
6176     "foo.exe",
6177     NULL
6178   };
6179
6180   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
6181 }
6182
6183 // Tests parsing --gtest_print_time=F.
6184 TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
6185   const char* argv[] = {
6186     "foo.exe",
6187     "--gtest_print_time=F",
6188     NULL
6189   };
6190
6191   const char* argv2[] = {
6192     "foo.exe",
6193     NULL
6194   };
6195
6196   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
6197 }
6198
6199 // Tests parsing --gtest_random_seed=number
6200 TEST_F(ParseFlagsTest, RandomSeed) {
6201   const char* argv[] = {
6202     "foo.exe",
6203     "--gtest_random_seed=1000",
6204     NULL
6205   };
6206
6207   const char* argv2[] = {
6208     "foo.exe",
6209     NULL
6210   };
6211
6212   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
6213 }
6214
6215 // Tests parsing --gtest_repeat=number
6216 TEST_F(ParseFlagsTest, Repeat) {
6217   const char* argv[] = {
6218     "foo.exe",
6219     "--gtest_repeat=1000",
6220     NULL
6221   };
6222
6223   const char* argv2[] = {
6224     "foo.exe",
6225     NULL
6226   };
6227
6228   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
6229 }
6230
6231 // Tests having a --gtest_also_run_disabled_tests flag
6232 TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
6233     const char* argv[] = {
6234       "foo.exe",
6235       "--gtest_also_run_disabled_tests",
6236       NULL
6237     };
6238
6239     const char* argv2[] = {
6240       "foo.exe",
6241       NULL
6242     };
6243
6244     GTEST_TEST_PARSING_FLAGS_(argv, argv2,
6245                               Flags::AlsoRunDisabledTests(true), false);
6246 }
6247
6248 // Tests having a --gtest_also_run_disabled_tests flag with a "true" value
6249 TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
6250     const char* argv[] = {
6251       "foo.exe",
6252       "--gtest_also_run_disabled_tests=1",
6253       NULL
6254     };
6255
6256     const char* argv2[] = {
6257       "foo.exe",
6258       NULL
6259     };
6260
6261     GTEST_TEST_PARSING_FLAGS_(argv, argv2,
6262                               Flags::AlsoRunDisabledTests(true), false);
6263 }
6264
6265 // Tests having a --gtest_also_run_disabled_tests flag with a "false" value
6266 TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
6267     const char* argv[] = {
6268       "foo.exe",
6269       "--gtest_also_run_disabled_tests=0",
6270       NULL
6271     };
6272
6273     const char* argv2[] = {
6274       "foo.exe",
6275       NULL
6276     };
6277
6278     GTEST_TEST_PARSING_FLAGS_(argv, argv2,
6279                               Flags::AlsoRunDisabledTests(false), false);
6280 }
6281
6282 // Tests parsing --gtest_shuffle.
6283 TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
6284   const char* argv[] = {
6285     "foo.exe",
6286     "--gtest_shuffle",
6287     NULL
6288 };
6289
6290   const char* argv2[] = {
6291     "foo.exe",
6292     NULL
6293   };
6294
6295   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
6296 }
6297
6298 // Tests parsing --gtest_shuffle=0.
6299 TEST_F(ParseFlagsTest, ShuffleFalse_0) {
6300   const char* argv[] = {
6301     "foo.exe",
6302     "--gtest_shuffle=0",
6303     NULL
6304   };
6305
6306   const char* argv2[] = {
6307     "foo.exe",
6308     NULL
6309   };
6310
6311   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
6312 }
6313
6314 // Tests parsing a --gtest_shuffle flag that has a "true" definition.
6315 TEST_F(ParseFlagsTest, ShuffleTrue) {
6316   const char* argv[] = {
6317     "foo.exe",
6318     "--gtest_shuffle=1",
6319     NULL
6320   };
6321
6322   const char* argv2[] = {
6323     "foo.exe",
6324     NULL
6325   };
6326
6327   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
6328 }
6329
6330 // Tests parsing --gtest_stack_trace_depth=number.
6331 TEST_F(ParseFlagsTest, StackTraceDepth) {
6332   const char* argv[] = {
6333     "foo.exe",
6334     "--gtest_stack_trace_depth=5",
6335     NULL
6336   };
6337
6338   const char* argv2[] = {
6339     "foo.exe",
6340     NULL
6341   };
6342
6343   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
6344 }
6345
6346 TEST_F(ParseFlagsTest, StreamResultTo) {
6347   const char* argv[] = {
6348     "foo.exe",
6349     "--gtest_stream_result_to=localhost:1234",
6350     NULL
6351   };
6352
6353   const char* argv2[] = {
6354     "foo.exe",
6355     NULL
6356   };
6357
6358   GTEST_TEST_PARSING_FLAGS_(
6359       argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
6360 }
6361
6362 // Tests parsing --gtest_throw_on_failure.
6363 TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
6364   const char* argv[] = {
6365     "foo.exe",
6366     "--gtest_throw_on_failure",
6367     NULL
6368 };
6369
6370   const char* argv2[] = {
6371     "foo.exe",
6372     NULL
6373   };
6374
6375   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
6376 }
6377
6378 // Tests parsing --gtest_throw_on_failure=0.
6379 TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
6380   const char* argv[] = {
6381     "foo.exe",
6382     "--gtest_throw_on_failure=0",
6383     NULL
6384   };
6385
6386   const char* argv2[] = {
6387     "foo.exe",
6388     NULL
6389   };
6390
6391   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
6392 }
6393
6394 // Tests parsing a --gtest_throw_on_failure flag that has a "true"
6395 // definition.
6396 TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
6397   const char* argv[] = {
6398     "foo.exe",
6399     "--gtest_throw_on_failure=1",
6400     NULL
6401   };
6402
6403   const char* argv2[] = {
6404     "foo.exe",
6405     NULL
6406   };
6407
6408   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
6409 }
6410
6411 # if GTEST_OS_WINDOWS
6412 // Tests parsing wide strings.
6413 TEST_F(ParseFlagsTest, WideStrings) {
6414   const wchar_t* argv[] = {
6415     L"foo.exe",
6416     L"--gtest_filter=Foo*",
6417     L"--gtest_list_tests=1",
6418     L"--gtest_break_on_failure",
6419     L"--non_gtest_flag",
6420     NULL
6421   };
6422
6423   const wchar_t* argv2[] = {
6424     L"foo.exe",
6425     L"--non_gtest_flag",
6426     NULL
6427   };
6428
6429   Flags expected_flags;
6430   expected_flags.break_on_failure = true;
6431   expected_flags.filter = "Foo*";
6432   expected_flags.list_tests = true;
6433
6434   GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
6435 }
6436 # endif  // GTEST_OS_WINDOWS
6437
6438 #if GTEST_USE_OWN_FLAGFILE_FLAG_
6439 class FlagfileTest : public ParseFlagsTest {
6440  public:
6441   virtual void SetUp() {
6442     ParseFlagsTest::SetUp();
6443
6444     testdata_path_.Set(internal::FilePath(
6445         testing::TempDir() + internal::GetCurrentExecutableName().string() +
6446         "_flagfile_test"));
6447     testing::internal::posix::RmDir(testdata_path_.c_str());
6448     EXPECT_TRUE(testdata_path_.CreateFolder());
6449   }
6450
6451   virtual void TearDown() {
6452     testing::internal::posix::RmDir(testdata_path_.c_str());
6453     ParseFlagsTest::TearDown();
6454   }
6455
6456   internal::FilePath CreateFlagfile(const char* contents) {
6457     internal::FilePath file_path(internal::FilePath::GenerateUniqueFileName(
6458         testdata_path_, internal::FilePath("unique"), "txt"));
6459     FILE* f = testing::internal::posix::FOpen(file_path.c_str(), "w");
6460     fprintf(f, "%s", contents);
6461     fclose(f);
6462     return file_path;
6463   }
6464
6465  private:
6466   internal::FilePath testdata_path_;
6467 };
6468
6469 // Tests an empty flagfile.
6470 TEST_F(FlagfileTest, Empty) {
6471   internal::FilePath flagfile_path(CreateFlagfile(""));
6472   std::string flagfile_flag =
6473       std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
6474
6475   const char* argv[] = {
6476     "foo.exe",
6477     flagfile_flag.c_str(),
6478     NULL
6479   };
6480
6481   const char* argv2[] = {
6482     "foo.exe",
6483     NULL
6484   };
6485
6486   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
6487 }
6488
6489 // Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
6490 TEST_F(FlagfileTest, FilterNonEmpty) {
6491   internal::FilePath flagfile_path(CreateFlagfile(
6492       "--"  GTEST_FLAG_PREFIX_  "filter=abc"));
6493   std::string flagfile_flag =
6494       std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
6495
6496   const char* argv[] = {
6497     "foo.exe",
6498     flagfile_flag.c_str(),
6499     NULL
6500   };
6501
6502   const char* argv2[] = {
6503     "foo.exe",
6504     NULL
6505   };
6506
6507   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
6508 }
6509
6510 // Tests passing several flags via --gtest_flagfile.
6511 TEST_F(FlagfileTest, SeveralFlags) {
6512   internal::FilePath flagfile_path(CreateFlagfile(
6513       "--"  GTEST_FLAG_PREFIX_  "filter=abc\n"
6514       "--"  GTEST_FLAG_PREFIX_  "break_on_failure\n"
6515       "--"  GTEST_FLAG_PREFIX_  "list_tests"));
6516   std::string flagfile_flag =
6517       std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
6518
6519   const char* argv[] = {
6520     "foo.exe",
6521     flagfile_flag.c_str(),
6522     NULL
6523   };
6524
6525   const char* argv2[] = {
6526     "foo.exe",
6527     NULL
6528   };
6529
6530   Flags expected_flags;
6531   expected_flags.break_on_failure = true;
6532   expected_flags.filter = "abc";
6533   expected_flags.list_tests = true;
6534
6535   GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
6536 }
6537 #endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
6538
6539 // Tests current_test_info() in UnitTest.
6540 class CurrentTestInfoTest : public Test {
6541  protected:
6542   // Tests that current_test_info() returns NULL before the first test in
6543   // the test case is run.
6544   static void SetUpTestCase() {
6545     // There should be no tests running at this point.
6546     const TestInfo* test_info =
6547       UnitTest::GetInstance()->current_test_info();
6548     EXPECT_TRUE(test_info == NULL)
6549         << "There should be no tests running at this point.";
6550   }
6551
6552   // Tests that current_test_info() returns NULL after the last test in
6553   // the test case has run.
6554   static void TearDownTestCase() {
6555     const TestInfo* test_info =
6556       UnitTest::GetInstance()->current_test_info();
6557     EXPECT_TRUE(test_info == NULL)
6558         << "There should be no tests running at this point.";
6559   }
6560 };
6561
6562 // Tests that current_test_info() returns TestInfo for currently running
6563 // test by checking the expected test name against the actual one.
6564 TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) {
6565   const TestInfo* test_info =
6566     UnitTest::GetInstance()->current_test_info();
6567   ASSERT_TRUE(NULL != test_info)
6568       << "There is a test running so we should have a valid TestInfo.";
6569   EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
6570       << "Expected the name of the currently running test case.";
6571   EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())
6572       << "Expected the name of the currently running test.";
6573 }
6574
6575 // Tests that current_test_info() returns TestInfo for currently running
6576 // test by checking the expected test name against the actual one.  We
6577 // use this test to see that the TestInfo object actually changed from
6578 // the previous invocation.
6579 TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {
6580   const TestInfo* test_info =
6581     UnitTest::GetInstance()->current_test_info();
6582   ASSERT_TRUE(NULL != test_info)
6583       << "There is a test running so we should have a valid TestInfo.";
6584   EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
6585       << "Expected the name of the currently running test case.";
6586   EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())
6587       << "Expected the name of the currently running test.";
6588 }
6589
6590 }  // namespace testing
6591
6592
6593 // These two lines test that we can define tests in a namespace that
6594 // has the name "testing" and is nested in another namespace.
6595 namespace my_namespace {
6596 namespace testing {
6597
6598 // Makes sure that TEST knows to use ::testing::Test instead of
6599 // ::my_namespace::testing::Test.
6600 class Test {};
6601
6602 // Makes sure that an assertion knows to use ::testing::Message instead of
6603 // ::my_namespace::testing::Message.
6604 class Message {};
6605
6606 // Makes sure that an assertion knows to use
6607 // ::testing::AssertionResult instead of
6608 // ::my_namespace::testing::AssertionResult.
6609 class AssertionResult {};
6610
6611 // Tests that an assertion that should succeed works as expected.
6612 TEST(NestedTestingNamespaceTest, Success) {
6613   EXPECT_EQ(1, 1) << "This shouldn't fail.";
6614 }
6615
6616 // Tests that an assertion that should fail works as expected.
6617 TEST(NestedTestingNamespaceTest, Failure) {
6618   EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.",
6619                        "This failure is expected.");
6620 }
6621
6622 }  // namespace testing
6623 }  // namespace my_namespace
6624
6625 // Tests that one can call superclass SetUp and TearDown methods--
6626 // that is, that they are not private.
6627 // No tests are based on this fixture; the test "passes" if it compiles
6628 // successfully.
6629 class ProtectedFixtureMethodsTest : public Test {
6630  protected:
6631   virtual void SetUp() {
6632     Test::SetUp();
6633   }
6634   virtual void TearDown() {
6635     Test::TearDown();
6636   }
6637 };
6638
6639 // StreamingAssertionsTest tests the streaming versions of a representative
6640 // sample of assertions.
6641 TEST(StreamingAssertionsTest, Unconditional) {
6642   SUCCEED() << "expected success";
6643   EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
6644                           "expected failure");
6645   EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
6646                        "expected failure");
6647 }
6648
6649 #ifdef __BORLANDC__
6650 // Silences warnings: "Condition is always true", "Unreachable code"
6651 # pragma option push -w-ccc -w-rch
6652 #endif
6653
6654 TEST(StreamingAssertionsTest, Truth) {
6655   EXPECT_TRUE(true) << "unexpected failure";
6656   ASSERT_TRUE(true) << "unexpected failure";
6657   EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",
6658                           "expected failure");
6659   EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",
6660                        "expected failure");
6661 }
6662
6663 TEST(StreamingAssertionsTest, Truth2) {
6664   EXPECT_FALSE(false) << "unexpected failure";
6665   ASSERT_FALSE(false) << "unexpected failure";
6666   EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",
6667                           "expected failure");
6668   EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",
6669                        "expected failure");
6670 }
6671
6672 #ifdef __BORLANDC__
6673 // Restores warnings after previous "#pragma option push" suppressed them
6674 # pragma option pop
6675 #endif
6676
6677 TEST(StreamingAssertionsTest, IntegerEquals) {
6678   EXPECT_EQ(1, 1) << "unexpected failure";
6679   ASSERT_EQ(1, 1) << "unexpected failure";
6680   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",
6681                           "expected failure");
6682   EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",
6683                        "expected failure");
6684 }
6685
6686 TEST(StreamingAssertionsTest, IntegerLessThan) {
6687   EXPECT_LT(1, 2) << "unexpected failure";
6688   ASSERT_LT(1, 2) << "unexpected failure";
6689   EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",
6690                           "expected failure");
6691   EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",
6692                        "expected failure");
6693 }
6694
6695 TEST(StreamingAssertionsTest, StringsEqual) {
6696   EXPECT_STREQ("foo", "foo") << "unexpected failure";
6697   ASSERT_STREQ("foo", "foo") << "unexpected failure";
6698   EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",
6699                           "expected failure");
6700   EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",
6701                        "expected failure");
6702 }
6703
6704 TEST(StreamingAssertionsTest, StringsNotEqual) {
6705   EXPECT_STRNE("foo", "bar") << "unexpected failure";
6706   ASSERT_STRNE("foo", "bar") << "unexpected failure";
6707   EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",
6708                           "expected failure");
6709   EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",
6710                        "expected failure");
6711 }
6712
6713 TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {
6714   EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";
6715   ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";
6716   EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",
6717                           "expected failure");
6718   EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",
6719                        "expected failure");
6720 }
6721
6722 TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {
6723   EXPECT_STRCASENE("foo", "bar") << "unexpected failure";
6724   ASSERT_STRCASENE("foo", "bar") << "unexpected failure";
6725   EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",
6726                           "expected failure");
6727   EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",
6728                        "expected failure");
6729 }
6730
6731 TEST(StreamingAssertionsTest, FloatingPointEquals) {
6732   EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
6733   ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
6734   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",
6735                           "expected failure");
6736   EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",
6737                        "expected failure");
6738 }
6739
6740 #if GTEST_HAS_EXCEPTIONS
6741
6742 TEST(StreamingAssertionsTest, Throw) {
6743   EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
6744   ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
6745   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
6746                           "expected failure", "expected failure");
6747   EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
6748                        "expected failure", "expected failure");
6749 }
6750
6751 TEST(StreamingAssertionsTest, NoThrow) {
6752   EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
6753   ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
6754   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
6755                           "expected failure", "expected failure");
6756   EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
6757                        "expected failure", "expected failure");
6758 }
6759
6760 TEST(StreamingAssertionsTest, AnyThrow) {
6761   EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
6762   ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
6763   EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
6764                           "expected failure", "expected failure");
6765   EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
6766                        "expected failure", "expected failure");
6767 }
6768
6769 #endif  // GTEST_HAS_EXCEPTIONS
6770
6771 // Tests that Google Test correctly decides whether to use colors in the output.
6772
6773 TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
6774   GTEST_FLAG(color) = "yes";
6775
6776   SetEnv("TERM", "xterm");  // TERM supports colors.
6777   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6778   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
6779
6780   SetEnv("TERM", "dumb");  // TERM doesn't support colors.
6781   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6782   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
6783 }
6784
6785 TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
6786   SetEnv("TERM", "dumb");  // TERM doesn't support colors.
6787
6788   GTEST_FLAG(color) = "True";
6789   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
6790
6791   GTEST_FLAG(color) = "t";
6792   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
6793
6794   GTEST_FLAG(color) = "1";
6795   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
6796 }
6797
6798 TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
6799   GTEST_FLAG(color) = "no";
6800
6801   SetEnv("TERM", "xterm");  // TERM supports colors.
6802   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6803   EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
6804
6805   SetEnv("TERM", "dumb");  // TERM doesn't support colors.
6806   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6807   EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
6808 }
6809
6810 TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
6811   SetEnv("TERM", "xterm");  // TERM supports colors.
6812
6813   GTEST_FLAG(color) = "F";
6814   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6815
6816   GTEST_FLAG(color) = "0";
6817   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6818
6819   GTEST_FLAG(color) = "unknown";
6820   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6821 }
6822
6823 TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
6824   GTEST_FLAG(color) = "auto";
6825
6826   SetEnv("TERM", "xterm");  // TERM supports colors.
6827   EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
6828   EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.
6829 }
6830
6831 TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
6832   GTEST_FLAG(color) = "auto";
6833
6834 #if GTEST_OS_WINDOWS
6835   // On Windows, we ignore the TERM variable as it's usually not set.
6836
6837   SetEnv("TERM", "dumb");
6838   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6839
6840   SetEnv("TERM", "");
6841   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6842
6843   SetEnv("TERM", "xterm");
6844   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6845 #else
6846   // On non-Windows platforms, we rely on TERM to determine if the
6847   // terminal supports colors.
6848
6849   SetEnv("TERM", "dumb");  // TERM doesn't support colors.
6850   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6851
6852   SetEnv("TERM", "emacs");  // TERM doesn't support colors.
6853   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6854
6855   SetEnv("TERM", "vt100");  // TERM doesn't support colors.
6856   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6857
6858   SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.
6859   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
6860
6861   SetEnv("TERM", "xterm");  // TERM supports colors.
6862   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6863
6864   SetEnv("TERM", "xterm-color");  // TERM supports colors.
6865   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6866
6867   SetEnv("TERM", "xterm-256color");  // TERM supports colors.
6868   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6869
6870   SetEnv("TERM", "screen");  // TERM supports colors.
6871   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6872
6873   SetEnv("TERM", "screen-256color");  // TERM supports colors.
6874   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6875
6876   SetEnv("TERM", "tmux");  // TERM supports colors.
6877   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6878
6879   SetEnv("TERM", "tmux-256color");  // TERM supports colors.
6880   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6881
6882   SetEnv("TERM", "rxvt-unicode");  // TERM supports colors.
6883   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6884
6885   SetEnv("TERM", "rxvt-unicode-256color");  // TERM supports colors.
6886   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6887
6888   SetEnv("TERM", "linux");  // TERM supports colors.
6889   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6890
6891   SetEnv("TERM", "cygwin");  // TERM supports colors.
6892   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
6893 #endif  // GTEST_OS_WINDOWS
6894 }
6895
6896 // Verifies that StaticAssertTypeEq works in a namespace scope.
6897
6898 static bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();
6899 static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =
6900     StaticAssertTypeEq<const int, const int>();
6901
6902 // Verifies that StaticAssertTypeEq works in a class.
6903
6904 template <typename T>
6905 class StaticAssertTypeEqTestHelper {
6906  public:
6907   StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }
6908 };
6909
6910 TEST(StaticAssertTypeEqTest, WorksInClass) {
6911   StaticAssertTypeEqTestHelper<bool>();
6912 }
6913
6914 // Verifies that StaticAssertTypeEq works inside a function.
6915
6916 typedef int IntAlias;
6917
6918 TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
6919   StaticAssertTypeEq<int, IntAlias>();
6920   StaticAssertTypeEq<int*, IntAlias*>();
6921 }
6922
6923 TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
6924   EXPECT_FALSE(HasNonfatalFailure());
6925 }
6926
6927 static void FailFatally() { FAIL(); }
6928
6929 TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {
6930   FailFatally();
6931   const bool has_nonfatal_failure = HasNonfatalFailure();
6932   ClearCurrentTestPartResults();
6933   EXPECT_FALSE(has_nonfatal_failure);
6934 }
6935
6936 TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
6937   ADD_FAILURE();
6938   const bool has_nonfatal_failure = HasNonfatalFailure();
6939   ClearCurrentTestPartResults();
6940   EXPECT_TRUE(has_nonfatal_failure);
6941 }
6942
6943 TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
6944   FailFatally();
6945   ADD_FAILURE();
6946   const bool has_nonfatal_failure = HasNonfatalFailure();
6947   ClearCurrentTestPartResults();
6948   EXPECT_TRUE(has_nonfatal_failure);
6949 }
6950
6951 // A wrapper for calling HasNonfatalFailure outside of a test body.
6952 static bool HasNonfatalFailureHelper() {
6953   return testing::Test::HasNonfatalFailure();
6954 }
6955
6956 TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {
6957   EXPECT_FALSE(HasNonfatalFailureHelper());
6958 }
6959
6960 TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {
6961   ADD_FAILURE();
6962   const bool has_nonfatal_failure = HasNonfatalFailureHelper();
6963   ClearCurrentTestPartResults();
6964   EXPECT_TRUE(has_nonfatal_failure);
6965 }
6966
6967 TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {
6968   EXPECT_FALSE(HasFailure());
6969 }
6970
6971 TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {
6972   FailFatally();
6973   const bool has_failure = HasFailure();
6974   ClearCurrentTestPartResults();
6975   EXPECT_TRUE(has_failure);
6976 }
6977
6978 TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
6979   ADD_FAILURE();
6980   const bool has_failure = HasFailure();
6981   ClearCurrentTestPartResults();
6982   EXPECT_TRUE(has_failure);
6983 }
6984
6985 TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
6986   FailFatally();
6987   ADD_FAILURE();
6988   const bool has_failure = HasFailure();
6989   ClearCurrentTestPartResults();
6990   EXPECT_TRUE(has_failure);
6991 }
6992
6993 // A wrapper for calling HasFailure outside of a test body.
6994 static bool HasFailureHelper() { return testing::Test::HasFailure(); }
6995
6996 TEST(HasFailureTest, WorksOutsideOfTestBody) {
6997   EXPECT_FALSE(HasFailureHelper());
6998 }
6999
7000 TEST(HasFailureTest, WorksOutsideOfTestBody2) {
7001   ADD_FAILURE();
7002   const bool has_failure = HasFailureHelper();
7003   ClearCurrentTestPartResults();
7004   EXPECT_TRUE(has_failure);
7005 }
7006
7007 class TestListener : public EmptyTestEventListener {
7008  public:
7009   TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {}
7010   TestListener(int* on_start_counter, bool* is_destroyed)
7011       : on_start_counter_(on_start_counter),
7012         is_destroyed_(is_destroyed) {}
7013
7014   virtual ~TestListener() {
7015     if (is_destroyed_)
7016       *is_destroyed_ = true;
7017   }
7018
7019  protected:
7020   virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
7021     if (on_start_counter_ != NULL)
7022       (*on_start_counter_)++;
7023   }
7024
7025  private:
7026   int* on_start_counter_;
7027   bool* is_destroyed_;
7028 };
7029
7030 // Tests the constructor.
7031 TEST(TestEventListenersTest, ConstructionWorks) {
7032   TestEventListeners listeners;
7033
7034   EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);
7035   EXPECT_TRUE(listeners.default_result_printer() == NULL);
7036   EXPECT_TRUE(listeners.default_xml_generator() == NULL);
7037 }
7038
7039 // Tests that the TestEventListeners destructor deletes all the listeners it
7040 // owns.
7041 TEST(TestEventListenersTest, DestructionWorks) {
7042   bool default_result_printer_is_destroyed = false;
7043   bool default_xml_printer_is_destroyed = false;
7044   bool extra_listener_is_destroyed = false;
7045   TestListener* default_result_printer = new TestListener(
7046       NULL, &default_result_printer_is_destroyed);
7047   TestListener* default_xml_printer = new TestListener(
7048       NULL, &default_xml_printer_is_destroyed);
7049   TestListener* extra_listener = new TestListener(
7050       NULL, &extra_listener_is_destroyed);
7051
7052   {
7053     TestEventListeners listeners;
7054     TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,
7055                                                         default_result_printer);
7056     TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,
7057                                                        default_xml_printer);
7058     listeners.Append(extra_listener);
7059   }
7060   EXPECT_TRUE(default_result_printer_is_destroyed);
7061   EXPECT_TRUE(default_xml_printer_is_destroyed);
7062   EXPECT_TRUE(extra_listener_is_destroyed);
7063 }
7064
7065 // Tests that a listener Append'ed to a TestEventListeners list starts
7066 // receiving events.
7067 TEST(TestEventListenersTest, Append) {
7068   int on_start_counter = 0;
7069   bool is_destroyed = false;
7070   TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
7071   {
7072     TestEventListeners listeners;
7073     listeners.Append(listener);
7074     TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7075         *UnitTest::GetInstance());
7076     EXPECT_EQ(1, on_start_counter);
7077   }
7078   EXPECT_TRUE(is_destroyed);
7079 }
7080
7081 // Tests that listeners receive events in the order they were appended to
7082 // the list, except for *End requests, which must be received in the reverse
7083 // order.
7084 class SequenceTestingListener : public EmptyTestEventListener {
7085  public:
7086   SequenceTestingListener(std::vector<std::string>* vector, const char* id)
7087       : vector_(vector), id_(id) {}
7088
7089  protected:
7090   virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
7091     vector_->push_back(GetEventDescription("OnTestProgramStart"));
7092   }
7093
7094   virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
7095     vector_->push_back(GetEventDescription("OnTestProgramEnd"));
7096   }
7097
7098   virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
7099                                     int /*iteration*/) {
7100     vector_->push_back(GetEventDescription("OnTestIterationStart"));
7101   }
7102
7103   virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
7104                                   int /*iteration*/) {
7105     vector_->push_back(GetEventDescription("OnTestIterationEnd"));
7106   }
7107
7108  private:
7109   std::string GetEventDescription(const char* method) {
7110     Message message;
7111     message << id_ << "." << method;
7112     return message.GetString();
7113   }
7114
7115   std::vector<std::string>* vector_;
7116   const char* const id_;
7117
7118   GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
7119 };
7120
7121 TEST(EventListenerTest, AppendKeepsOrder) {
7122   std::vector<std::string> vec;
7123   TestEventListeners listeners;
7124   listeners.Append(new SequenceTestingListener(&vec, "1st"));
7125   listeners.Append(new SequenceTestingListener(&vec, "2nd"));
7126   listeners.Append(new SequenceTestingListener(&vec, "3rd"));
7127
7128   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7129       *UnitTest::GetInstance());
7130   ASSERT_EQ(3U, vec.size());
7131   EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
7132   EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
7133   EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
7134
7135   vec.clear();
7136   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
7137       *UnitTest::GetInstance());
7138   ASSERT_EQ(3U, vec.size());
7139   EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
7140   EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
7141   EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
7142
7143   vec.clear();
7144   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
7145       *UnitTest::GetInstance(), 0);
7146   ASSERT_EQ(3U, vec.size());
7147   EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
7148   EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
7149   EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
7150
7151   vec.clear();
7152   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
7153       *UnitTest::GetInstance(), 0);
7154   ASSERT_EQ(3U, vec.size());
7155   EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
7156   EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
7157   EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str());
7158 }
7159
7160 // Tests that a listener removed from a TestEventListeners list stops receiving
7161 // events and is not deleted when the list is destroyed.
7162 TEST(TestEventListenersTest, Release) {
7163   int on_start_counter = 0;
7164   bool is_destroyed = false;
7165   // Although Append passes the ownership of this object to the list,
7166   // the following calls release it, and we need to delete it before the
7167   // test ends.
7168   TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
7169   {
7170     TestEventListeners listeners;
7171     listeners.Append(listener);
7172     EXPECT_EQ(listener, listeners.Release(listener));
7173     TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7174         *UnitTest::GetInstance());
7175     EXPECT_TRUE(listeners.Release(listener) == NULL);
7176   }
7177   EXPECT_EQ(0, on_start_counter);
7178   EXPECT_FALSE(is_destroyed);
7179   delete listener;
7180 }
7181
7182 // Tests that no events are forwarded when event forwarding is disabled.
7183 TEST(EventListenerTest, SuppressEventForwarding) {
7184   int on_start_counter = 0;
7185   TestListener* listener = new TestListener(&on_start_counter, NULL);
7186
7187   TestEventListeners listeners;
7188   listeners.Append(listener);
7189   ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
7190   TestEventListenersAccessor::SuppressEventForwarding(&listeners);
7191   ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
7192   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7193       *UnitTest::GetInstance());
7194   EXPECT_EQ(0, on_start_counter);
7195 }
7196
7197 // Tests that events generated by Google Test are not forwarded in
7198 // death test subprocesses.
7199 TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
7200   EXPECT_DEATH_IF_SUPPORTED({
7201       GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
7202           *GetUnitTestImpl()->listeners())) << "expected failure";},
7203       "expected failure");
7204 }
7205
7206 // Tests that a listener installed via SetDefaultResultPrinter() starts
7207 // receiving events and is returned via default_result_printer() and that
7208 // the previous default_result_printer is removed from the list and deleted.
7209 TEST(EventListenerTest, default_result_printer) {
7210   int on_start_counter = 0;
7211   bool is_destroyed = false;
7212   TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
7213
7214   TestEventListeners listeners;
7215   TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
7216
7217   EXPECT_EQ(listener, listeners.default_result_printer());
7218
7219   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7220       *UnitTest::GetInstance());
7221
7222   EXPECT_EQ(1, on_start_counter);
7223
7224   // Replacing default_result_printer with something else should remove it
7225   // from the list and destroy it.
7226   TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);
7227
7228   EXPECT_TRUE(listeners.default_result_printer() == NULL);
7229   EXPECT_TRUE(is_destroyed);
7230
7231   // After broadcasting an event the counter is still the same, indicating
7232   // the listener is not in the list anymore.
7233   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7234       *UnitTest::GetInstance());
7235   EXPECT_EQ(1, on_start_counter);
7236 }
7237
7238 // Tests that the default_result_printer listener stops receiving events
7239 // when removed via Release and that is not owned by the list anymore.
7240 TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
7241   int on_start_counter = 0;
7242   bool is_destroyed = false;
7243   // Although Append passes the ownership of this object to the list,
7244   // the following calls release it, and we need to delete it before the
7245   // test ends.
7246   TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
7247   {
7248     TestEventListeners listeners;
7249     TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
7250
7251     EXPECT_EQ(listener, listeners.Release(listener));
7252     EXPECT_TRUE(listeners.default_result_printer() == NULL);
7253     EXPECT_FALSE(is_destroyed);
7254
7255     // Broadcasting events now should not affect default_result_printer.
7256     TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7257         *UnitTest::GetInstance());
7258     EXPECT_EQ(0, on_start_counter);
7259   }
7260   // Destroying the list should not affect the listener now, too.
7261   EXPECT_FALSE(is_destroyed);
7262   delete listener;
7263 }
7264
7265 // Tests that a listener installed via SetDefaultXmlGenerator() starts
7266 // receiving events and is returned via default_xml_generator() and that
7267 // the previous default_xml_generator is removed from the list and deleted.
7268 TEST(EventListenerTest, default_xml_generator) {
7269   int on_start_counter = 0;
7270   bool is_destroyed = false;
7271   TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
7272
7273   TestEventListeners listeners;
7274   TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
7275
7276   EXPECT_EQ(listener, listeners.default_xml_generator());
7277
7278   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7279       *UnitTest::GetInstance());
7280
7281   EXPECT_EQ(1, on_start_counter);
7282
7283   // Replacing default_xml_generator with something else should remove it
7284   // from the list and destroy it.
7285   TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);
7286
7287   EXPECT_TRUE(listeners.default_xml_generator() == NULL);
7288   EXPECT_TRUE(is_destroyed);
7289
7290   // After broadcasting an event the counter is still the same, indicating
7291   // the listener is not in the list anymore.
7292   TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7293       *UnitTest::GetInstance());
7294   EXPECT_EQ(1, on_start_counter);
7295 }
7296
7297 // Tests that the default_xml_generator listener stops receiving events
7298 // when removed via Release and that is not owned by the list anymore.
7299 TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
7300   int on_start_counter = 0;
7301   bool is_destroyed = false;
7302   // Although Append passes the ownership of this object to the list,
7303   // the following calls release it, and we need to delete it before the
7304   // test ends.
7305   TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
7306   {
7307     TestEventListeners listeners;
7308     TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
7309
7310     EXPECT_EQ(listener, listeners.Release(listener));
7311     EXPECT_TRUE(listeners.default_xml_generator() == NULL);
7312     EXPECT_FALSE(is_destroyed);
7313
7314     // Broadcasting events now should not affect default_xml_generator.
7315     TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
7316         *UnitTest::GetInstance());
7317     EXPECT_EQ(0, on_start_counter);
7318   }
7319   // Destroying the list should not affect the listener now, too.
7320   EXPECT_FALSE(is_destroyed);
7321   delete listener;
7322 }
7323
7324 // Sanity tests to ensure that the alternative, verbose spellings of
7325 // some of the macros work.  We don't test them thoroughly as that
7326 // would be quite involved.  Since their implementations are
7327 // straightforward, and they are rarely used, we'll just rely on the
7328 // users to tell us when they are broken.
7329 GTEST_TEST(AlternativeNameTest, Works) {  // GTEST_TEST is the same as TEST.
7330   GTEST_SUCCEED() << "OK";  // GTEST_SUCCEED is the same as SUCCEED.
7331
7332   // GTEST_FAIL is the same as FAIL.
7333   EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",
7334                        "An expected failure");
7335
7336   // GTEST_ASSERT_XY is the same as ASSERT_XY.
7337
7338   GTEST_ASSERT_EQ(0, 0);
7339   EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",
7340                        "An expected failure");
7341   EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",
7342                        "An expected failure");
7343
7344   GTEST_ASSERT_NE(0, 1);
7345   GTEST_ASSERT_NE(1, 0);
7346   EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",
7347                        "An expected failure");
7348
7349   GTEST_ASSERT_LE(0, 0);
7350   GTEST_ASSERT_LE(0, 1);
7351   EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",
7352                        "An expected failure");
7353
7354   GTEST_ASSERT_LT(0, 1);
7355   EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",
7356                        "An expected failure");
7357   EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",
7358                        "An expected failure");
7359
7360   GTEST_ASSERT_GE(0, 0);
7361   GTEST_ASSERT_GE(1, 0);
7362   EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",
7363                        "An expected failure");
7364
7365   GTEST_ASSERT_GT(1, 0);
7366   EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",
7367                        "An expected failure");
7368   EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",
7369                        "An expected failure");
7370 }
7371
7372 // Tests for internal utilities necessary for implementation of the universal
7373 // printing.
7374 // FIXME: Find a better home for them.
7375
7376 class ConversionHelperBase {};
7377 class ConversionHelperDerived : public ConversionHelperBase {};
7378
7379 // Tests that IsAProtocolMessage<T>::value is a compile-time constant.
7380 TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {
7381   GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,
7382                         const_true);
7383   GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);
7384 }
7385
7386 // Tests that IsAProtocolMessage<T>::value is true when T is
7387 // proto2::Message or a sub-class of it.
7388 TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) {
7389   EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);
7390   EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);
7391 }
7392
7393 // Tests that IsAProtocolMessage<T>::value is false when T is neither
7394 // ProtocolMessage nor a sub-class of it.
7395 TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) {
7396   EXPECT_FALSE(IsAProtocolMessage<int>::value);
7397   EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);
7398 }
7399
7400 // Tests that CompileAssertTypesEqual compiles when the type arguments are
7401 // equal.
7402 TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) {
7403   CompileAssertTypesEqual<void, void>();
7404   CompileAssertTypesEqual<int*, int*>();
7405 }
7406
7407 // Tests that RemoveReference does not affect non-reference types.
7408 TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) {
7409   CompileAssertTypesEqual<int, RemoveReference<int>::type>();
7410   CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();
7411 }
7412
7413 // Tests that RemoveReference removes reference from reference types.
7414 TEST(RemoveReferenceTest, RemovesReference) {
7415   CompileAssertTypesEqual<int, RemoveReference<int&>::type>();
7416   CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();
7417 }
7418
7419 // Tests GTEST_REMOVE_REFERENCE_.
7420
7421 template <typename T1, typename T2>
7422 void TestGTestRemoveReference() {
7423   CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();
7424 }
7425
7426 TEST(RemoveReferenceTest, MacroVersion) {
7427   TestGTestRemoveReference<int, int>();
7428   TestGTestRemoveReference<const char, const char&>();
7429 }
7430
7431
7432 // Tests that RemoveConst does not affect non-const types.
7433 TEST(RemoveConstTest, DoesNotAffectNonConstType) {
7434   CompileAssertTypesEqual<int, RemoveConst<int>::type>();
7435   CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();
7436 }
7437
7438 // Tests that RemoveConst removes const from const types.
7439 TEST(RemoveConstTest, RemovesConst) {
7440   CompileAssertTypesEqual<int, RemoveConst<const int>::type>();
7441   CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();
7442   CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();
7443 }
7444
7445 // Tests GTEST_REMOVE_CONST_.
7446
7447 template <typename T1, typename T2>
7448 void TestGTestRemoveConst() {
7449   CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();
7450 }
7451
7452 TEST(RemoveConstTest, MacroVersion) {
7453   TestGTestRemoveConst<int, int>();
7454   TestGTestRemoveConst<double&, double&>();
7455   TestGTestRemoveConst<char, const char>();
7456 }
7457
7458 // Tests GTEST_REMOVE_REFERENCE_AND_CONST_.
7459
7460 template <typename T1, typename T2>
7461 void TestGTestRemoveReferenceAndConst() {
7462   CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();
7463 }
7464
7465 TEST(RemoveReferenceToConstTest, Works) {
7466   TestGTestRemoveReferenceAndConst<int, int>();
7467   TestGTestRemoveReferenceAndConst<double, double&>();
7468   TestGTestRemoveReferenceAndConst<char, const char>();
7469   TestGTestRemoveReferenceAndConst<char, const char&>();
7470   TestGTestRemoveReferenceAndConst<const char*, const char*>();
7471 }
7472
7473 // Tests that AddReference does not affect reference types.
7474 TEST(AddReferenceTest, DoesNotAffectReferenceType) {
7475   CompileAssertTypesEqual<int&, AddReference<int&>::type>();
7476   CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();
7477 }
7478
7479 // Tests that AddReference adds reference to non-reference types.
7480 TEST(AddReferenceTest, AddsReference) {
7481   CompileAssertTypesEqual<int&, AddReference<int>::type>();
7482   CompileAssertTypesEqual<const char&, AddReference<const char>::type>();
7483 }
7484
7485 // Tests GTEST_ADD_REFERENCE_.
7486
7487 template <typename T1, typename T2>
7488 void TestGTestAddReference() {
7489   CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();
7490 }
7491
7492 TEST(AddReferenceTest, MacroVersion) {
7493   TestGTestAddReference<int&, int>();
7494   TestGTestAddReference<const char&, const char&>();
7495 }
7496
7497 // Tests GTEST_REFERENCE_TO_CONST_.
7498
7499 template <typename T1, typename T2>
7500 void TestGTestReferenceToConst() {
7501   CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();
7502 }
7503
7504 TEST(GTestReferenceToConstTest, Works) {
7505   TestGTestReferenceToConst<const char&, char>();
7506   TestGTestReferenceToConst<const int&, const int>();
7507   TestGTestReferenceToConst<const double&, double>();
7508   TestGTestReferenceToConst<const std::string&, const std::string&>();
7509 }
7510
7511 // Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.
7512 TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) {
7513   GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);
7514   GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),
7515                         const_false);
7516 }
7517
7518 // Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can
7519 // be implicitly converted to T2.
7520 TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) {
7521   EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));
7522   EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));
7523   EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));
7524   EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));
7525   EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,
7526                                      const ConversionHelperBase&>::value));
7527   EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,
7528                                      ConversionHelperBase>::value));
7529 }
7530
7531 // Tests that ImplicitlyConvertible<T1, T2>::value is false when T1
7532 // cannot be implicitly converted to T2.
7533 TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) {
7534   EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));
7535   EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));
7536   EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));
7537   EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,
7538                                       ConversionHelperDerived&>::value));
7539 }
7540
7541 // Tests IsContainerTest.
7542
7543 class NonContainer {};
7544
7545 TEST(IsContainerTestTest, WorksForNonContainer) {
7546   EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));
7547   EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));
7548   EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));
7549 }
7550
7551 TEST(IsContainerTestTest, WorksForContainer) {
7552   EXPECT_EQ(sizeof(IsContainer),
7553             sizeof(IsContainerTest<std::vector<bool> >(0)));
7554   EXPECT_EQ(sizeof(IsContainer),
7555             sizeof(IsContainerTest<std::map<int, double> >(0)));
7556 }
7557
7558 #if GTEST_LANG_CXX11
7559 struct ConstOnlyContainerWithPointerIterator {
7560   using const_iterator = int*;
7561   const_iterator begin() const;
7562   const_iterator end() const;
7563 };
7564
7565 struct ConstOnlyContainerWithClassIterator {
7566   struct const_iterator {
7567     const int& operator*() const;
7568     const_iterator& operator++(/* pre-increment */);
7569   };
7570   const_iterator begin() const;
7571   const_iterator end() const;
7572 };
7573
7574 TEST(IsContainerTestTest, ConstOnlyContainer) {
7575   EXPECT_EQ(sizeof(IsContainer),
7576             sizeof(IsContainerTest<ConstOnlyContainerWithPointerIterator>(0)));
7577   EXPECT_EQ(sizeof(IsContainer),
7578             sizeof(IsContainerTest<ConstOnlyContainerWithClassIterator>(0)));
7579 }
7580 #endif  // GTEST_LANG_CXX11
7581
7582 // Tests IsHashTable.
7583 struct AHashTable {
7584   typedef void hasher;
7585 };
7586 struct NotReallyAHashTable {
7587   typedef void hasher;
7588   typedef void reverse_iterator;
7589 };
7590 TEST(IsHashTable, Basic) {
7591   EXPECT_TRUE(testing::internal::IsHashTable<AHashTable>::value);
7592   EXPECT_FALSE(testing::internal::IsHashTable<NotReallyAHashTable>::value);
7593 #if GTEST_LANG_CXX11
7594   EXPECT_FALSE(testing::internal::IsHashTable<std::vector<int>>::value);
7595   EXPECT_TRUE(testing::internal::IsHashTable<std::unordered_set<int>>::value);
7596 #endif  // GTEST_LANG_CXX11
7597 #if GTEST_HAS_HASH_SET_
7598   EXPECT_TRUE(testing::internal::IsHashTable<__gnu_cxx::hash_set<int>>::value);
7599 #endif  // GTEST_HAS_HASH_SET_
7600 }
7601
7602 // Tests ArrayEq().
7603
7604 TEST(ArrayEqTest, WorksForDegeneratedArrays) {
7605   EXPECT_TRUE(ArrayEq(5, 5L));
7606   EXPECT_FALSE(ArrayEq('a', 0));
7607 }
7608
7609 TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
7610   // Note that a and b are distinct but compatible types.
7611   const int a[] = { 0, 1 };
7612   long b[] = { 0, 1 };
7613   EXPECT_TRUE(ArrayEq(a, b));
7614   EXPECT_TRUE(ArrayEq(a, 2, b));
7615
7616   b[0] = 2;
7617   EXPECT_FALSE(ArrayEq(a, b));
7618   EXPECT_FALSE(ArrayEq(a, 1, b));
7619 }
7620
7621 TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
7622   const char a[][3] = { "hi", "lo" };
7623   const char b[][3] = { "hi", "lo" };
7624   const char c[][3] = { "hi", "li" };
7625
7626   EXPECT_TRUE(ArrayEq(a, b));
7627   EXPECT_TRUE(ArrayEq(a, 2, b));
7628
7629   EXPECT_FALSE(ArrayEq(a, c));
7630   EXPECT_FALSE(ArrayEq(a, 2, c));
7631 }
7632
7633 // Tests ArrayAwareFind().
7634
7635 TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
7636   const char a[] = "hello";
7637   EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));
7638   EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));
7639 }
7640
7641 TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
7642   int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
7643   const int b[2] = { 2, 3 };
7644   EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
7645
7646   const int c[2] = { 6, 7 };
7647   EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
7648 }
7649
7650 // Tests CopyArray().
7651
7652 TEST(CopyArrayTest, WorksForDegeneratedArrays) {
7653   int n = 0;
7654   CopyArray('a', &n);
7655   EXPECT_EQ('a', n);
7656 }
7657
7658 TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
7659   const char a[3] = "hi";
7660   int b[3];
7661 #ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
7662   CopyArray(a, &b);
7663   EXPECT_TRUE(ArrayEq(a, b));
7664 #endif
7665
7666   int c[3];
7667   CopyArray(a, 3, c);
7668   EXPECT_TRUE(ArrayEq(a, c));
7669 }
7670
7671 TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
7672   const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
7673   int b[2][3];
7674 #ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
7675   CopyArray(a, &b);
7676   EXPECT_TRUE(ArrayEq(a, b));
7677 #endif
7678
7679   int c[2][3];
7680   CopyArray(a, 2, c);
7681   EXPECT_TRUE(ArrayEq(a, c));
7682 }
7683
7684 // Tests NativeArray.
7685
7686 TEST(NativeArrayTest, ConstructorFromArrayWorks) {
7687   const int a[3] = { 0, 1, 2 };
7688   NativeArray<int> na(a, 3, RelationToSourceReference());
7689   EXPECT_EQ(3U, na.size());
7690   EXPECT_EQ(a, na.begin());
7691 }
7692
7693 TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
7694   typedef int Array[2];
7695   Array* a = new Array[1];
7696   (*a)[0] = 0;
7697   (*a)[1] = 1;
7698   NativeArray<int> na(*a, 2, RelationToSourceCopy());
7699   EXPECT_NE(*a, na.begin());
7700   delete[] a;
7701   EXPECT_EQ(0, na.begin()[0]);
7702   EXPECT_EQ(1, na.begin()[1]);
7703
7704   // We rely on the heap checker to verify that na deletes the copy of
7705   // array.
7706 }
7707
7708 TEST(NativeArrayTest, TypeMembersAreCorrect) {
7709   StaticAssertTypeEq<char, NativeArray<char>::value_type>();
7710   StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();
7711
7712   StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();
7713   StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();
7714 }
7715
7716 TEST(NativeArrayTest, MethodsWork) {
7717   const int a[3] = { 0, 1, 2 };
7718   NativeArray<int> na(a, 3, RelationToSourceCopy());
7719   ASSERT_EQ(3U, na.size());
7720   EXPECT_EQ(3, na.end() - na.begin());
7721
7722   NativeArray<int>::const_iterator it = na.begin();
7723   EXPECT_EQ(0, *it);
7724   ++it;
7725   EXPECT_EQ(1, *it);
7726   it++;
7727   EXPECT_EQ(2, *it);
7728   ++it;
7729   EXPECT_EQ(na.end(), it);
7730
7731   EXPECT_TRUE(na == na);
7732
7733   NativeArray<int> na2(a, 3, RelationToSourceReference());
7734   EXPECT_TRUE(na == na2);
7735
7736   const int b1[3] = { 0, 1, 1 };
7737   const int b2[4] = { 0, 1, 2, 3 };
7738   EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference()));
7739   EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy()));
7740 }
7741
7742 TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
7743   const char a[2][3] = { "hi", "lo" };
7744   NativeArray<char[3]> na(a, 2, RelationToSourceReference());
7745   ASSERT_EQ(2U, na.size());
7746   EXPECT_EQ(a, na.begin());
7747 }
7748
7749 // Tests SkipPrefix().
7750
7751 TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {
7752   const char* const str = "hello";
7753
7754   const char* p = str;
7755   EXPECT_TRUE(SkipPrefix("", &p));
7756   EXPECT_EQ(str, p);
7757
7758   p = str;
7759   EXPECT_TRUE(SkipPrefix("hell", &p));
7760   EXPECT_EQ(str + 4, p);
7761 }
7762
7763 TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {
7764   const char* const str = "world";
7765
7766   const char* p = str;
7767   EXPECT_FALSE(SkipPrefix("W", &p));
7768   EXPECT_EQ(str, p);
7769
7770   p = str;
7771   EXPECT_FALSE(SkipPrefix("world!", &p));
7772   EXPECT_EQ(str, p);
7773 }
7774
7775 // Tests ad_hoc_test_result().
7776
7777 class AdHocTestResultTest : public testing::Test {
7778  protected:
7779   static void SetUpTestCase() {
7780     FAIL() << "A failure happened inside SetUpTestCase().";
7781   }
7782 };
7783
7784 TEST_F(AdHocTestResultTest, AdHocTestResultForTestCaseShowsFailure) {
7785   const testing::TestResult& test_result = testing::UnitTest::GetInstance()
7786                                                ->current_test_case()
7787                                                ->ad_hoc_test_result();
7788   EXPECT_TRUE(test_result.Failed());
7789 }
7790
7791 TEST_F(AdHocTestResultTest, AdHocTestResultTestForUnitTestDoesNotShowFailure) {
7792   const testing::TestResult& test_result =
7793       testing::UnitTest::GetInstance()->ad_hoc_test_result();
7794   EXPECT_FALSE(test_result.Failed());
7795 }