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