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 64 namespace proto2 { 65 class Message; 66 } // namespace proto2 67 68 namespace testing { 69 namespace internal { 70 71 namespace { 72 73 TEST(JoinAsKeyValueTupleTest, JoinsEmptyTuple) { 74 EXPECT_EQ("", JoinAsKeyValueTuple({}, Strings())); 75 } 76 77 TEST(JoinAsKeyValueTupleTest, JoinsOneTuple) { 78 EXPECT_EQ("(a: 1)", JoinAsKeyValueTuple({"a"}, {"1"})); 79 } 80 81 TEST(JoinAsKeyValueTupleTest, JoinsTwoTuple) { 82 EXPECT_EQ("(a: 1, b: 2)", JoinAsKeyValueTuple({"a", "b"}, {"1", "2"})); 83 } 84 85 TEST(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 92 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) { 93 EXPECT_EQ("", ConvertIdentifierNameToWords("")); 94 EXPECT_EQ("", ConvertIdentifierNameToWords("_")); 95 EXPECT_EQ("", ConvertIdentifierNameToWords("__")); 96 } 97 98 TEST(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 105 TEST(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 113 TEST(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 120 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) { 121 EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123")); 122 EXPECT_EQ("chapter 11 section 1", 123 ConvertIdentifierNameToWords("_Chapter11Section_1_")); 124 } 125 126 TEST(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 135 TEST(GetRawPointerTest, WorksForRawPointers) { 136 int* p = nullptr; 137 EXPECT_TRUE(nullptr == GetRawPointer(p)); 138 int n = 1; 139 EXPECT_EQ(&n, GetRawPointer(&n)); 140 } 141 142 TEST(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 150 class Base {}; 151 class Derived : public Base {}; 152 153 TEST(KindOfTest, Bool) { 154 EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool)); // NOLINT 155 } 156 157 TEST(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 177 TEST(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 183 TEST(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 191 TEST(LosslessArithmeticConvertibleTest, BoolToBool) { 192 EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value)); 193 } 194 195 TEST(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 202 TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) { 203 EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value)); 204 EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value)); 205 } 206 207 TEST(LosslessArithmeticConvertibleTest, IntegerToBool) { 208 EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value)); 209 EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value)); 210 } 211 212 TEST(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 246 TEST(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 255 TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) { 256 EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value)); 257 EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value)); 258 } 259 260 TEST(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 266 TEST(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 291 TEST(TupleMatchesTest, WorksForSize0) { 292 std::tuple<> matchers; 293 std::tuple<> values; 294 295 EXPECT_TRUE(TupleMatches(matchers, values)); 296 } 297 298 TEST(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 306 TEST(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 317 TEST(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. 332 TEST(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. 338 TEST(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. 346 TEST(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. 352 TEST(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 368 class 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 377 TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) { 378 GMOCK_FLAG_SET(verbose, kInfoVerbosity); 379 EXPECT_TRUE(LogIsVisible(kInfo)); 380 EXPECT_TRUE(LogIsVisible(kWarning)); 381 } 382 383 TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) { 384 GMOCK_FLAG_SET(verbose, kErrorVerbosity); 385 EXPECT_FALSE(LogIsVisible(kInfo)); 386 EXPECT_FALSE(LogIsVisible(kWarning)); 387 } 388 389 TEST_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. 401 void 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. 421 TEST(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 430 struct 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. 440 TEST(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". 479 TEST(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". 486 TEST(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". 493 TEST(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. 500 TEST(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. 507 std::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 516 class DummyMock { 517 public: 518 MOCK_METHOD0(TestMethod, void()); 519 MOCK_METHOD1(TestMethodArg, void(int dummy)); 520 }; 521 522 void 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". 529 TEST(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". 536 TEST(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". 542 TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) { 543 EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str()); 544 } 545 546 void 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". 552 TEST(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". 559 TEST(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". 565 TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) { 566 EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str()); 567 } 568 569 void OnCallAnyArgumentLogger() { 570 DummyMock mock; 571 ON_CALL(mock, TestMethodArg(_)); 572 } 573 574 // Verifies that ON_CALL prints provided _ argument. 575 TEST(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 584 TEST(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 600 TEST(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 626 TEST(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 659 TEST(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 669 TEST(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 682 TEST(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 699 TEST(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 724 TEST(Base64Unescape, InvalidString) { 725 std::string unescaped; 726 EXPECT_FALSE(Base64Unescape("(invalid)", &unescaped)); 727 } 728 729 TEST(Base64Unescape, ShortString) { 730 std::string unescaped; 731 EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQh", &unescaped)); 732 EXPECT_EQ("Hello world!", unescaped); 733 } 734 735 TEST(Base64Unescape, ShortStringWithPadding) { 736 std::string unescaped; 737 EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ=", &unescaped)); 738 EXPECT_EQ("Hello world", unescaped); 739 } 740 741 TEST(Base64Unescape, ShortStringWithoutPadding) { 742 std::string unescaped; 743 EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ", &unescaped)); 744 EXPECT_EQ("Hello world", unescaped); 745 } 746 747 TEST(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