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