Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

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