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