googlemock/test/gmock_output_test_.cc

   1 // Copyright 2008, 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 // Tests Google Mock's output in various scenarios.  This ensures that
  31 // Google Mock's messages are readable and useful.
  32
  33 #include <stdio.h>
  34
  35 #include <string>
  36
  37 #include "gmock/gmock.h"
  38 #include "gtest/gtest.h"
  39
  40 // Silence C4100 (unreferenced formal parameter)
  41 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100)
  42
  43 using testing::_;
  44 using testing::AnyNumber;
  45 using testing::Ge;
  46 using testing::InSequence;
  47 using testing::NaggyMock;
  48 using testing::Ref;
  49 using testing::Return;
  50 using testing::Sequence;
  51 using testing::Value;
  52
  53 class MockFoo {
  54  public:
  55   MockFoo() = default;
  56
  57   MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
  58   MOCK_METHOD2(Bar2, bool(int x, int y));
  59   MOCK_METHOD2(Bar3, void(int x, int y));
  60
  61  private:
  62   MockFoo(const MockFoo&) = delete;
  63   MockFoo& operator=(const MockFoo&) = delete;
  64 };
  65
  66 class GMockOutputTest : public testing::Test {
  67  protected:
  68   NaggyMock<MockFoo> foo_;
  69 };
  70
  71 TEST_F(GMockOutputTest, ExpectedCall) {
  72   GMOCK_FLAG_SET(verbose, "info");
  73
  74   EXPECT_CALL(foo_, Bar2(0, _));
  75   foo_.Bar2(0, 0);  // Expected call
  76
  77   GMOCK_FLAG_SET(verbose, "warning");
  78 }
  79
  80 TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
  81   GMOCK_FLAG_SET(verbose, "info");
  82
  83   EXPECT_CALL(foo_, Bar3(0, _));
  84   foo_.Bar3(0, 0);  // Expected call
  85
  86   GMOCK_FLAG_SET(verbose, "warning");
  87 }
  88
  89 TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
  90   EXPECT_CALL(foo_, Bar2(_, _)).Times(2).WillOnce(Return(false));
  91   foo_.Bar2(2, 2);
  92   foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
  93 }
  94
  95 TEST_F(GMockOutputTest, UnexpectedCall) {
  96   EXPECT_CALL(foo_, Bar2(0, _));
  97
  98   foo_.Bar2(1, 0);  // Unexpected call
  99   foo_.Bar2(0, 0);  // Expected call
 100 }
 101
 102 TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
 103   EXPECT_CALL(foo_, Bar3(0, _));
 104
 105   foo_.Bar3(1, 0);  // Unexpected call
 106   foo_.Bar3(0, 0);  // Expected call
 107 }
 108
 109 TEST_F(GMockOutputTest, ExcessiveCall) {
 110   EXPECT_CALL(foo_, Bar2(0, _));
 111
 112   foo_.Bar2(0, 0);  // Expected call
 113   foo_.Bar2(0, 1);  // Excessive call
 114 }
 115
 116 TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
 117   EXPECT_CALL(foo_, Bar3(0, _));
 118
 119   foo_.Bar3(0, 0);  // Expected call
 120   foo_.Bar3(0, 1);  // Excessive call
 121 }
 122
 123 TEST_F(GMockOutputTest, UninterestingCall) {
 124   foo_.Bar2(0, 1);  // Uninteresting call
 125 }
 126
 127 TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
 128   foo_.Bar3(0, 1);  // Uninteresting call
 129 }
 130
 131 TEST_F(GMockOutputTest, RetiredExpectation) {
 132   EXPECT_CALL(foo_, Bar2(_, _)).RetiresOnSaturation();
 133   EXPECT_CALL(foo_, Bar2(0, 0));
 134
 135   foo_.Bar2(1, 1);
 136   foo_.Bar2(1, 1);  // Matches a retired expectation
 137   foo_.Bar2(0, 0);
 138 }
 139
 140 TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
 141   {
 142     InSequence s;
 143     EXPECT_CALL(foo_, Bar(_, 0, _));
 144     EXPECT_CALL(foo_, Bar2(0, 0));
 145     EXPECT_CALL(foo_, Bar2(1, _));
 146   }
 147
 148   foo_.Bar2(1, 0);  // Has one immediate unsatisfied pre-requisite
 149   foo_.Bar("Hi", 0, 0);
 150   foo_.Bar2(0, 0);
 151   foo_.Bar2(1, 0);
 152 }
 153
 154 TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
 155   Sequence s1, s2;
 156
 157   EXPECT_CALL(foo_, Bar(_, 0, _)).InSequence(s1);
 158   EXPECT_CALL(foo_, Bar2(0, 0)).InSequence(s2);
 159   EXPECT_CALL(foo_, Bar2(1, _)).InSequence(s1, s2);
 160
 161   foo_.Bar2(1, 0);  // Has two immediate unsatisfied pre-requisites
 162   foo_.Bar("Hi", 0, 0);
 163   foo_.Bar2(0, 0);
 164   foo_.Bar2(1, 0);
 165 }
 166
 167 TEST_F(GMockOutputTest, UnsatisfiedWith) {
 168   EXPECT_CALL(foo_, Bar2(_, _)).With(Ge());
 169 }
 170
 171 TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
 172   EXPECT_CALL(foo_, Bar(_, _, _));
 173   EXPECT_CALL(foo_, Bar2(0, _)).Times(2);
 174
 175   foo_.Bar2(0, 1);
 176 }
 177
 178 TEST_F(GMockOutputTest, MismatchArguments) {
 179   const std::string s = "Hi";
 180   EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)));
 181
 182   foo_.Bar("Ho", 0, -0.1);  // Mismatch arguments
 183   foo_.Bar(s, 0, 0);
 184 }
 185
 186 TEST_F(GMockOutputTest, MismatchWith) {
 187   EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))).With(Ge());
 188
 189   foo_.Bar2(2, 3);  // Mismatch With()
 190   foo_.Bar2(2, 1);
 191 }
 192
 193 TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
 194   EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))).With(Ge());
 195
 196   foo_.Bar2(1, 3);  // Mismatch arguments and mismatch With()
 197   foo_.Bar2(2, 1);
 198 }
 199
 200 TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
 201   ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));   // Default action #1
 202   ON_CALL(foo_, Bar2(1, _)).WillByDefault(Return(false));  // Default action #2
 203
 204   EXPECT_CALL(foo_, Bar2(2, 2));
 205   foo_.Bar2(1, 0);  // Unexpected call, takes default action #2.
 206   foo_.Bar2(0, 0);  // Unexpected call, takes default action #1.
 207   foo_.Bar2(2, 2);  // Expected call.
 208 }
 209
 210 TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
 211   ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));   // Default action #1
 212   ON_CALL(foo_, Bar2(1, _)).WillByDefault(Return(false));  // Default action #2
 213
 214   EXPECT_CALL(foo_, Bar2(2, 2));
 215   EXPECT_CALL(foo_, Bar2(1, 1));
 216
 217   foo_.Bar2(2, 2);  // Expected call.
 218   foo_.Bar2(2, 2);  // Excessive call, takes default action #1.
 219   foo_.Bar2(1, 1);  // Expected call.
 220   foo_.Bar2(1, 1);  // Excessive call, takes default action #2.
 221 }
 222
 223 TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
 224   ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));   // Default action #1
 225   ON_CALL(foo_, Bar2(1, _)).WillByDefault(Return(false));  // Default action #2
 226
 227   foo_.Bar2(2, 2);  // Uninteresting call, takes default action #1.
 228   foo_.Bar2(1, 1);  // Uninteresting call, takes default action #2.
 229 }
 230
 231 TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
 232   ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));  // Default action #1
 233
 234   EXPECT_CALL(foo_, Bar2(_, _)).Times(2).WillOnce(Return(false));
 235   foo_.Bar2(2, 2);
 236   foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
 237 }
 238
 239 TEST_F(GMockOutputTest, CatchesLeakedMocks) {
 240   MockFoo* foo1 = new MockFoo;
 241   MockFoo* foo2 = new MockFoo;
 242
 243   // Invokes ON_CALL on foo1.
 244   ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a'));
 245
 246   // Invokes EXPECT_CALL on foo2.
 247   EXPECT_CALL(*foo2, Bar2(_, _));
 248   EXPECT_CALL(*foo2, Bar2(1, _));
 249   EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber());
 250   foo2->Bar2(2, 1);
 251   foo2->Bar2(1, 1);
 252
 253   // Both foo1 and foo2 are deliberately leaked.
 254 }
 255
 256 MATCHER_P2(IsPair, first, second, "") {
 257   return Value(arg.first, first) && Value(arg.second, second);
 258 }
 259
 260 TEST_F(GMockOutputTest, PrintsMatcher) {
 261   const testing::Matcher<int> m1 = Ge(48);
 262   EXPECT_THAT((std::pair<int, bool>(42, true)), IsPair(m1, true));
 263 }
 264
 265 void TestCatchesLeakedMocksInAdHocTests() {
 266   MockFoo* foo = new MockFoo;
 267
 268   // Invokes EXPECT_CALL on foo.
 269   EXPECT_CALL(*foo, Bar2(_, _));
 270   foo->Bar2(2, 1);
 271
 272   // foo is deliberately leaked.
 273 }
 274
 275 int main(int argc, char** argv) {
 276   testing::InitGoogleMock(&argc, argv);
 277   // Ensures that the tests pass no matter what value of
 278   // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
 279   GMOCK_FLAG_SET(catch_leaked_mocks, true);
 280   GMOCK_FLAG_SET(verbose, "warning");
 281
 282   TestCatchesLeakedMocksInAdHocTests();
 283   return RUN_ALL_TESTS();
 284 }
 285
 286 GTEST_DISABLE_MSC_WARNINGS_POP_()  // 4100