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