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