Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 //
      5 // This test is a simple sanity check to make sure gmock is able to build/link
      6 // correctly.  It just instantiates a mock object and runs through a couple of
      7 // the basic mock features.
      8 
      9 #include "testing/gmock/include/gmock/gmock.h"
     10 #include "testing/gtest/include/gtest/gtest.h"
     11 
     12 // Gmock matchers and actions that we use below.
     13 using testing::AnyOf;
     14 using testing::Eq;
     15 using testing::Return;
     16 using testing::SetArgumentPointee;
     17 using testing::WithArg;
     18 using testing::_;
     19 
     20 namespace {
     21 
     22 // Simple class that we can mock out the behavior for.  Everything is virtual
     23 // for easy mocking.
     24 class SampleClass {
     25  public:
     26   SampleClass() {}
     27   virtual ~SampleClass() {}
     28 
     29   virtual int ReturnSomething() {
     30     return -1;
     31   }
     32 
     33   virtual void ReturnNothingConstly() const {
     34   }
     35 
     36   virtual void OutputParam(int* a) {
     37   }
     38 
     39   virtual int ReturnSecond(int a, int b) {
     40     return b;
     41   }
     42 };
     43 
     44 // Declare a mock for the class.
     45 class MockSampleClass : public SampleClass {
     46  public:
     47   MOCK_METHOD0(ReturnSomething, int());
     48   MOCK_CONST_METHOD0(ReturnNothingConstly, void());
     49   MOCK_METHOD1(OutputParam, void(int* a));
     50   MOCK_METHOD2(ReturnSecond, int(int a, int b));
     51 };
     52 
     53 // Create a couple of custom actions.  Custom actions can be used for adding
     54 // more complex behavior into your mock...though if you start needing these, ask
     55 // if you're asking your mock to do too much.
     56 ACTION(ReturnVal) {
     57   // Return the first argument received.
     58   return arg0;
     59 }
     60 ACTION(ReturnSecond) {
     61   // Returns the second argument.  This basically implemetns ReturnSecond.
     62   return arg1;
     63 }
     64 
     65 TEST(GmockTest, SimpleMatchAndActions) {
     66   // Basic test of some simple gmock matchers, actions, and cardinality
     67   // expectations.
     68   MockSampleClass mock;
     69 
     70   EXPECT_CALL(mock, ReturnSomething())
     71       .WillOnce(Return(1))
     72       .WillOnce(Return(2))
     73       .WillOnce(Return(3));
     74   EXPECT_EQ(1, mock.ReturnSomething());
     75   EXPECT_EQ(2, mock.ReturnSomething());
     76   EXPECT_EQ(3, mock.ReturnSomething());
     77 
     78   EXPECT_CALL(mock, ReturnNothingConstly()).Times(2);
     79   mock.ReturnNothingConstly();
     80   mock.ReturnNothingConstly();
     81 }
     82 
     83 TEST(GmockTest, AssignArgument) {
     84   // Capture an argument for examination.
     85   MockSampleClass mock;
     86 
     87   EXPECT_CALL(mock, OutputParam(_))
     88       .WillRepeatedly(SetArgumentPointee<0>(5));
     89 
     90   int arg = 0;
     91   mock.OutputParam(&arg);
     92   EXPECT_EQ(5, arg);
     93 }
     94 
     95 TEST(GmockTest, SideEffects) {
     96   // Capture an argument for examination.
     97   MockSampleClass mock;
     98 
     99   EXPECT_CALL(mock, OutputParam(_))
    100       .WillRepeatedly(SetArgumentPointee<0>(5));
    101 
    102   int arg = 0;
    103   mock.OutputParam(&arg);
    104   EXPECT_EQ(5, arg);
    105 }
    106 
    107 TEST(GmockTest, CustomAction_ReturnSecond) {
    108   // Test a mock of the ReturnSecond behavior using an action that provides an
    109   // alternate implementation of the function.  Danger here though, this is
    110   // starting to add too much behavior of the mock, which means the mock
    111   // implementation might start to have bugs itself.
    112   MockSampleClass mock;
    113 
    114   EXPECT_CALL(mock, ReturnSecond(_, AnyOf(Eq(4), Eq(5))))
    115       .WillRepeatedly(ReturnSecond());
    116   EXPECT_EQ(4, mock.ReturnSecond(-1, 4));
    117   EXPECT_EQ(5, mock.ReturnSecond(0, 5));
    118   EXPECT_EQ(4, mock.ReturnSecond(0xdeadbeef, 4));
    119   EXPECT_EQ(4, mock.ReturnSecond(112358, 4));
    120   EXPECT_EQ(5, mock.ReturnSecond(1337, 5));
    121 }
    122 
    123 TEST(GmockTest, CustomAction_ReturnVal) {
    124   // Alternate implemention of ReturnSecond using a more general custom action,
    125   // and a WithArg adapter to bridge the interfaces.
    126   MockSampleClass mock;
    127 
    128   EXPECT_CALL(mock, ReturnSecond(_, AnyOf(Eq(4), Eq(5))))
    129       .WillRepeatedly(WithArg<1>(ReturnVal()));
    130   EXPECT_EQ(4, mock.ReturnSecond(-1, 4));
    131   EXPECT_EQ(5, mock.ReturnSecond(0, 5));
    132   EXPECT_EQ(4, mock.ReturnSecond(0xdeadbeef, 4));
    133   EXPECT_EQ(4, mock.ReturnSecond(112358, 4));
    134   EXPECT_EQ(5, mock.ReturnSecond(1337, 5));
    135 }
    136 
    137 }  // namespace
    138