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