gmock-internal-utils_test.cc revision c407dc5cd9bdc5668497f21b26b09d988ab439de
1// Copyright 2007, 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// Google Mock - a framework for writing C++ mock classes. 33// 34// This file tests the internal utilities. 35 36#include <gmock/internal/gmock-internal-utils.h> 37#include <stdlib.h> 38#include <map> 39#include <string> 40#include <sstream> 41#include <vector> 42#include <gmock/gmock.h> 43#include <gmock/internal/gmock-port.h> 44#include <gtest/gtest.h> 45#include <gtest/gtest-spi.h> 46 47#if GTEST_OS_CYGWIN 48#include <sys/types.h> // For ssize_t. NOLINT 49#endif 50 51class ProtocolMessage; 52 53namespace proto2 { 54class Message; 55} // namespace proto2 56 57namespace testing { 58namespace internal { 59 60namespace { 61 62using ::std::tr1::make_tuple; 63using ::std::tr1::tuple; 64 65TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) { 66 EXPECT_EQ("", ConvertIdentifierNameToWords("")); 67 EXPECT_EQ("", ConvertIdentifierNameToWords("_")); 68 EXPECT_EQ("", ConvertIdentifierNameToWords("__")); 69} 70 71TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) { 72 EXPECT_EQ("1", ConvertIdentifierNameToWords("_1")); 73 EXPECT_EQ("2", ConvertIdentifierNameToWords("2_")); 74 EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_")); 75 EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56")); 76} 77 78TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) { 79 EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord")); 80 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar")); 81 EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_")); 82 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_")); 83 EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar")); 84} 85 86TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) { 87 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar")); 88 EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_")); 89 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_")); 90 EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar")); 91} 92 93TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) { 94 EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123")); 95 EXPECT_EQ("chapter 11 section 1", 96 ConvertIdentifierNameToWords("_Chapter11Section_1_")); 97} 98 99// Tests that CompileAssertTypesEqual compiles when the type arguments are 100// equal. 101TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) { 102 CompileAssertTypesEqual<void, void>(); 103 CompileAssertTypesEqual<int*, int*>(); 104} 105 106// Tests that RemoveReference does not affect non-reference types. 107TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) { 108 CompileAssertTypesEqual<int, RemoveReference<int>::type>(); 109 CompileAssertTypesEqual<const char, RemoveReference<const char>::type>(); 110} 111 112// Tests that RemoveReference removes reference from reference types. 113TEST(RemoveReferenceTest, RemovesReference) { 114 CompileAssertTypesEqual<int, RemoveReference<int&>::type>(); 115 CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>(); 116} 117 118// Tests GMOCK_REMOVE_REFERENCE_. 119 120template <typename T1, typename T2> 121void TestGMockRemoveReference() { 122 CompileAssertTypesEqual<T1, GMOCK_REMOVE_REFERENCE_(T2)>(); 123} 124 125TEST(RemoveReferenceTest, MacroVersion) { 126 TestGMockRemoveReference<int, int>(); 127 TestGMockRemoveReference<const char, const char&>(); 128} 129 130 131// Tests that RemoveConst does not affect non-const types. 132TEST(RemoveConstTest, DoesNotAffectNonConstType) { 133 CompileAssertTypesEqual<int, RemoveConst<int>::type>(); 134 CompileAssertTypesEqual<char&, RemoveConst<char&>::type>(); 135} 136 137// Tests that RemoveConst removes const from const types. 138TEST(RemoveConstTest, RemovesConst) { 139 CompileAssertTypesEqual<int, RemoveConst<const int>::type>(); 140 CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>(); 141 CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>(); 142} 143 144// Tests GMOCK_REMOVE_CONST_. 145 146template <typename T1, typename T2> 147void TestGMockRemoveConst() { 148 CompileAssertTypesEqual<T1, GMOCK_REMOVE_CONST_(T2)>(); 149} 150 151TEST(RemoveConstTest, MacroVersion) { 152 TestGMockRemoveConst<int, int>(); 153 TestGMockRemoveConst<double&, double&>(); 154 TestGMockRemoveConst<char, const char>(); 155} 156 157// Tests that AddReference does not affect reference types. 158TEST(AddReferenceTest, DoesNotAffectReferenceType) { 159 CompileAssertTypesEqual<int&, AddReference<int&>::type>(); 160 CompileAssertTypesEqual<const char&, AddReference<const char&>::type>(); 161} 162 163// Tests that AddReference adds reference to non-reference types. 164TEST(AddReferenceTest, AddsReference) { 165 CompileAssertTypesEqual<int&, AddReference<int>::type>(); 166 CompileAssertTypesEqual<const char&, AddReference<const char>::type>(); 167} 168 169// Tests GMOCK_ADD_REFERENCE_. 170 171template <typename T1, typename T2> 172void TestGMockAddReference() { 173 CompileAssertTypesEqual<T1, GMOCK_ADD_REFERENCE_(T2)>(); 174} 175 176TEST(AddReferenceTest, MacroVersion) { 177 TestGMockAddReference<int&, int>(); 178 TestGMockAddReference<const char&, const char&>(); 179} 180 181// Tests GMOCK_REFERENCE_TO_CONST_. 182 183template <typename T1, typename T2> 184void TestGMockReferenceToConst() { 185 CompileAssertTypesEqual<T1, GMOCK_REFERENCE_TO_CONST_(T2)>(); 186} 187 188TEST(GMockReferenceToConstTest, Works) { 189 TestGMockReferenceToConst<const char&, char>(); 190 TestGMockReferenceToConst<const int&, const int>(); 191 TestGMockReferenceToConst<const double&, double>(); 192 TestGMockReferenceToConst<const string&, const string&>(); 193} 194 195TEST(PointeeOfTest, WorksForSmartPointers) { 196 CompileAssertTypesEqual<const char, 197 PointeeOf<internal::linked_ptr<const char> >::type>(); 198} 199 200TEST(PointeeOfTest, WorksForRawPointers) { 201 CompileAssertTypesEqual<int, PointeeOf<int*>::type>(); 202 CompileAssertTypesEqual<const char, PointeeOf<const char*>::type>(); 203 CompileAssertTypesEqual<void, PointeeOf<void*>::type>(); 204} 205 206TEST(GetRawPointerTest, WorksForSmartPointers) { 207 const char* const raw_p4 = new const char('a'); // NOLINT 208 const internal::linked_ptr<const char> p4(raw_p4); 209 EXPECT_EQ(raw_p4, GetRawPointer(p4)); 210} 211 212TEST(GetRawPointerTest, WorksForRawPointers) { 213 int* p = NULL; 214 // Don't use EXPECT_EQ as no NULL-testing magic on Symbian. 215 EXPECT_TRUE(NULL == GetRawPointer(p)); 216 int n = 1; 217 EXPECT_EQ(&n, GetRawPointer(&n)); 218} 219 220class Base {}; 221class Derived : public Base {}; 222 223// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant. 224TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) { 225 GMOCK_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true); 226 GMOCK_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value), 227 const_false); 228} 229 230// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can 231// be implicitly converted to T2. 232TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) { 233 EXPECT_TRUE((ImplicitlyConvertible<int, double>::value)); 234 EXPECT_TRUE((ImplicitlyConvertible<double, int>::value)); 235 EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value)); 236 EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value)); 237 EXPECT_TRUE((ImplicitlyConvertible<Derived&, const Base&>::value)); 238 EXPECT_TRUE((ImplicitlyConvertible<const Base, Base>::value)); 239} 240 241// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1 242// cannot be implicitly converted to T2. 243TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) { 244 EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value)); 245 EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value)); 246 EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value)); 247 EXPECT_FALSE((ImplicitlyConvertible<Base&, Derived&>::value)); 248} 249 250// Tests KindOf<T>. 251 252TEST(KindOfTest, Bool) { 253 EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool)); // NOLINT 254} 255 256TEST(KindOfTest, Integer) { 257 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char)); // NOLINT 258 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char)); // NOLINT 259 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char)); // NOLINT 260 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short)); // NOLINT 261 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short)); // NOLINT 262 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int)); // NOLINT 263 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int)); // NOLINT 264 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long)); // NOLINT 265 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long)); // NOLINT 266 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT 267 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64)); // NOLINT 268 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64)); // NOLINT 269 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT 270#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN 271 // ssize_t is not defined on Windows and possibly some other OSes. 272 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT 273#endif 274} 275 276TEST(KindOfTest, FloatingPoint) { 277 EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float)); // NOLINT 278 EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double)); // NOLINT 279 EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double)); // NOLINT 280} 281 282TEST(KindOfTest, Other) { 283 EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*)); // NOLINT 284 EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**)); // NOLINT 285 EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base)); // NOLINT 286} 287 288// Tests LosslessArithmeticConvertible<T, U>. 289 290TEST(LosslessArithmeticConvertibleTest, BoolToBool) { 291 EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value)); 292} 293 294TEST(LosslessArithmeticConvertibleTest, BoolToInteger) { 295 EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value)); 296 EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value)); 297 EXPECT_TRUE( 298 (LosslessArithmeticConvertible<bool, unsigned long>::value)); // NOLINT 299} 300 301TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) { 302 EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value)); 303 EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value)); 304} 305 306TEST(LosslessArithmeticConvertibleTest, IntegerToBool) { 307 EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value)); 308 EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value)); 309} 310 311TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) { 312 // Unsigned => larger signed is fine. 313 EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value)); 314 315 // Unsigned => larger unsigned is fine. 316 EXPECT_TRUE( 317 (LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT 318 319 // Signed => unsigned is not fine. 320 EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT 321 EXPECT_FALSE((LosslessArithmeticConvertible< 322 signed char, unsigned int>::value)); // NOLINT 323 324 // Same size and same signedness: fine too. 325 EXPECT_TRUE((LosslessArithmeticConvertible< 326 unsigned char, unsigned char>::value)); 327 EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value)); 328 EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value)); 329 EXPECT_TRUE((LosslessArithmeticConvertible< 330 unsigned long, unsigned long>::value)); // NOLINT 331 332 // Same size, different signedness: not fine. 333 EXPECT_FALSE((LosslessArithmeticConvertible< 334 unsigned char, signed char>::value)); 335 EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value)); 336 EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value)); 337 338 // Larger size => smaller size is not fine. 339 EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value)); // NOLINT 340 EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value)); 341 EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value)); 342} 343 344TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) { 345 // Integers cannot be losslessly converted to floating-points, as 346 // the format of the latter is implementation-defined. 347 EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value)); 348 EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value)); 349 EXPECT_FALSE((LosslessArithmeticConvertible< 350 short, long double>::value)); // NOLINT 351} 352 353TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) { 354 EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value)); 355 EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value)); 356} 357 358TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) { 359 EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value)); // NOLINT 360 EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value)); 361 EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value)); 362} 363 364TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) { 365 // Smaller size => larger size is fine. 366 EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value)); 367 EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value)); 368 EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value)); 369 370 // Same size: fine. 371 EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value)); 372 EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value)); 373 374 // Larger size => smaller size is not fine. 375 EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value)); 376 if (sizeof(double) == sizeof(long double)) { // NOLINT 377 // In some implementations (e.g. MSVC), double and long double 378 // have the same size. 379 EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value)); 380 } else { 381 EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value)); 382 } 383} 384 385// Tests that IsAProtocolMessage<T>::value is a compile-time constant. 386TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) { 387 GMOCK_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value, const_true); 388 GMOCK_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false); 389} 390 391// Tests that IsAProtocolMessage<T>::value is true when T is 392// ProtocolMessage or a sub-class of it. 393TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) { 394 EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value); 395 EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value); 396#if GMOCK_HAS_PROTOBUF_ 397 EXPECT_TRUE(IsAProtocolMessage<const TestMessage>::value); 398#endif // GMOCK_HAS_PROTOBUF_ 399} 400 401// Tests that IsAProtocolMessage<T>::value is false when T is neither 402// ProtocolMessage nor a sub-class of it. 403TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) { 404 EXPECT_FALSE(IsAProtocolMessage<int>::value); 405 EXPECT_FALSE(IsAProtocolMessage<const Base>::value); 406} 407 408// Tests IsContainerTest. 409 410class NonContainer {}; 411 412TEST(IsContainerTestTest, WorksForNonContainer) { 413 EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0))); 414 EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0))); 415 EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0))); 416} 417 418TEST(IsContainerTestTest, WorksForContainer) { 419 EXPECT_EQ(sizeof(IsContainer), 420 sizeof(IsContainerTest<std::vector<bool> >(0))); 421 EXPECT_EQ(sizeof(IsContainer), 422 sizeof(IsContainerTest<std::map<int, double> >(0))); 423} 424 425// Tests the TupleMatches() template function. 426 427TEST(TupleMatchesTest, WorksForSize0) { 428 tuple<> matchers; 429 tuple<> values; 430 431 EXPECT_TRUE(TupleMatches(matchers, values)); 432} 433 434TEST(TupleMatchesTest, WorksForSize1) { 435 tuple<Matcher<int> > matchers(Eq(1)); 436 tuple<int> values1(1), 437 values2(2); 438 439 EXPECT_TRUE(TupleMatches(matchers, values1)); 440 EXPECT_FALSE(TupleMatches(matchers, values2)); 441} 442 443TEST(TupleMatchesTest, WorksForSize2) { 444 tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a')); 445 tuple<int, char> values1(1, 'a'), 446 values2(1, 'b'), 447 values3(2, 'a'), 448 values4(2, 'b'); 449 450 EXPECT_TRUE(TupleMatches(matchers, values1)); 451 EXPECT_FALSE(TupleMatches(matchers, values2)); 452 EXPECT_FALSE(TupleMatches(matchers, values3)); 453 EXPECT_FALSE(TupleMatches(matchers, values4)); 454} 455 456TEST(TupleMatchesTest, WorksForSize5) { 457 tuple<Matcher<int>, Matcher<char>, Matcher<bool>, Matcher<long>, // NOLINT 458 Matcher<string> > 459 matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi")); 460 tuple<int, char, bool, long, string> // NOLINT 461 values1(1, 'a', true, 2L, "hi"), 462 values2(1, 'a', true, 2L, "hello"), 463 values3(2, 'a', true, 2L, "hi"); 464 465 EXPECT_TRUE(TupleMatches(matchers, values1)); 466 EXPECT_FALSE(TupleMatches(matchers, values2)); 467 EXPECT_FALSE(TupleMatches(matchers, values3)); 468} 469 470// Tests that Assert(true, ...) succeeds. 471TEST(AssertTest, SucceedsOnTrue) { 472 Assert(true, __FILE__, __LINE__, "This should succeed."); 473 Assert(true, __FILE__, __LINE__); // This should succeed too. 474} 475 476// Tests that Assert(false, ...) generates a fatal failure. 477TEST(AssertTest, FailsFatallyOnFalse) { 478 EXPECT_DEATH_IF_SUPPORTED({ 479 Assert(false, __FILE__, __LINE__, "This should fail."); 480 }, ""); 481 482 EXPECT_DEATH_IF_SUPPORTED({ 483 Assert(false, __FILE__, __LINE__); 484 }, ""); 485} 486 487// Tests that Expect(true, ...) succeeds. 488TEST(ExpectTest, SucceedsOnTrue) { 489 Expect(true, __FILE__, __LINE__, "This should succeed."); 490 Expect(true, __FILE__, __LINE__); // This should succeed too. 491} 492 493// Tests that Expect(false, ...) generates a non-fatal failure. 494TEST(ExpectTest, FailsNonfatallyOnFalse) { 495 EXPECT_NONFATAL_FAILURE({ // NOLINT 496 Expect(false, __FILE__, __LINE__, "This should fail."); 497 }, "This should fail"); 498 499 EXPECT_NONFATAL_FAILURE({ // NOLINT 500 Expect(false, __FILE__, __LINE__); 501 }, "Expectation failed"); 502} 503 504// Tests LogIsVisible(). 505 506class LogIsVisibleTest : public ::testing::Test { 507 protected: 508 virtual void SetUp() { 509 // The code needs to work when both ::string and ::std::string are 510 // defined and the flag is implemented as a 511 // testing::internal::String. In this case, without the call to 512 // c_str(), the compiler will complain that it cannot figure out 513 // whether the String flag should be converted to a ::string or an 514 // ::std::string before being assigned to original_verbose_. 515 original_verbose_ = GMOCK_FLAG(verbose).c_str(); 516 } 517 518 virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; } 519 520 string original_verbose_; 521}; 522 523TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) { 524 GMOCK_FLAG(verbose) = kInfoVerbosity; 525 EXPECT_TRUE(LogIsVisible(INFO)); 526 EXPECT_TRUE(LogIsVisible(WARNING)); 527} 528 529TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) { 530 GMOCK_FLAG(verbose) = kErrorVerbosity; 531 EXPECT_FALSE(LogIsVisible(INFO)); 532 EXPECT_FALSE(LogIsVisible(WARNING)); 533} 534 535TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) { 536 GMOCK_FLAG(verbose) = kWarningVerbosity; 537 EXPECT_FALSE(LogIsVisible(INFO)); 538 EXPECT_TRUE(LogIsVisible(WARNING)); 539} 540 541#if GTEST_HAS_STREAM_REDIRECTION_ 542 543// Tests the Log() function. 544 545// Verifies that Log() behaves correctly for the given verbosity level 546// and log severity. 547void TestLogWithSeverity(const string& verbosity, LogSeverity severity, 548 bool should_print) { 549 const string old_flag = GMOCK_FLAG(verbose); 550 GMOCK_FLAG(verbose) = verbosity; 551 CaptureStdout(); 552 Log(severity, "Test log.\n", 0); 553 if (should_print) { 554 EXPECT_THAT(GetCapturedStdout().c_str(), 555 ContainsRegex( 556 severity == WARNING ? 557 "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" : 558 "^\nTest log\\.\nStack trace:\n")); 559 } else { 560 EXPECT_STREQ("", GetCapturedStdout().c_str()); 561 } 562 GMOCK_FLAG(verbose) = old_flag; 563} 564 565// Tests that when the stack_frames_to_skip parameter is negative, 566// Log() doesn't include the stack trace in the output. 567TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) { 568 GMOCK_FLAG(verbose) = kInfoVerbosity; 569 CaptureStdout(); 570 Log(INFO, "Test log.\n", -1); 571 EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str()); 572} 573 574// Tests that in opt mode, a positive stack_frames_to_skip argument is 575// treated as 0. 576TEST(LogTest, NoSkippingStackFrameInOptMode) { 577 CaptureStdout(); 578 Log(WARNING, "Test log.\n", 100); 579 const String log = GetCapturedStdout(); 580#if defined(NDEBUG) && GTEST_GOOGLE3_MODE_ 581 // In opt mode, no stack frame should be skipped. 582 EXPECT_THAT(log, ContainsRegex("\nGMOCK WARNING:\n" 583 "Test log\\.\n" 584 "Stack trace:\n" 585 ".+")); 586#else 587 // In dbg mode, the stack frames should be skipped. 588 EXPECT_STREQ("\nGMOCK WARNING:\n" 589 "Test log.\n" 590 "Stack trace:\n", log.c_str()); 591#endif 592} 593 594// Tests that all logs are printed when the value of the 595// --gmock_verbose flag is "info". 596TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) { 597 TestLogWithSeverity(kInfoVerbosity, INFO, true); 598 TestLogWithSeverity(kInfoVerbosity, WARNING, true); 599} 600 601// Tests that only warnings are printed when the value of the 602// --gmock_verbose flag is "warning". 603TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) { 604 TestLogWithSeverity(kWarningVerbosity, INFO, false); 605 TestLogWithSeverity(kWarningVerbosity, WARNING, true); 606} 607 608// Tests that no logs are printed when the value of the 609// --gmock_verbose flag is "error". 610TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) { 611 TestLogWithSeverity(kErrorVerbosity, INFO, false); 612 TestLogWithSeverity(kErrorVerbosity, WARNING, false); 613} 614 615// Tests that only warnings are printed when the value of the 616// --gmock_verbose flag is invalid. 617TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) { 618 TestLogWithSeverity("invalid", INFO, false); 619 TestLogWithSeverity("invalid", WARNING, true); 620} 621 622#endif // GTEST_HAS_STREAM_REDIRECTION_ 623 624TEST(TypeTraitsTest, true_type) { 625 EXPECT_TRUE(true_type::value); 626} 627 628TEST(TypeTraitsTest, false_type) { 629 EXPECT_FALSE(false_type::value); 630} 631 632TEST(TypeTraitsTest, is_reference) { 633 EXPECT_FALSE(is_reference<int>::value); 634 EXPECT_FALSE(is_reference<char*>::value); 635 EXPECT_TRUE(is_reference<const int&>::value); 636} 637 638TEST(TypeTraitsTest, is_pointer) { 639 EXPECT_FALSE(is_pointer<int>::value); 640 EXPECT_FALSE(is_pointer<char&>::value); 641 EXPECT_TRUE(is_pointer<const int*>::value); 642} 643 644TEST(TypeTraitsTest, type_equals) { 645 EXPECT_FALSE((type_equals<int, const int>::value)); 646 EXPECT_FALSE((type_equals<int, int&>::value)); 647 EXPECT_FALSE((type_equals<int, double>::value)); 648 EXPECT_TRUE((type_equals<char, char>::value)); 649} 650 651TEST(TypeTraitsTest, remove_reference) { 652 EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value)); 653 EXPECT_TRUE((type_equals<const int, 654 remove_reference<const int&>::type>::value)); 655 EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value)); 656 EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value)); 657} 658 659#if GTEST_HAS_STREAM_REDIRECTION_ 660 661// Verifies that Log() behaves correctly for the given verbosity level 662// and log severity. 663String GrabOutput(void(*logger)(), const char* verbosity) { 664 const string saved_flag = GMOCK_FLAG(verbose); 665 GMOCK_FLAG(verbose) = verbosity; 666 CaptureStdout(); 667 logger(); 668 GMOCK_FLAG(verbose) = saved_flag; 669 return GetCapturedStdout(); 670} 671 672class DummyMock { 673 public: 674 MOCK_METHOD0(TestMethod, void()); 675 MOCK_METHOD1(TestMethodArg, void(int dummy)); 676}; 677 678void ExpectCallLogger() { 679 DummyMock mock; 680 EXPECT_CALL(mock, TestMethod()); 681 mock.TestMethod(); 682}; 683 684// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info". 685TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) { 686 EXPECT_THAT(GrabOutput(ExpectCallLogger, kInfoVerbosity), 687 HasSubstr("EXPECT_CALL(mock, TestMethod())")); 688} 689 690// Verifies that EXPECT_CALL doesn't log 691// if the --gmock_verbose flag is set to "warning". 692TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) { 693 EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str()); 694} 695 696// Verifies that EXPECT_CALL doesn't log 697// if the --gmock_verbose flag is set to "error". 698TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) { 699 EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str()); 700} 701 702void OnCallLogger() { 703 DummyMock mock; 704 ON_CALL(mock, TestMethod()); 705}; 706 707// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info". 708TEST(OnCallTest, LogsWhenVerbosityIsInfo) { 709 EXPECT_THAT(GrabOutput(OnCallLogger, kInfoVerbosity), 710 HasSubstr("ON_CALL(mock, TestMethod())")); 711} 712 713// Verifies that ON_CALL doesn't log 714// if the --gmock_verbose flag is set to "warning". 715TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) { 716 EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str()); 717} 718 719// Verifies that ON_CALL doesn't log if 720// the --gmock_verbose flag is set to "error". 721TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) { 722 EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str()); 723} 724 725void OnCallAnyArgumentLogger() { 726 DummyMock mock; 727 ON_CALL(mock, TestMethodArg(_)); 728} 729 730// Verifies that ON_CALL prints provided _ argument. 731TEST(OnCallTest, LogsAnythingArgument) { 732 EXPECT_THAT(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity), 733 HasSubstr("ON_CALL(mock, TestMethodArg(_)")); 734} 735 736#endif // GTEST_HAS_STREAM_REDIRECTION_ 737 738// Tests ArrayEq(). 739 740TEST(ArrayEqTest, WorksForDegeneratedArrays) { 741 EXPECT_TRUE(ArrayEq(5, 5L)); 742 EXPECT_FALSE(ArrayEq('a', 0)); 743} 744 745TEST(ArrayEqTest, WorksForOneDimensionalArrays) { 746 const int a[] = { 0, 1 }; 747 long b[] = { 0, 1 }; 748 EXPECT_TRUE(ArrayEq(a, b)); 749 EXPECT_TRUE(ArrayEq(a, 2, b)); 750 751 b[0] = 2; 752 EXPECT_FALSE(ArrayEq(a, b)); 753 EXPECT_FALSE(ArrayEq(a, 1, b)); 754} 755 756TEST(ArrayEqTest, WorksForTwoDimensionalArrays) { 757 const char a[][3] = { "hi", "lo" }; 758 const char b[][3] = { "hi", "lo" }; 759 const char c[][3] = { "hi", "li" }; 760 761 EXPECT_TRUE(ArrayEq(a, b)); 762 EXPECT_TRUE(ArrayEq(a, 2, b)); 763 764 EXPECT_FALSE(ArrayEq(a, c)); 765 EXPECT_FALSE(ArrayEq(a, 2, c)); 766} 767 768// Tests ArrayAwareFind(). 769 770TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) { 771 const char a[] = "hello"; 772 EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o')); 773 EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x')); 774} 775 776TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) { 777 int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } }; 778 const int b[2] = { 2, 3 }; 779 EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b)); 780 781 const int c[2] = { 6, 7 }; 782 EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c)); 783} 784 785// Tests CopyArray(). 786 787TEST(CopyArrayTest, WorksForDegeneratedArrays) { 788 int n = 0; 789 CopyArray('a', &n); 790 EXPECT_EQ('a', n); 791} 792 793TEST(CopyArrayTest, WorksForOneDimensionalArrays) { 794 const char a[3] = "hi"; 795 int b[3]; 796 CopyArray(a, &b); 797 EXPECT_TRUE(ArrayEq(a, b)); 798 799 int c[3]; 800 CopyArray(a, 3, c); 801 EXPECT_TRUE(ArrayEq(a, c)); 802} 803 804TEST(CopyArrayTest, WorksForTwoDimensionalArrays) { 805 const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } }; 806 int b[2][3]; 807 CopyArray(a, &b); 808 EXPECT_TRUE(ArrayEq(a, b)); 809 810 int c[2][3]; 811 CopyArray(a, 2, c); 812 EXPECT_TRUE(ArrayEq(a, c)); 813} 814 815// Tests NativeArray. 816 817TEST(NativeArrayTest, ConstructorFromArrayWorks) { 818 const int a[3] = { 0, 1, 2 }; 819 NativeArray<int> na(a, 3, kReference); 820 EXPECT_EQ(3U, na.size()); 821 EXPECT_EQ(a, na.begin()); 822} 823 824TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) { 825 typedef int Array[2]; 826 Array* a = new Array[1]; 827 (*a)[0] = 0; 828 (*a)[1] = 1; 829 NativeArray<int> na(*a, 2, kCopy); 830 EXPECT_NE(*a, na.begin()); 831 delete[] a; 832 EXPECT_EQ(0, na.begin()[0]); 833 EXPECT_EQ(1, na.begin()[1]); 834 835 // We rely on the heap checker to verify that na deletes the copy of 836 // array. 837} 838 839TEST(NativeArrayTest, TypeMembersAreCorrect) { 840 StaticAssertTypeEq<char, NativeArray<char>::value_type>(); 841 StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>(); 842 843 StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>(); 844 StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>(); 845} 846 847TEST(NativeArrayTest, MethodsWork) { 848 const int a[3] = { 0, 1, 2 }; 849 NativeArray<int> na(a, 3, kCopy); 850 ASSERT_EQ(3U, na.size()); 851 EXPECT_EQ(3, na.end() - na.begin()); 852 853 NativeArray<int>::const_iterator it = na.begin(); 854 EXPECT_EQ(0, *it); 855 ++it; 856 EXPECT_EQ(1, *it); 857 it++; 858 EXPECT_EQ(2, *it); 859 ++it; 860 EXPECT_EQ(na.end(), it); 861 862 EXPECT_THAT(na, Eq(na)); 863 864 NativeArray<int> na2(a, 3, kReference); 865 EXPECT_THAT(na, Eq(na2)); 866 867 const int b1[3] = { 0, 1, 1 }; 868 const int b2[4] = { 0, 1, 2, 3 }; 869 EXPECT_THAT(na, Not(Eq(NativeArray<int>(b1, 3, kReference)))); 870 EXPECT_THAT(na, Not(Eq(NativeArray<int>(b2, 4, kCopy)))); 871} 872 873TEST(NativeArrayTest, WorksForTwoDimensionalArray) { 874 const char a[2][3] = { "hi", "lo" }; 875 NativeArray<char[3]> na(a, 2, kReference); 876 ASSERT_EQ(2U, na.size()); 877 EXPECT_EQ(a, na.begin()); 878} 879 880// Tests StlContainerView. 881 882TEST(StlContainerViewTest, WorksForStlContainer) { 883 StaticAssertTypeEq<std::vector<int>, 884 StlContainerView<std::vector<int> >::type>(); 885 StaticAssertTypeEq<const std::vector<double>&, 886 StlContainerView<std::vector<double> >::const_reference>(); 887 888 typedef std::vector<char> Chars; 889 Chars v1; 890 const Chars& v2(StlContainerView<Chars>::ConstReference(v1)); 891 EXPECT_EQ(&v1, &v2); 892 893 v1.push_back('a'); 894 Chars v3 = StlContainerView<Chars>::Copy(v1); 895 EXPECT_THAT(v3, Eq(v3)); 896} 897 898TEST(StlContainerViewTest, WorksForStaticNativeArray) { 899 StaticAssertTypeEq<NativeArray<int>, 900 StlContainerView<int[3]>::type>(); 901 StaticAssertTypeEq<NativeArray<double>, 902 StlContainerView<const double[4]>::type>(); 903 StaticAssertTypeEq<NativeArray<char[3]>, 904 StlContainerView<const char[2][3]>::type>(); 905 906 StaticAssertTypeEq<const NativeArray<int>, 907 StlContainerView<int[2]>::const_reference>(); 908 909 int a1[3] = { 0, 1, 2 }; 910 NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1); 911 EXPECT_EQ(3U, a2.size()); 912 EXPECT_EQ(a1, a2.begin()); 913 914 const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1); 915 ASSERT_EQ(3U, a3.size()); 916 EXPECT_EQ(0, a3.begin()[0]); 917 EXPECT_EQ(1, a3.begin()[1]); 918 EXPECT_EQ(2, a3.begin()[2]); 919 920 // Makes sure a1 and a3 aren't aliases. 921 a1[0] = 3; 922 EXPECT_EQ(0, a3.begin()[0]); 923} 924 925TEST(StlContainerViewTest, WorksForDynamicNativeArray) { 926 StaticAssertTypeEq<NativeArray<int>, 927 StlContainerView<tuple<const int*, size_t> >::type>(); 928 StaticAssertTypeEq<NativeArray<double>, 929 StlContainerView<tuple<linked_ptr<double>, int> >::type>(); 930 931 StaticAssertTypeEq<const NativeArray<int>, 932 StlContainerView<tuple<const int*, int> >::const_reference>(); 933 934 int a1[3] = { 0, 1, 2 }; 935 const int* const p1 = a1; 936 NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >:: 937 ConstReference(make_tuple(p1, 3)); 938 EXPECT_EQ(3U, a2.size()); 939 EXPECT_EQ(a1, a2.begin()); 940 941 const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >:: 942 Copy(make_tuple(static_cast<int*>(a1), 3)); 943 ASSERT_EQ(3U, a3.size()); 944 EXPECT_EQ(0, a3.begin()[0]); 945 EXPECT_EQ(1, a3.begin()[1]); 946 EXPECT_EQ(2, a3.begin()[2]); 947 948 // Makes sure a1 and a3 aren't aliases. 949 a1[0] = 3; 950 EXPECT_EQ(0, a3.begin()[0]); 951} 952 953} // namespace 954} // namespace internal 955} // namespace testing 956