testing::gmock_function_mocker_test Namespace Reference

Classes
struct	AlternateCallable
class	ExpectCallTest
class	FooInterface
class	FunctionMockerTest
class	LegacyMockB
class	LegacyMockFoo
struct	LegacyMockMethodSizes0
struct	LegacyMockMethodSizes1
struct	LegacyMockMethodSizes2
struct	LegacyMockMethodSizes3
struct	LegacyMockMethodSizes4
class	LegacyMockOverloadedOnArgNumber
class	LegacyMockStack
class	MockB
class	MockFoo
class	MockMethodMockFunctionSignatureTest
struct	MockMethodNoexceptSpecifier
struct	MockMethodSizes0
struct	MockMethodSizes1
struct	MockMethodSizes2
struct	MockMethodSizes3
struct	MockMethodSizes4
class	MockOverloadedOnArgNumber
class	MockOverloadedOnConstness
class	MockStack
class	OverloadedMockMethodTest
class	StackInterface
class	TemplatedCopyable
class	TemplateMockTest

Typedefs
using	FunctionMockerTestTypes = ::testing::Types< MockFoo, LegacyMockFoo >
using	ExpectCallTestTypes = ::testing::Types< MockB, LegacyMockB >
using	TemplateMockTestTypes = ::testing::Types< MockStack< int >, LegacyMockStack< int > >
using	OverloadedMockMethodTestTypes = ::testing::Types< MockOverloadedOnArgNumber, LegacyMockOverloadedOnArgNumber >
using	MockMethodMockFunctionSignatureTypes = Types< void(), int(), void(int), int(int), int(bool, int), int(bool, char, int, int, int, int, int, char, int, bool)>

Functions
	TYPED_TEST_SUITE (FunctionMockerTest, FunctionMockerTestTypes)
	TYPED_TEST (FunctionMockerTest, MocksVoidFunction)
	TYPED_TEST (FunctionMockerTest, MocksNullaryFunction)
	TYPED_TEST (FunctionMockerTest, MocksUnaryFunction)
	TYPED_TEST (FunctionMockerTest, MocksBinaryFunction)
	TYPED_TEST (FunctionMockerTest, MocksDecimalFunction)
	TYPED_TEST (FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument)
	TYPED_TEST (FunctionMockerTest, MocksFunctionWithConstReferenceArgument)
	TYPED_TEST (FunctionMockerTest, MocksFunctionWithConstArgument)
	TYPED_TEST (FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber)
	TYPED_TEST (FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType)
	TYPED_TEST (FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis)
	TYPED_TEST (FunctionMockerTest, MocksReturnTypeWithComma)
	TYPED_TEST (FunctionMockerTest, MocksTypeWithTemplatedCopyCtor)
	TEST (FunctionMockerTest, RefQualified)
	TYPED_TEST_SUITE (ExpectCallTest, ExpectCallTestTypes)
	TYPED_TEST (ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes)
	TYPED_TEST_SUITE (TemplateMockTest, TemplateMockTestTypes)
	TYPED_TEST (TemplateMockTest, Works)
	TYPED_TEST (TemplateMockTest, MethodWithCommaInReturnTypeWorks)
	TYPED_TEST_SUITE (OverloadedMockMethodTest, OverloadedMockMethodTestTypes)
	TYPED_TEST (OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody)
	TEST (MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody)
	TEST (MockMethodMockFunctionTest, WorksForVoidNullary)
	TEST (MockMethodMockFunctionTest, WorksForNonVoidNullary)
	TEST (MockMethodMockFunctionTest, WorksForVoidUnary)
	TEST (MockMethodMockFunctionTest, WorksForNonVoidBinary)
	TEST (MockMethodMockFunctionTest, WorksFor10Arguments)
	TEST (MockMethodMockFunctionTest, AsStdFunction)
	TEST (MockMethodMockFunctionTest, AsStdFunctionReturnsReference)
	TEST (MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter)
	TYPED_TEST_SUITE (MockMethodMockFunctionSignatureTest, MockMethodMockFunctionSignatureTypes)
	TYPED_TEST (MockMethodMockFunctionSignatureTest, IsMockFunctionTemplateArgumentDeducedForRawSignature)
	TYPED_TEST (MockMethodMockFunctionSignatureTest, IsMockFunctionTemplateArgumentDeducedForStdFunction)
	TYPED_TEST (MockMethodMockFunctionSignatureTest, IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction)
	TYPED_TEST (MockMethodMockFunctionSignatureTest, IsMockFunctionTemplateArgumentDeducedForAlternateCallable)
	TYPED_TEST (MockMethodMockFunctionSignatureTest, IsMockFunctionCallMethodSignatureTheSameForAlternateCallable)
	TEST (MockMethodMockFunctionTest, MockMethodSizeOverhead)
void	hasTwoParams (int, int)
void	MaybeThrows ()
void	DoesntThrow () noexcept
	TEST (MockMethodMockFunctionTest, NoexceptSpecifierPreserved)

Typedef Documentation

ExpectCallTestTypes

using testing::gmock_function_mocker_test::ExpectCallTestTypes = typedef ::testing::Types<MockB, LegacyMockB>

Definition at line 511 of file gmock-function-mocker_test.cc.

FunctionMockerTestTypes

using testing::gmock_function_mocker_test::FunctionMockerTestTypes = typedef ::testing::Types<MockFoo, LegacyMockFoo>

Definition at line 293 of file gmock-function-mocker_test.cc.

MockMethodMockFunctionSignatureTypes

using testing::gmock_function_mocker_test::MockMethodMockFunctionSignatureTypes = typedef Types<void(), int(), void(int), int(int), int(bool, int), int(bool, char, int, int, int, int, int, char, int, bool)>

Definition at line 861 of file gmock-function-mocker_test.cc.

OverloadedMockMethodTestTypes

using testing::gmock_function_mocker_test::OverloadedMockMethodTestTypes = typedef ::testing::Types<MockOverloadedOnArgNumber, LegacyMockOverloadedOnArgNumber>

Definition at line 734 of file gmock-function-mocker_test.cc.

TemplateMockTestTypes

using testing::gmock_function_mocker_test::TemplateMockTestTypes = typedef ::testing::Types<MockStack<int>, LegacyMockStack<int> >

Definition at line 584 of file gmock-function-mocker_test.cc.

Function Documentation

DoesntThrow()

void testing::gmock_function_mocker_test::DoesntThrow ( )

noexcept

hasTwoParams()

void testing::gmock_function_mocker_test::hasTwoParams	(	int	,
		int
	)

MaybeThrows()

void testing::gmock_function_mocker_test::MaybeThrows

(

)

TEST() [1/12]

testing::gmock_function_mocker_test::TEST	(	FunctionMockerTest	,
		RefQualified
	)

Definition at line 455 of file gmock-function-mocker_test.cc.

                                       {
  MockFoo mock_foo;
 
  EXPECT_CALL(mock_foo, RefQualifiedConstRef).WillOnce(Return(1));
  EXPECT_CALL(std::move(mock_foo),  // NOLINT
              RefQualifiedConstRefRef)
      .WillOnce(Return(2));
  EXPECT_CALL(mock_foo, RefQualifiedRef).WillOnce(Return(3));
  EXPECT_CALL(std::move(mock_foo),  // NOLINT
              RefQualifiedRefRef)
      .WillOnce(Return(4));
 
  EXPECT_CALL(static_cast<const MockFoo&>(mock_foo), RefQualifiedOverloaded())
      .WillOnce(Return(5));
  EXPECT_CALL(static_cast<const MockFoo&&>(mock_foo), RefQualifiedOverloaded())
      .WillOnce(Return(6));
  EXPECT_CALL(static_cast<MockFoo&>(mock_foo), RefQualifiedOverloaded())
      .WillOnce(Return(7));
  EXPECT_CALL(static_cast<MockFoo&&>(mock_foo), RefQualifiedOverloaded())
      .WillOnce(Return(8));
 
  EXPECT_EQ(mock_foo.RefQualifiedConstRef(), 1);
  EXPECT_EQ(std::move(mock_foo).RefQualifiedConstRefRef(), 2);  // NOLINT
  EXPECT_EQ(mock_foo.RefQualifiedRef(), 3);
  EXPECT_EQ(std::move(mock_foo).RefQualifiedRefRef(), 4);  // NOLINT
 
  EXPECT_EQ(std::cref(mock_foo).get().RefQualifiedOverloaded(), 5);
  EXPECT_EQ(std::move(std::cref(mock_foo).get())  // NOLINT
                .RefQualifiedOverloaded(),
            6);
  EXPECT_EQ(mock_foo.RefQualifiedOverloaded(), 7);
  EXPECT_EQ(std::move(mock_foo).RefQualifiedOverloaded(), 8);  // NOLINT
}

TEST() [2/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		AsStdFunction
	)

Definition at line 817 of file gmock-function-mocker_test.cc.

                                                {
  MockFunction<int(int)> foo;
  auto call = [](const std::function<int(int)> &f, int i) {
    return f(i);
  };
  EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1));
  EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2));
  EXPECT_EQ(-1, call(foo.AsStdFunction(), 1));
  EXPECT_EQ(-2, call(foo.AsStdFunction(), 2));
}

TEST() [3/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		AsStdFunctionReturnsReference
	)

Definition at line 828 of file gmock-function-mocker_test.cc.

                                                                {
  MockFunction<int&()> foo;
  int value = 1;
  EXPECT_CALL(foo, Call()).WillOnce(ReturnRef(value));
  int& ref = foo.AsStdFunction()();
  EXPECT_EQ(1, ref);
  value = 2;
  EXPECT_EQ(2, ref);
}

TEST() [4/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		AsStdFunctionWithReferenceParameter
	)

Definition at line 838 of file gmock-function-mocker_test.cc.

                                                                      {
  MockFunction<int(int &)> foo;
  auto call = [](const std::function<int(int& )> &f, int &i) {
    return f(i);
  };
  int i = 42;
  EXPECT_CALL(foo, Call(i)).WillOnce(Return(-1));
  EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
}

TEST() [5/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		MockMethodSizeOverhead
	)

Definition at line 944 of file gmock-function-mocker_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));
 
  EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes1));
  EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes2));
  EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes3));
  EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes4));
 
  EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(MockMethodSizes0));
}

TEST() [6/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		NoexceptSpecifierPreserved
	)

Definition at line 973 of file gmock-function-mocker_test.cc.

                                                             {
  EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func1()));
  EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func2()));
  EXPECT_FALSE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func3()));
  EXPECT_FALSE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func4()));
  EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func5()));
  EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func6()));
  EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func7()));
  EXPECT_EQ(noexcept(std::declval<MockMethodNoexceptSpecifier>().func8()),
            noexcept(hasTwoParams(1, 2)));
}

TEST() [7/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		WorksFor10Arguments
	)

Definition at line 807 of file gmock-function-mocker_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));
}

TEST() [8/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		WorksForNonVoidBinary
	)

Definition at line 795 of file gmock-function-mocker_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));
}

TEST() [9/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		WorksForNonVoidNullary
	)

Definition at line 780 of file gmock-function-mocker_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());
}

TEST() [10/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		WorksForVoidNullary
	)

Definition at line 774 of file gmock-function-mocker_test.cc.

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

TEST() [11/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodMockFunctionTest	,
		WorksForVoidUnary
	)

Definition at line 789 of file gmock-function-mocker_test.cc.

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

TEST() [12/12]

testing::gmock_function_mocker_test::TEST	(	MockMethodOverloadedMockMethodTest	,
		CanOverloadOnConstnessInMacroBody
	)

Definition at line 764 of file gmock-function-mocker_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));
}

TYPED_TEST() [1/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	ExpectCallTest	,
		UnmentionedFunctionCanBeCalledAnyNumberOfTimes
	)

Definition at line 516 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [2/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksBinaryFunction
	)

Definition at line 321 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [3/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksDecimalFunction
	)

Definition at line 328 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [4/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksFunctionsOverloadedOnArgumentNumber
	)

Definition at line 362 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [5/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksFunctionsOverloadedOnArgumentType
	)

Definition at line 373 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [6/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksFunctionsOverloadedOnConstnessOfThis
	)

Definition at line 384 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [7/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksFunctionWithConstArgument
	)

Definition at line 355 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [8/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksFunctionWithConstReferenceArgument
	)

Definition at line 346 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [9/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksFunctionWithNonConstReferenceArgument
	)

Definition at line 337 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [10/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksNullaryFunction
	)

Definition at line 303 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [11/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksReturnTypeWithComma
	)

Definition at line 393 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [12/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksTypeWithTemplatedCopyCtor
	)

Definition at line 402 of file gmock-function-mocker_test.cc.

                                                               {
  EXPECT_CALL(this->mock_foo_, TypeWithTemplatedCopyCtor(_))
      .WillOnce(Return(true));
  EXPECT_TRUE(this->foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>()));
}

TYPED_TEST() [13/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksUnaryFunction
	)

Definition at line 313 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [14/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	FunctionMockerTest	,
		MocksVoidFunction
	)

Definition at line 297 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [15/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	MockMethodMockFunctionSignatureTest	,
		IsMockFunctionCallMethodSignatureTheSameForAlternateCallable
	)

Definition at line 901 of file gmock-function-mocker_test.cc.

                                                                  {
  using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
  using ForStdFunction =
      decltype(&MockFunction<std::function<TypeParam>>::Call);
  EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
}

TYPED_TEST() [16/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	MockMethodMockFunctionSignatureTest	,
		IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction
	)

Definition at line 881 of file gmock-function-mocker_test.cc.

                                                                           {
  using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
  using ForStdFunction =
      decltype(&MockFunction<std::function<TypeParam>>::Call);
  EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
}

TYPED_TEST() [17/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	MockMethodMockFunctionSignatureTest	,
		IsMockFunctionTemplateArgumentDeducedForAlternateCallable
	)

Definition at line 894 of file gmock-function-mocker_test.cc.

                                                                      {
  using Argument = AlternateCallable<TypeParam>;
  MockFunction<Argument> foo;
  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
}

TYPED_TEST() [18/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	MockMethodMockFunctionSignatureTest	,
		IsMockFunctionTemplateArgumentDeducedForRawSignature
	)

Definition at line 867 of file gmock-function-mocker_test.cc.

                                                                 {
  using Argument = TypeParam;
  MockFunction<Argument> foo;
  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
}

TYPED_TEST() [19/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	MockMethodMockFunctionSignatureTest	,
		IsMockFunctionTemplateArgumentDeducedForStdFunction
	)

Definition at line 874 of file gmock-function-mocker_test.cc.

                                                                {
  using Argument = std::function<TypeParam>;
  MockFunction<Argument> foo;
  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
}

TYPED_TEST() [20/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	OverloadedMockMethodTest	,
		CanOverloadOnArgNumberInMacroBody
	)

Definition at line 739 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [21/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	TemplateMockTest	,
		MethodWithCommaInReturnTypeWorks
	)

Definition at line 611 of file gmock-function-mocker_test.cc.

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

TYPED_TEST() [22/22]

testing::gmock_function_mocker_test::TYPED_TEST	(	TemplateMockTest	,
		Works
	)

Definition at line 589 of file gmock-function-mocker_test.cc.

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

TYPED_TEST_SUITE() [1/5]

testing::gmock_function_mocker_test::TYPED_TEST_SUITE	(	ExpectCallTest	,
		ExpectCallTestTypes
	)

TYPED_TEST_SUITE() [2/5]

testing::gmock_function_mocker_test::TYPED_TEST_SUITE	(	FunctionMockerTest	,
		FunctionMockerTestTypes
	)

TYPED_TEST_SUITE() [3/5]

testing::gmock_function_mocker_test::TYPED_TEST_SUITE	(	MockMethodMockFunctionSignatureTest	,
		MockMethodMockFunctionSignatureTypes
	)

TYPED_TEST_SUITE() [4/5]

testing::gmock_function_mocker_test::TYPED_TEST_SUITE	(	OverloadedMockMethodTest	,
		OverloadedMockMethodTestTypes
	)

TYPED_TEST_SUITE() [5/5]

testing::gmock_function_mocker_test::TYPED_TEST_SUITE	(	TemplateMockTest	,
		TemplateMockTestTypes
	)