1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125
  126
  127
  128
  129
  130
  131
  132
  133
  134
  135


base / gmock_unittest.cc [blame]

// Copyright 2009 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// This test is a simple sanity check to make sure gmock is able to build/link
// correctly.  It just instantiates a mock object and runs through a couple of
// the basic mock features.

#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

// Gmock matchers and actions that we use below.
using testing::AnyOf;
using testing::Eq;
using testing::Return;
using testing::SetArgPointee;
using testing::WithArg;
using testing::_;

namespace {

// Simple class that we can mock out the behavior for.  Everything is virtual
// for easy mocking.
class SampleClass {
 public:
  SampleClass() = default;
  virtual ~SampleClass() = default;

  virtual int ReturnSomething() {
    return -1;
  }

  virtual void ReturnNothingConstly() const {
  }

  virtual void OutputParam(int* a) {
  }

  virtual int ReturnSecond(int a, int b) {
    return b;
  }
};

// Declare a mock for the class.
class MockSampleClass : public SampleClass {
 public:
  MOCK_METHOD(int, ReturnSomething, ());
  MOCK_METHOD(void, ReturnNothingConstly, (), (const));
  MOCK_METHOD(void, OutputParam, (int* a));
  MOCK_METHOD(int, ReturnSecond, (int a, int b));
};

// Create a couple of custom actions.  Custom actions can be used for adding
// more complex behavior into your mock...though if you start needing these, ask
// if you're asking your mock to do too much.
ACTION(ReturnVal) {
  // Return the first argument received.
  return arg0;
}
ACTION(ReturnSecond) {
  // Returns the second argument.  This basically implemetns ReturnSecond.
  return arg1;
}

TEST(GmockTest, SimpleMatchAndActions) {
  // Basic test of some simple gmock matchers, actions, and cardinality
  // expectations.
  MockSampleClass mock;

  EXPECT_CALL(mock, ReturnSomething())
      .WillOnce(Return(1))
      .WillOnce(Return(2))
      .WillOnce(Return(3));
  EXPECT_EQ(1, mock.ReturnSomething());
  EXPECT_EQ(2, mock.ReturnSomething());
  EXPECT_EQ(3, mock.ReturnSomething());

  EXPECT_CALL(mock, ReturnNothingConstly()).Times(2);
  mock.ReturnNothingConstly();
  mock.ReturnNothingConstly();
}

TEST(GmockTest, AssignArgument) {
  // Capture an argument for examination.
  MockSampleClass mock;

  EXPECT_CALL(mock, OutputParam(_)).WillRepeatedly(SetArgPointee<0>(5));

  int arg = 0;
  mock.OutputParam(&arg);
  EXPECT_EQ(5, arg);
}

TEST(GmockTest, SideEffects) {
  // Capture an argument for examination.
  MockSampleClass mock;

  EXPECT_CALL(mock, OutputParam(_)).WillRepeatedly(SetArgPointee<0>(5));

  int arg = 0;
  mock.OutputParam(&arg);
  EXPECT_EQ(5, arg);
}

TEST(GmockTest, CustomAction_ReturnSecond) {
  // Test a mock of the ReturnSecond behavior using an action that provides an
  // alternate implementation of the function.  Danger here though, this is
  // starting to add too much behavior of the mock, which means the mock
  // implementation might start to have bugs itself.
  MockSampleClass mock;

  EXPECT_CALL(mock, ReturnSecond(_, AnyOf(Eq(4), Eq(5))))
      .WillRepeatedly(ReturnSecond());
  EXPECT_EQ(4, mock.ReturnSecond(-1, 4));
  EXPECT_EQ(5, mock.ReturnSecond(0, 5));
  EXPECT_EQ(4, mock.ReturnSecond(0xdeadbeef, 4));
  EXPECT_EQ(4, mock.ReturnSecond(112358, 4));
  EXPECT_EQ(5, mock.ReturnSecond(1337, 5));
}

TEST(GmockTest, CustomAction_ReturnVal) {
  // Alternate implemention of ReturnSecond using a more general custom action,
  // and a WithArg adapter to bridge the interfaces.
  MockSampleClass mock;

  EXPECT_CALL(mock, ReturnSecond(_, AnyOf(Eq(4), Eq(5))))
      .WillRepeatedly(WithArg<1>(ReturnVal()));
  EXPECT_EQ(4, mock.ReturnSecond(-1, 4));
  EXPECT_EQ(5, mock.ReturnSecond(0, 5));
  EXPECT_EQ(4, mock.ReturnSecond(0xdeadbeef, 4));
  EXPECT_EQ(4, mock.ReturnSecond(112358, 4));
  EXPECT_EQ(5, mock.ReturnSecond(1337, 5));
}

}  // namespace