testing::gmock_generated_function_mockers_test Namespace Reference

Classes
class	FooInterface
class	FunctionMockerTest
class	MockB
class	MockFoo
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)

Function Documentation

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

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

References b.

Referenced by testing::gmock_generated_function_mockers_test::MockB::MockB(), testing::gmock_generated_function_mockers_test::MockOverloadedOnArgNumber::MockOverloadedOnArgNumber(), testing::gmock_generated_function_mockers_test::MockOverloadedOnConstness::MockOverloadedOnConstness(), testing::gmock_generated_function_mockers_test::MockStack< T >::MockStack(), and TEST().

                                                                     {
  {
    MockB b;
  }

  {
    MockB b;
    b.DoB();
  }

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

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

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

References testing::_, testing::AnyNumber(), EXPECT_CALL, EXPECT_EQ, testing::gmock_generated_function_mockers_test::StackInterface< T >::GetSize(), testing::gmock_generated_function_mockers_test::StackInterface< T >::GetTop(), testing::gmock_generated_function_mockers_test::StackInterface< T >::Pop(), Push, testing::gmock_generated_function_mockers_test::StackInterface< T >::Push(), testing::Return(), and testing::ReturnRef().

                              {
  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());
}

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

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

References testing::_, testing::AnyNumber(), EXPECT_CALL, EXPECT_EQ, GTEST_DISALLOW_COPY_AND_ASSIGN_, MOCK_CONST_METHOD0_T_WITH_CALLTYPE, MOCK_METHOD0_T_WITH_CALLTYPE, MOCK_METHOD1_T_WITH_CALLTYPE, Push, testing::Return(), testing::ReturnRef(), T, TEST(), and value.

                                                         {
  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));
}

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

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

References EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, and testing::Return().

                                                                  {
  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));
}

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

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

References EXPECT_CALL, EXPECT_EQ, and testing::Return().

                                                                  {
  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));
}

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

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

References EXPECT_CALL, and testing::gmock_matchers_test::foo.

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

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

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

References EXPECT_CALL, EXPECT_EQ, testing::gmock_matchers_test::foo, and testing::Return().

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

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

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

References EXPECT_CALL, and testing::gmock_matchers_test::foo.

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

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

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

References EXPECT_CALL, EXPECT_EQ, testing::gmock_matchers_test::foo, testing::Ge(), and testing::Return().

                                              {
  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));
}

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

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

References testing::_, call(), EXPECT_CALL, EXPECT_EQ, f, testing::gmock_matchers_test::foo, i, testing::Return(), testing::ReturnRef(), TEST(), and value.

                                            {
  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));
}

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

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

References EXPECT_CALL, testing::Lt(), and testing::gmock_generated_function_mockers_test::FooInterface::VoidReturning().

Referenced by testing::gmock_generated_function_mockers_test::FunctionMockerTest::FunctionMockerTest(), and TEST_F().

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

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

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

References testing::DoDefault(), EXPECT_CALL, EXPECT_EQ, testing::gmock_generated_function_mockers_test::FooInterface::Nullary(), and testing::Return().

                                                 {
  EXPECT_CALL(mock_foo_, Nullary())
      .WillOnce(DoDefault())
      .WillOnce(Return(1));

  EXPECT_EQ(0, foo_->Nullary());
  EXPECT_EQ(1, foo_->Nullary());
}

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

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

References testing::Eq(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::Return(), and testing::gmock_generated_function_mockers_test::FooInterface::Unary().

                                               {
  EXPECT_CALL(mock_foo_, Unary(Eq(2)))
      .Times(2)
      .WillOnce(Return(true));

  EXPECT_TRUE(foo_->Unary(2));
  EXPECT_FALSE(foo_->Unary(2));
}

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

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

References testing::_, testing::gmock_generated_function_mockers_test::FooInterface::Binary(), EXPECT_CALL, EXPECT_EQ, and testing::Return().

                                                {
  EXPECT_CALL(mock_foo_, Binary(2, _))
      .WillOnce(Return(3));

  EXPECT_EQ(3, foo_->Binary(2, 1));
}

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

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

References testing::gmock_generated_function_mockers_test::FooInterface::Decimal(), EXPECT_CALL, EXPECT_EQ, testing::Lt(), and testing::Return().

                                                 {
  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"));
}

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

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

References a, EXPECT_CALL, EXPECT_TRUE, testing::Ref(), testing::Return(), and testing::gmock_generated_function_mockers_test::FooInterface::TakesNonConstReference().

                                                                       {
  int a = 0;
  EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a)))
      .WillOnce(Return(true));

  EXPECT_TRUE(foo_->TakesNonConstReference(a));
}

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

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

References a, EXPECT_CALL, EXPECT_EQ, testing::Ref(), testing::Return(), and testing::gmock_generated_function_mockers_test::FooInterface::TakesConstReference().

                                                                    {
  int a = 0;
  EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a)))
      .WillOnce(Return("Hello"));

  EXPECT_EQ("Hello", foo_->TakesConstReference(a));
}

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

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

References testing::DoDefault(), EXPECT_CALL, EXPECT_FALSE, testing::Lt(), and testing::gmock_generated_function_mockers_test::FooInterface::TakesConst().

                                                           {
  EXPECT_CALL(mock_foo_, TakesConst(Lt(10)))
      .WillOnce(DoDefault());

  EXPECT_FALSE(foo_->TakesConst(5));
}

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

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

References testing::_, EXPECT_CALL, EXPECT_EQ, testing::gmock_generated_function_mockers_test::FooInterface::OverloadedOnArgumentNumber(), and testing::Return().

                                                                     {
  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());
}

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

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

References EXPECT_CALL, EXPECT_EQ, testing::gmock_generated_function_mockers_test::FooInterface::OverloadedOnArgumentType(), and testing::Return().

                                                                   {
  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'));
}

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

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

References testing::Const(), EXPECT_CALL, EXPECT_EQ, testing::gmock_generated_function_mockers_test::FooInterface::OverloadedOnConstness(), and testing::Return().

                                                                      {
  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());
}

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

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

References testing::_, testing::Const(), testing::Eq(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::Lt(), testing::Return(), and TEST_F().

                                                     {
  const std::map<int, 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));
}