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// Google Mock - a framework for writing C++ mock classes. 31// 32// This file tests the internal utilities. 33 34#include "gmock/internal/gmock-internal-utils.h" 35 36#include <stdlib.h> 37 38#include <cstdint> 39#include <map> 40#include <memory> 41#include <sstream> 42#include <string> 43#include <tuple> 44#include <vector> 45 46#include "gmock/gmock.h" 47#include "gmock/internal/gmock-port.h" 48#include "gtest/gtest-spi.h" 49#include "gtest/gtest.h" 50 51// Indicates that this translation unit is part of Google Test's 52// implementation. It must come before gtest-internal-inl.h is 53// included, or there will be a compiler error. This trick is to 54// prevent a user from accidentally including gtest-internal-inl.h in 55// their code. 56#define GTEST_IMPLEMENTATION_ 1 57#include "src/gtest-internal-inl.h" 58#undef GTEST_IMPLEMENTATION_ 59 60#ifdef GTEST_OS_CYGWIN 61#include <sys/types.h> // For ssize_t. NOLINT 62#endif 63 64namespace proto2 { 65class Message; 66} // namespace proto2 67 68namespace testing { 69namespace internal { 70 71namespace { 72 73TEST(JoinAsKeyValueTupleTest, JoinsEmptyTuple) { 74 EXPECT_EQ("", JoinAsKeyValueTuple({}, Strings())); 75} 76 77TEST(JoinAsKeyValueTupleTest, JoinsOneTuple) { 78 EXPECT_EQ("(a: 1)", JoinAsKeyValueTuple({"a"}, {"1"})); 79} 80 81TEST(JoinAsKeyValueTupleTest, JoinsTwoTuple) { 82 EXPECT_EQ("(a: 1, b: 2)", JoinAsKeyValueTuple({"a", "b"}, {"1", "2"})); 83} 84 85TEST(JoinAsKeyValueTupleTest, JoinsTenTuple) { 86 EXPECT_EQ( 87 "(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10)", 88 JoinAsKeyValueTuple({"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}, 89 {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"})); 90} 91 92TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) { 93 EXPECT_EQ("", ConvertIdentifierNameToWords("")); 94 EXPECT_EQ("", ConvertIdentifierNameToWords("_")); 95 EXPECT_EQ("", ConvertIdentifierNameToWords("__")); 96} 97 98TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) { 99 EXPECT_EQ("1", ConvertIdentifierNameToWords("_1")); 100 EXPECT_EQ("2", ConvertIdentifierNameToWords("2_")); 101 EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_")); 102 EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56")); 103} 104 105TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) { 106 EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord")); 107 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar")); 108 EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_")); 109 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_")); 110 EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar")); 111} 112 113TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) { 114 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar")); 115 EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_")); 116 EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_")); 117 EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar")); 118} 119 120TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) { 121 EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123")); 122 EXPECT_EQ("chapter 11 section 1", 123 ConvertIdentifierNameToWords("_Chapter11Section_1_")); 124} 125 126TEST(GetRawPointerTest, WorksForSmartPointers) { 127 const char* const raw_p1 = new const char('a'); // NOLINT 128 const std::unique_ptr<const char> p1(raw_p1); 129 EXPECT_EQ(raw_p1, GetRawPointer(p1)); 130 double* const raw_p2 = new double(2.5); // NOLINT 131 const std::shared_ptr<double> p2(raw_p2); 132 EXPECT_EQ(raw_p2, GetRawPointer(p2)); 133} 134 135TEST(GetRawPointerTest, WorksForRawPointers) { 136 int* p = nullptr; 137 EXPECT_TRUE(nullptr == GetRawPointer(p)); 138 int n = 1; 139 EXPECT_EQ(&n, GetRawPointer(&n)); 140} 141 142TEST(GetRawPointerTest, WorksForStdReferenceWrapper) { 143 int n = 1; 144 EXPECT_EQ(&n, GetRawPointer(std::ref(n))); 145 EXPECT_EQ(&n, GetRawPointer(std::cref(n))); 146} 147 148// Tests KindOf<T>. 149 150class Base {}; 151class Derived : public Base {}; 152 153TEST(KindOfTest, Bool) { 154 EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool)); // NOLINT 155} 156 157TEST(KindOfTest, Integer) { 158 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char)); // NOLINT 159 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char)); // NOLINT 160 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char)); // NOLINT 161 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short)); // NOLINT 162 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short)); // NOLINT 163 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int)); // NOLINT 164 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int)); // NOLINT 165 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long)); // NOLINT 166 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long)); // NOLINT 167 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long long)); // NOLINT 168 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long long)); // NOLINT 169 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT 170 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT 171#if defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) || defined(GTEST_OS_CYGWIN) 172 // ssize_t is not defined on Windows and possibly some other OSes. 173 EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT 174#endif 175} 176 177TEST(KindOfTest, FloatingPoint) { 178 EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float)); // NOLINT 179 EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double)); // NOLINT 180 EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double)); // NOLINT 181} 182 183TEST(KindOfTest, Other) { 184 EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*)); // NOLINT 185 EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**)); // NOLINT 186 EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base)); // NOLINT 187} 188 189// Tests LosslessArithmeticConvertible<T, U>. 190 191TEST(LosslessArithmeticConvertibleTest, BoolToBool) { 192 EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value)); 193} 194 195TEST(LosslessArithmeticConvertibleTest, BoolToInteger) { 196 EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value)); 197 EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value)); 198 EXPECT_TRUE( 199 (LosslessArithmeticConvertible<bool, unsigned long>::value)); // NOLINT 200} 201 202TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) { 203 EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value)); 204 EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value)); 205} 206 207TEST(LosslessArithmeticConvertibleTest, IntegerToBool) { 208 EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value)); 209 EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value)); 210} 211 212TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) { 213 // Unsigned => larger signed is fine. 214 EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value)); 215 216 // Unsigned => larger unsigned is fine. 217 EXPECT_TRUE((LosslessArithmeticConvertible<unsigned short, 218 uint64_t>::value)); // NOLINT 219 220 // Signed => unsigned is not fine. 221 EXPECT_FALSE( 222 (LosslessArithmeticConvertible<short, uint64_t>::value)); // NOLINT 223 EXPECT_FALSE((LosslessArithmeticConvertible<signed char, 224 unsigned int>::value)); // NOLINT 225 226 // Same size and same signedness: fine too. 227 EXPECT_TRUE( 228 (LosslessArithmeticConvertible<unsigned char, unsigned char>::value)); 229 EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value)); 230 EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value)); 231 EXPECT_TRUE((LosslessArithmeticConvertible<unsigned long, 232 unsigned long>::value)); // NOLINT 233 234 // Same size, different signedness: not fine. 235 EXPECT_FALSE( 236 (LosslessArithmeticConvertible<unsigned char, signed char>::value)); 237 EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value)); 238 EXPECT_FALSE((LosslessArithmeticConvertible<uint64_t, int64_t>::value)); 239 240 // Larger size => smaller size is not fine. 241 EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value)); // NOLINT 242 EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value)); 243 EXPECT_FALSE((LosslessArithmeticConvertible<int64_t, unsigned int>::value)); 244} 245 246TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) { 247 // Integers cannot be losslessly converted to floating-points, as 248 // the format of the latter is implementation-defined. 249 EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value)); 250 EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value)); 251 EXPECT_FALSE( 252 (LosslessArithmeticConvertible<short, long double>::value)); // NOLINT 253} 254 255TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) { 256 EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value)); 257 EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value)); 258} 259 260TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) { 261 EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value)); // NOLINT 262 EXPECT_FALSE((LosslessArithmeticConvertible<double, int64_t>::value)); 263 EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value)); 264} 265 266TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) { 267 // Smaller size => larger size is fine. 268 EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value)); 269 EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value)); 270 EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value)); 271 272 // Same size: fine. 273 EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value)); 274 EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value)); 275 276 // Larger size => smaller size is not fine. 277 EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value)); 278 GTEST_INTENTIONAL_CONST_COND_PUSH_() 279 if (sizeof(double) == sizeof(long double)) { // NOLINT 280 GTEST_INTENTIONAL_CONST_COND_POP_() 281 // In some implementations (e.g. MSVC), double and long double 282 // have the same size. 283 EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value)); 284 } else { 285 EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value)); 286 } 287} 288 289// Tests the TupleMatches() template function. 290 291TEST(TupleMatchesTest, WorksForSize0) { 292 std::tuple<> matchers; 293 std::tuple<> values; 294 295 EXPECT_TRUE(TupleMatches(matchers, values)); 296} 297 298TEST(TupleMatchesTest, WorksForSize1) { 299 std::tuple<Matcher<int>> matchers(Eq(1)); 300 std::tuple<int> values1(1), values2(2); 301 302 EXPECT_TRUE(TupleMatches(matchers, values1)); 303 EXPECT_FALSE(TupleMatches(matchers, values2)); 304} 305 306TEST(TupleMatchesTest, WorksForSize2) { 307 std::tuple<Matcher<int>, Matcher<char>> matchers(Eq(1), Eq('a')); 308 std::tuple<int, char> values1(1, 'a'), values2(1, 'b'), values3(2, 'a'), 309 values4(2, 'b'); 310 311 EXPECT_TRUE(TupleMatches(matchers, values1)); 312 EXPECT_FALSE(TupleMatches(matchers, values2)); 313 EXPECT_FALSE(TupleMatches(matchers, values3)); 314 EXPECT_FALSE(TupleMatches(matchers, values4)); 315} 316 317TEST(TupleMatchesTest, WorksForSize5) { 318 std::tuple<Matcher<int>, Matcher<char>, Matcher<bool>, 319 Matcher<long>, // NOLINT 320 Matcher<std::string>> 321 matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi")); 322 std::tuple<int, char, bool, long, std::string> // NOLINT 323 values1(1, 'a', true, 2L, "hi"), values2(1, 'a', true, 2L, "hello"), 324 values3(2, 'a', true, 2L, "hi"); 325 326 EXPECT_TRUE(TupleMatches(matchers, values1)); 327 EXPECT_FALSE(TupleMatches(matchers, values2)); 328 EXPECT_FALSE(TupleMatches(matchers, values3)); 329} 330 331// Tests that Assert(true, ...) succeeds. 332TEST(AssertTest, SucceedsOnTrue) { 333 Assert(true, __FILE__, __LINE__, "This should succeed."); 334 Assert(true, __FILE__, __LINE__); // This should succeed too. 335} 336 337// Tests that Assert(false, ...) generates a fatal failure. 338TEST(AssertTest, FailsFatallyOnFalse) { 339 EXPECT_DEATH_IF_SUPPORTED( 340 { Assert(false, __FILE__, __LINE__, "This should fail."); }, ""); 341 342 EXPECT_DEATH_IF_SUPPORTED({ Assert(false, __FILE__, __LINE__); }, ""); 343} 344 345// Tests that Expect(true, ...) succeeds. 346TEST(ExpectTest, SucceedsOnTrue) { 347 Expect(true, __FILE__, __LINE__, "This should succeed."); 348 Expect(true, __FILE__, __LINE__); // This should succeed too. 349} 350 351// Tests that Expect(false, ...) generates a non-fatal failure. 352TEST(ExpectTest, FailsNonfatallyOnFalse) { 353 EXPECT_NONFATAL_FAILURE( 354 { // NOLINT 355 Expect(false, __FILE__, __LINE__, "This should fail."); 356 }, 357 "This should fail"); 358 359 EXPECT_NONFATAL_FAILURE( 360 { // NOLINT 361 Expect(false, __FILE__, __LINE__); 362 }, 363 "Expectation failed"); 364} 365 366// Tests LogIsVisible(). 367 368class LogIsVisibleTest : public ::testing::Test { 369 protected: 370 void SetUp() override { original_verbose_ = GMOCK_FLAG_GET(verbose); } 371 372 void TearDown() override { GMOCK_FLAG_SET(verbose, original_verbose_); } 373 374 std::string original_verbose_; 375}; 376 377TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) { 378 GMOCK_FLAG_SET(verbose, kInfoVerbosity); 379 EXPECT_TRUE(LogIsVisible(kInfo)); 380 EXPECT_TRUE(LogIsVisible(kWarning)); 381} 382 383TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) { 384 GMOCK_FLAG_SET(verbose, kErrorVerbosity); 385 EXPECT_FALSE(LogIsVisible(kInfo)); 386 EXPECT_FALSE(LogIsVisible(kWarning)); 387} 388 389TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) { 390 GMOCK_FLAG_SET(verbose, kWarningVerbosity); 391 EXPECT_FALSE(LogIsVisible(kInfo)); 392 EXPECT_TRUE(LogIsVisible(kWarning)); 393} 394 395#if GTEST_HAS_STREAM_REDIRECTION 396 397// Tests the Log() function. 398 399// Verifies that Log() behaves correctly for the given verbosity level 400// and log severity. 401void TestLogWithSeverity(const std::string& verbosity, LogSeverity severity, 402 bool should_print) { 403 const std::string old_flag = GMOCK_FLAG_GET(verbose); 404 GMOCK_FLAG_SET(verbose, verbosity); 405 CaptureStdout(); 406 Log(severity, "Test log.\n", 0); 407 if (should_print) { 408 EXPECT_THAT( 409 GetCapturedStdout().c_str(), 410 ContainsRegex(severity == kWarning 411 ? "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" 412 : "^\nTest log\\.\nStack trace:\n")); 413 } else { 414 EXPECT_STREQ("", GetCapturedStdout().c_str()); 415 } 416 GMOCK_FLAG_SET(verbose, old_flag); 417} 418 419// Tests that when the stack_frames_to_skip parameter is negative, 420// Log() doesn't include the stack trace in the output. 421TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) { 422 const std::string saved_flag = GMOCK_FLAG_GET(verbose); 423 GMOCK_FLAG_SET(verbose, kInfoVerbosity); 424 CaptureStdout(); 425 Log(kInfo, "Test log.\n", -1); 426 EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str()); 427 GMOCK_FLAG_SET(verbose, saved_flag); 428} 429 430struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface { 431 std::string CurrentStackTrace(int max_depth, int skip_count) override { 432 return (testing::Message() << max_depth << "::" << skip_count << "\n") 433 .GetString(); 434 } 435 void UponLeavingGTest() override {} 436}; 437 438// Tests that in opt mode, a positive stack_frames_to_skip argument is 439// treated as 0. 440TEST(LogTest, NoSkippingStackFrameInOptMode) { 441 MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter; 442 GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter); 443 444 CaptureStdout(); 445 Log(kWarning, "Test log.\n", 100); 446 const std::string log = GetCapturedStdout(); 447 448 std::string expected_trace = 449 (testing::Message() << GTEST_FLAG_GET(stack_trace_depth) << "::") 450 .GetString(); 451 std::string expected_message = 452 "\nGMOCK WARNING:\n" 453 "Test log.\n" 454 "Stack trace:\n" + 455 expected_trace; 456 EXPECT_THAT(log, HasSubstr(expected_message)); 457 int skip_count = atoi(log.substr(expected_message.size()).c_str()); 458 459#if defined(NDEBUG) 460 // In opt mode, no stack frame should be skipped. 461 const int expected_skip_count = 0; 462#else 463 // In dbg mode, the stack frames should be skipped. 464 const int expected_skip_count = 100; 465#endif 466 467 // Note that each inner implementation layer will +1 the number to remove 468 // itself from the trace. This means that the value is a little higher than 469 // expected, but close enough. 470 EXPECT_THAT(skip_count, 471 AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10))); 472 473 // Restores the default OS stack trace getter. 474 GetUnitTestImpl()->set_os_stack_trace_getter(nullptr); 475} 476 477// Tests that all logs are printed when the value of the 478// --gmock_verbose flag is "info". 479TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) { 480 TestLogWithSeverity(kInfoVerbosity, kInfo, true); 481 TestLogWithSeverity(kInfoVerbosity, kWarning, true); 482} 483 484// Tests that only warnings are printed when the value of the 485// --gmock_verbose flag is "warning". 486TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) { 487 TestLogWithSeverity(kWarningVerbosity, kInfo, false); 488 TestLogWithSeverity(kWarningVerbosity, kWarning, true); 489} 490 491// Tests that no logs are printed when the value of the 492// --gmock_verbose flag is "error". 493TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) { 494 TestLogWithSeverity(kErrorVerbosity, kInfo, false); 495 TestLogWithSeverity(kErrorVerbosity, kWarning, false); 496} 497 498// Tests that only warnings are printed when the value of the 499// --gmock_verbose flag is invalid. 500TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) { 501 TestLogWithSeverity("invalid", kInfo, false); 502 TestLogWithSeverity("invalid", kWarning, true); 503} 504 505// Verifies that Log() behaves correctly for the given verbosity level 506// and log severity. 507std::string GrabOutput(void (*logger)(), const char* verbosity) { 508 const std::string saved_flag = GMOCK_FLAG_GET(verbose); 509 GMOCK_FLAG_SET(verbose, verbosity); 510 CaptureStdout(); 511 logger(); 512 GMOCK_FLAG_SET(verbose, saved_flag); 513 return GetCapturedStdout(); 514} 515 516class DummyMock { 517 public: 518 MOCK_METHOD0(TestMethod, void()); 519 MOCK_METHOD1(TestMethodArg, void(int dummy)); 520}; 521 522void ExpectCallLogger() { 523 DummyMock mock; 524 EXPECT_CALL(mock, TestMethod()); 525 mock.TestMethod(); 526} 527 528// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info". 529TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) { 530 EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)), 531 HasSubstr("EXPECT_CALL(mock, TestMethod())")); 532} 533 534// Verifies that EXPECT_CALL doesn't log 535// if the --gmock_verbose flag is set to "warning". 536TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) { 537 EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str()); 538} 539 540// Verifies that EXPECT_CALL doesn't log 541// if the --gmock_verbose flag is set to "error". 542TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) { 543 EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str()); 544} 545 546void OnCallLogger() { 547 DummyMock mock; 548 ON_CALL(mock, TestMethod()); 549} 550 551// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info". 552TEST(OnCallTest, LogsWhenVerbosityIsInfo) { 553 EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)), 554 HasSubstr("ON_CALL(mock, TestMethod())")); 555} 556 557// Verifies that ON_CALL doesn't log 558// if the --gmock_verbose flag is set to "warning". 559TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) { 560 EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str()); 561} 562 563// Verifies that ON_CALL doesn't log if 564// the --gmock_verbose flag is set to "error". 565TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) { 566 EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str()); 567} 568 569void OnCallAnyArgumentLogger() { 570 DummyMock mock; 571 ON_CALL(mock, TestMethodArg(_)); 572} 573 574// Verifies that ON_CALL prints provided _ argument. 575TEST(OnCallTest, LogsAnythingArgument) { 576 EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)), 577 HasSubstr("ON_CALL(mock, TestMethodArg(_)")); 578} 579 580#endif // GTEST_HAS_STREAM_REDIRECTION 581 582// Tests StlContainerView. 583 584TEST(StlContainerViewTest, WorksForStlContainer) { 585 StaticAssertTypeEq<std::vector<int>, 586 StlContainerView<std::vector<int>>::type>(); 587 StaticAssertTypeEq<const std::vector<double>&, 588 StlContainerView<std::vector<double>>::const_reference>(); 589 590 typedef std::vector<char> Chars; 591 Chars v1; 592 const Chars& v2(StlContainerView<Chars>::ConstReference(v1)); 593 EXPECT_EQ(&v1, &v2); 594 595 v1.push_back('a'); 596 Chars v3 = StlContainerView<Chars>::Copy(v1); 597 EXPECT_THAT(v3, Eq(v3)); 598} 599 600TEST(StlContainerViewTest, WorksForStaticNativeArray) { 601 StaticAssertTypeEq<NativeArray<int>, StlContainerView<int[3]>::type>(); 602 StaticAssertTypeEq<NativeArray<double>, 603 StlContainerView<const double[4]>::type>(); 604 StaticAssertTypeEq<NativeArray<char[3]>, 605 StlContainerView<const char[2][3]>::type>(); 606 607 StaticAssertTypeEq<const NativeArray<int>, 608 StlContainerView<int[2]>::const_reference>(); 609 610 int a1[3] = {0, 1, 2}; 611 NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1); 612 EXPECT_EQ(3U, a2.size()); 613 EXPECT_EQ(a1, a2.begin()); 614 615 const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1); 616 ASSERT_EQ(3U, a3.size()); 617 EXPECT_EQ(0, a3.begin()[0]); 618 EXPECT_EQ(1, a3.begin()[1]); 619 EXPECT_EQ(2, a3.begin()[2]); 620 621 // Makes sure a1 and a3 aren't aliases. 622 a1[0] = 3; 623 EXPECT_EQ(0, a3.begin()[0]); 624} 625 626TEST(StlContainerViewTest, WorksForDynamicNativeArray) { 627 StaticAssertTypeEq<NativeArray<int>, 628 StlContainerView<std::tuple<const int*, size_t>>::type>(); 629 StaticAssertTypeEq< 630 NativeArray<double>, 631 StlContainerView<std::tuple<std::shared_ptr<double>, int>>::type>(); 632 633 StaticAssertTypeEq< 634 const NativeArray<int>, 635 StlContainerView<std::tuple<const int*, int>>::const_reference>(); 636 637 int a1[3] = {0, 1, 2}; 638 const int* const p1 = a1; 639 NativeArray<int> a2 = 640 StlContainerView<std::tuple<const int*, int>>::ConstReference( 641 std::make_tuple(p1, 3)); 642 EXPECT_EQ(3U, a2.size()); 643 EXPECT_EQ(a1, a2.begin()); 644 645 const NativeArray<int> a3 = StlContainerView<std::tuple<int*, size_t>>::Copy( 646 std::make_tuple(static_cast<int*>(a1), 3)); 647 ASSERT_EQ(3U, a3.size()); 648 EXPECT_EQ(0, a3.begin()[0]); 649 EXPECT_EQ(1, a3.begin()[1]); 650 EXPECT_EQ(2, a3.begin()[2]); 651 652 // Makes sure a1 and a3 aren't aliases. 653 a1[0] = 3; 654 EXPECT_EQ(0, a3.begin()[0]); 655} 656 657// Tests the Function template struct. 658 659TEST(FunctionTest, Nullary) { 660 typedef Function<int()> F; // NOLINT 661 EXPECT_EQ(0u, F::ArgumentCount); 662 EXPECT_TRUE((std::is_same<int, F::Result>::value)); 663 EXPECT_TRUE((std::is_same<std::tuple<>, F::ArgumentTuple>::value)); 664 EXPECT_TRUE((std::is_same<std::tuple<>, F::ArgumentMatcherTuple>::value)); 665 EXPECT_TRUE((std::is_same<void(), F::MakeResultVoid>::value)); 666 EXPECT_TRUE((std::is_same<IgnoredValue(), F::MakeResultIgnoredValue>::value)); 667} 668 669TEST(FunctionTest, Unary) { 670 typedef Function<int(bool)> F; // NOLINT 671 EXPECT_EQ(1u, F::ArgumentCount); 672 EXPECT_TRUE((std::is_same<int, F::Result>::value)); 673 EXPECT_TRUE((std::is_same<bool, F::Arg<0>::type>::value)); 674 EXPECT_TRUE((std::is_same<std::tuple<bool>, F::ArgumentTuple>::value)); 675 EXPECT_TRUE(( 676 std::is_same<std::tuple<Matcher<bool>>, F::ArgumentMatcherTuple>::value)); 677 EXPECT_TRUE((std::is_same<void(bool), F::MakeResultVoid>::value)); // NOLINT 678 EXPECT_TRUE((std::is_same<IgnoredValue(bool), // NOLINT 679 F::MakeResultIgnoredValue>::value)); 680} 681 682TEST(FunctionTest, Binary) { 683 typedef Function<int(bool, const long&)> F; // NOLINT 684 EXPECT_EQ(2u, F::ArgumentCount); 685 EXPECT_TRUE((std::is_same<int, F::Result>::value)); 686 EXPECT_TRUE((std::is_same<bool, F::Arg<0>::type>::value)); 687 EXPECT_TRUE((std::is_same<const long&, F::Arg<1>::type>::value)); // NOLINT 688 EXPECT_TRUE((std::is_same<std::tuple<bool, const long&>, // NOLINT 689 F::ArgumentTuple>::value)); 690 EXPECT_TRUE( 691 (std::is_same<std::tuple<Matcher<bool>, Matcher<const long&>>, // NOLINT 692 F::ArgumentMatcherTuple>::value)); 693 EXPECT_TRUE((std::is_same<void(bool, const long&), // NOLINT 694 F::MakeResultVoid>::value)); 695 EXPECT_TRUE((std::is_same<IgnoredValue(bool, const long&), // NOLINT 696 F::MakeResultIgnoredValue>::value)); 697} 698 699TEST(FunctionTest, LongArgumentList) { 700 typedef Function<char(bool, int, char*, int&, const long&)> F; // NOLINT 701 EXPECT_EQ(5u, F::ArgumentCount); 702 EXPECT_TRUE((std::is_same<char, F::Result>::value)); 703 EXPECT_TRUE((std::is_same<bool, F::Arg<0>::type>::value)); 704 EXPECT_TRUE((std::is_same<int, F::Arg<1>::type>::value)); 705 EXPECT_TRUE((std::is_same<char*, F::Arg<2>::type>::value)); 706 EXPECT_TRUE((std::is_same<int&, F::Arg<3>::type>::value)); 707 EXPECT_TRUE((std::is_same<const long&, F::Arg<4>::type>::value)); // NOLINT 708 EXPECT_TRUE( 709 (std::is_same<std::tuple<bool, int, char*, int&, const long&>, // NOLINT 710 F::ArgumentTuple>::value)); 711 EXPECT_TRUE( 712 (std::is_same< 713 std::tuple<Matcher<bool>, Matcher<int>, Matcher<char*>, Matcher<int&>, 714 Matcher<const long&>>, // NOLINT 715 F::ArgumentMatcherTuple>::value)); 716 EXPECT_TRUE( 717 (std::is_same<void(bool, int, char*, int&, const long&), // NOLINT 718 F::MakeResultVoid>::value)); 719 EXPECT_TRUE(( 720 std::is_same<IgnoredValue(bool, int, char*, int&, const long&), // NOLINT 721 F::MakeResultIgnoredValue>::value)); 722} 723 724TEST(Base64Unescape, InvalidString) { 725 std::string unescaped; 726 EXPECT_FALSE(Base64Unescape("(invalid)", &unescaped)); 727} 728 729TEST(Base64Unescape, ShortString) { 730 std::string unescaped; 731 EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQh", &unescaped)); 732 EXPECT_EQ("Hello world!", unescaped); 733} 734 735TEST(Base64Unescape, ShortStringWithPadding) { 736 std::string unescaped; 737 EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ=", &unescaped)); 738 EXPECT_EQ("Hello world", unescaped); 739} 740 741TEST(Base64Unescape, ShortStringWithoutPadding) { 742 std::string unescaped; 743 EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ", &unescaped)); 744 EXPECT_EQ("Hello world", unescaped); 745} 746 747TEST(Base64Unescape, LongStringWithWhiteSpaces) { 748 std::string escaped = 749 R"(TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz 750 IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg 751 dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu 752 dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo 753 ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=)"; 754 std::string expected = 755 "Man is distinguished, not only by his reason, but by this singular " 756 "passion from other animals, which is a lust of the mind, that by a " 757 "perseverance of delight in the continued and indefatigable generation " 758 "of knowledge, exceeds the short vehemence of any carnal pleasure."; 759 std::string unescaped; 760 EXPECT_TRUE(Base64Unescape(escaped, &unescaped)); 761 EXPECT_EQ(expected, unescaped); 762} 763 764} // namespace 765} // namespace internal 766} // namespace testing 767