testing::gmock_generated_function_mockers_test Namespace Reference

Classes
class	FooInterface
class	FunctionMockerTest
class	MockB
class	MockFoo
struct	MockMethodSizes0
struct	MockMethodSizes1
struct	MockMethodSizes2
struct	MockMethodSizes3
struct	MockMethodSizes4
class	MockOverloadedOnArgNumber
class	MockOverloadedOnConstness
class	MockStack
class	StackInterface

Functions
	TEST_F (FunctionMockerTest, MocksVoidFunction)
	TEST_F (FunctionMockerTest, MocksNullaryFunction)
	TEST_F (FunctionMockerTest, MocksUnaryFunction)
	TEST_F (FunctionMockerTest, MocksBinaryFunction)
	TEST_F (FunctionMockerTest, MocksDecimalFunction)
	TEST_F (FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument)
	TEST_F (FunctionMockerTest, MocksFunctionWithConstReferenceArgument)
	TEST_F (FunctionMockerTest, MocksFunctionWithConstArgument)
	TEST_F (FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber)
	TEST_F (FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType)
	TEST_F (FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis)
	TEST_F (FunctionMockerTest, MocksReturnTypeWithComma)
	TEST (ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes)
	TEST (TemplateMockTest, Works)
	TEST (TemplateMockTest, MethodWithCommaInReturnTypeWorks)
	TEST (OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody)
	TEST (OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody)
	TEST (MockFunctionTest, WorksForVoidNullary)
	TEST (MockFunctionTest, WorksForNonVoidNullary)
	TEST (MockFunctionTest, WorksForVoidUnary)
	TEST (MockFunctionTest, WorksForNonVoidBinary)
	TEST (MockFunctionTest, WorksFor10Arguments)
	TEST (MockFunctionTest, MockMethodSizeOverhead)

Function Documentation

TEST() [1/11]

testing::gmock_generated_function_mockers_test::TEST	(	ExpectCallTest	,
		UnmentionedFunctionCanBeCalledAnyNumberOfTimes	)

Definition at line 367 of file gmock-generated-function-mockers_test.cc.

                                                                     {
  {
    MockB b;
  }
 
  {
    MockB b;
    b.DoB();
  }
 
  {
    MockB b;
    b.DoB();
    b.DoB();
  }
}

TEST() [2/11]

testing::gmock_generated_function_mockers_test::TEST	(	MockFunctionTest	,
		MockMethodSizeOverhead	)

Definition at line 639 of file gmock-generated-function-mockers_test.cc.

                                               {
  EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes1));
  EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes2));
  EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes3));
  EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes4));
}

TEST() [3/11]

testing::gmock_generated_function_mockers_test::TEST	(	MockFunctionTest	,
		WorksFor10Arguments	)

Definition at line 590 of file gmock-generated-function-mockers_test.cc.

                                            {
  MockFunction<int(bool a0, char a1, int a2, int a3, int a4,
                   int a5, int a6, char a7, int a8, bool a9)> foo;
  EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _))
      .WillOnce(Return(1))
      .WillOnce(Return(2));
  EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true));
  EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false));
}

Here is the call graph for this function:

TEST() [4/11]

testing::gmock_generated_function_mockers_test::TEST	(	MockFunctionTest	,
		WorksForNonVoidBinary	)

Definition at line 578 of file gmock-generated-function-mockers_test.cc.

                                              {
  MockFunction<int(bool, int)> foo;
  EXPECT_CALL(foo, Call(false, 42))
      .WillOnce(Return(1))
      .WillOnce(Return(2));
  EXPECT_CALL(foo, Call(true, Ge(100)))
      .WillOnce(Return(3));
  EXPECT_EQ(1, foo.Call(false, 42));
  EXPECT_EQ(2, foo.Call(false, 42));
  EXPECT_EQ(3, foo.Call(true, 120));
}

Here is the call graph for this function:

TEST() [5/11]

testing::gmock_generated_function_mockers_test::TEST	(	MockFunctionTest	,
		WorksForNonVoidNullary	)

Definition at line 563 of file gmock-generated-function-mockers_test.cc.

                                               {
  MockFunction<int()> foo;
  EXPECT_CALL(foo, Call())
      .WillOnce(Return(1))
      .WillOnce(Return(2));
  EXPECT_EQ(1, foo.Call());
  EXPECT_EQ(2, foo.Call());
}

Here is the call graph for this function:

TEST() [6/11]

testing::gmock_generated_function_mockers_test::TEST	(	MockFunctionTest	,
		WorksForVoidNullary	)

Definition at line 557 of file gmock-generated-function-mockers_test.cc.

                                            {
  MockFunction<void()> foo;
  EXPECT_CALL(foo, Call());
  foo.Call();
}

TEST() [7/11]

testing::gmock_generated_function_mockers_test::TEST	(	MockFunctionTest	,
		WorksForVoidUnary	)

Definition at line 572 of file gmock-generated-function-mockers_test.cc.

                                          {
  MockFunction<void(int)> foo;
  EXPECT_CALL(foo, Call(1));
  foo.Call(1);
}

TEST() [8/11]

testing::gmock_generated_function_mockers_test::TEST	(	OverloadedMockMethodTest	,
		CanOverloadOnArgNumberInMacroBody	)

Definition at line 522 of file gmock-generated-function-mockers_test.cc.

                                                                  {
  MockOverloadedOnArgNumber mock;
  EXPECT_CALL(mock, Overloaded());
  EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
  EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true));
 
  mock.Overloaded();
  EXPECT_EQ(2, mock.Overloaded(1));
  EXPECT_TRUE(mock.Overloaded(true, 1));
}

Here is the call graph for this function:

TEST() [9/11]

testing::gmock_generated_function_mockers_test::TEST	(	OverloadedMockMethodTest	,
		CanOverloadOnConstnessInMacroBody	)

Definition at line 547 of file gmock-generated-function-mockers_test.cc.

                                                                  {
  MockOverloadedOnConstness mock;
  const MockOverloadedOnConstness* const_mock = &mock;
  EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
  EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3));
 
  EXPECT_EQ(2, mock.Overloaded(1));
  EXPECT_EQ(3, const_mock->Overloaded(1));
}

Here is the call graph for this function:

TEST() [10/11]

testing::gmock_generated_function_mockers_test::TEST	(	TemplateMockTest	,
		MethodWithCommaInReturnTypeWorks	)

Definition at line 440 of file gmock-generated-function-mockers_test.cc.

                                                         {
  MockStack<int> mock;
 
  const std::map<int, int> a_map;
  EXPECT_CALL(mock, ReturnTypeWithComma())
      .WillOnce(Return(a_map));
  EXPECT_CALL(mock, ReturnTypeWithComma(1))
      .WillOnce(Return(a_map));
 
  EXPECT_EQ(a_map, mock.ReturnTypeWithComma());
  EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
}

Here is the call graph for this function:

TEST() [11/11]

testing::gmock_generated_function_mockers_test::TEST	(	TemplateMockTest	,
		Works	)

Definition at line 418 of file gmock-generated-function-mockers_test.cc.

                              {
  MockStack<int> mock;
 
  EXPECT_CALL(mock, GetSize())
      .WillOnce(Return(0))
      .WillOnce(Return(1))
      .WillOnce(Return(0));
  EXPECT_CALL(mock, Push(_));
  int n = 5;
  EXPECT_CALL(mock, GetTop())
      .WillOnce(ReturnRef(n));
  EXPECT_CALL(mock, Pop())
      .Times(AnyNumber());
 
  EXPECT_EQ(0, mock.GetSize());
  mock.Push(5);
  EXPECT_EQ(1, mock.GetSize());
  EXPECT_EQ(5, mock.GetTop());
  mock.Pop();
  EXPECT_EQ(0, mock.GetSize());
}

Here is the call graph for this function:

TEST_F() [1/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksBinaryFunction	)

Definition at line 219 of file gmock-generated-function-mockers_test.cc.

                                                {
  EXPECT_CALL(mock_foo_, Binary(2, _))
      .WillOnce(Return(3));
 
  EXPECT_EQ(3, foo_->Binary(2, 1));
}

Here is the call graph for this function:

TEST_F() [2/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksDecimalFunction	)

Definition at line 227 of file gmock-generated-function-mockers_test.cc.

                                                 {
  EXPECT_CALL(mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(),
                                 Lt(100), 5U, NULL, "hi"))
      .WillOnce(Return(5));
 
  EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
}

Here is the call graph for this function:

TEST_F() [3/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksFunctionsOverloadedOnArgumentNumber	)

Definition at line 264 of file gmock-generated-function-mockers_test.cc.

                                                                     {
  EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber())
      .WillOnce(Return(1));
  EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber(_))
      .WillOnce(Return(2));
 
  EXPECT_EQ(2, foo_->OverloadedOnArgumentNumber(1));
  EXPECT_EQ(1, foo_->OverloadedOnArgumentNumber());
}

Here is the call graph for this function:

TEST_F() [4/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksFunctionsOverloadedOnArgumentType	)

Definition at line 275 of file gmock-generated-function-mockers_test.cc.

                                                                   {
  EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(An<int>()))
      .WillOnce(Return(1));
  EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a')))
      .WillOnce(Return('b'));
 
  EXPECT_EQ(1, foo_->OverloadedOnArgumentType(0));
  EXPECT_EQ('b', foo_->OverloadedOnArgumentType('a'));
}

Here is the call graph for this function:

TEST_F() [5/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksFunctionsOverloadedOnConstnessOfThis	)

Definition at line 286 of file gmock-generated-function-mockers_test.cc.

                                                                      {
  EXPECT_CALL(mock_foo_, OverloadedOnConstness());
  EXPECT_CALL(Const(mock_foo_), OverloadedOnConstness())
      .WillOnce(Return('a'));
 
  EXPECT_EQ(0, foo_->OverloadedOnConstness());
  EXPECT_EQ('a', Const(*foo_).OverloadedOnConstness());
}

Here is the call graph for this function:

TEST_F() [6/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksFunctionWithConstArgument	)

Definition at line 255 of file gmock-generated-function-mockers_test.cc.

                                                           {
  EXPECT_CALL(mock_foo_, TakesConst(Lt(10)))
      .WillOnce(DoDefault());
 
  EXPECT_FALSE(foo_->TakesConst(5));
}

Here is the call graph for this function:

TEST_F() [7/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksFunctionWithConstReferenceArgument	)

Definition at line 245 of file gmock-generated-function-mockers_test.cc.

                                                                    {
  int a = 0;
  EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a)))
      .WillOnce(Return("Hello"));
 
  EXPECT_EQ("Hello", foo_->TakesConstReference(a));
}

Here is the call graph for this function:

TEST_F() [8/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksFunctionWithNonConstReferenceArgument	)

Definition at line 236 of file gmock-generated-function-mockers_test.cc.

                                                                       {
  int a = 0;
  EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a)))
      .WillOnce(Return(true));
 
  EXPECT_TRUE(foo_->TakesNonConstReference(a));
}

Here is the call graph for this function:

TEST_F() [9/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksNullaryFunction	)

Definition at line 199 of file gmock-generated-function-mockers_test.cc.

                                                 {
  EXPECT_CALL(mock_foo_, Nullary())
      .WillOnce(DoDefault())
      .WillOnce(Return(1));
 
  EXPECT_EQ(0, foo_->Nullary());
  EXPECT_EQ(1, foo_->Nullary());
}

Here is the call graph for this function:

TEST_F() [10/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksReturnTypeWithComma	)

Definition at line 295 of file gmock-generated-function-mockers_test.cc.

                                                     {
  const std::map<int, std::string> a_map;
  EXPECT_CALL(mock_foo_, ReturnTypeWithComma())
      .WillOnce(Return(a_map));
  EXPECT_CALL(mock_foo_, ReturnTypeWithComma(42))
      .WillOnce(Return(a_map));
 
  EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma());
  EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma(42));
}

Here is the call graph for this function:

TEST_F() [11/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksUnaryFunction	)

Definition at line 209 of file gmock-generated-function-mockers_test.cc.

                                               {
  EXPECT_CALL(mock_foo_, Unary(Eq(2)))
      .Times(2)
      .WillOnce(Return(true));
 
  EXPECT_TRUE(foo_->Unary(2));
  EXPECT_FALSE(foo_->Unary(2));
}

Here is the call graph for this function:

TEST_F() [12/12]

testing::gmock_generated_function_mockers_test::TEST_F	(	FunctionMockerTest	,
		MocksVoidFunction	)

Definition at line 193 of file gmock-generated-function-mockers_test.cc.

                                              {
  EXPECT_CALL(mock_foo_, VoidReturning(Lt(100)));
  foo_->VoidReturning(0);
}

Here is the call graph for this function: