gmock_link_test.h File Reference

#include "gmock/gmock.h"
#include <errno.h>
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h"
#include <iostream>
#include <vector>

Go to the source code of this file.

Classes
class	Interface
class	Mock
class	InvokeHelper
class	FieldHelper

Functions
	TEST (LinkTest, TestReturnVoid)
	TEST (LinkTest, TestReturn)
	TEST (LinkTest, TestReturnNull)
	TEST (LinkTest, TestReturnRef)
	TEST (LinkTest, TestAssign)
	TEST (LinkTest, TestSetArgPointee)
	TEST (LinkTest, TestSetArrayArgument)
	TEST (LinkTest, TestSetErrnoAndReturn)
	TEST (LinkTest, TestInvoke)
	TEST (LinkTest, TestInvokeWithoutArgs)
	TEST (LinkTest, TestInvokeArgument)
	TEST (LinkTest, TestWithArg)
	TEST (LinkTest, TestWithArgs)
	TEST (LinkTest, TestWithoutArgs)
	TEST (LinkTest, TestDoAll)
	TEST (LinkTest, TestDoDefault)
	TEST (LinkTest, TestIgnoreResult)
	TEST (LinkTest, TestActionMacro)
	TEST (LinkTest, TestActionPMacro)
	TEST (LinkTest, TestActionP2Macro)
	TEST (LinkTest, TestMatcherAnything)
	TEST (LinkTest, TestMatcherA)
	TEST (LinkTest, TestMatchersEq)
	TEST (LinkTest, TestMatchersRelations)
	TEST (LinkTest, TestMatcherNotNull)
	TEST (LinkTest, TestMatcherIsNull)
	TEST (LinkTest, TestMatcherRef)
	TEST (LinkTest, TestMatcherTypedEq)
	TEST (LinkTest, TestMatchersFloatingPoint)
	TEST (LinkTest, TestMatcherContainsRegex)
	TEST (LinkTest, TestMatcherMatchesRegex)
	TEST (LinkTest, TestMatchersSubstrings)
	TEST (LinkTest, TestMatchersStringEquality)
	TEST (LinkTest, TestMatcherElementsAre)
	TEST (LinkTest, TestMatcherElementsAreArray)
	TEST (LinkTest, TestMatcherContainerEq)
	TEST (LinkTest, TestMatcherField)
	TEST (LinkTest, TestMatcherProperty)
	TEST (LinkTest, TestMatcherResultOf)
	TEST (LinkTest, TestMatcherPointee)
	TEST (LinkTest, TestMatcherTruly)
	TEST (LinkTest, TestMatcherAllOf)
	TEST (LinkTest, TestMatcherAnyOf)
	TEST (LinkTest, TestMatcherNot)
	TEST (LinkTest, TestMatcherCast)

Function Documentation

TEST	(	LinkTest	,
		TestReturnVoid
	)

Definition at line 242 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::Return(), and Interface::VoidFromString().

Referenced by TEST().

                               {
  Mock mock;

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestReturn
	)

Definition at line 250 of file gmock_link_test.h.

References testing::_, ch, EXPECT_CALL, testing::Return(), and Interface::StringFromString().

                           {
  Mock mock;
  char ch = 'x';

  EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
  mock.StringFromString(NULL);
}

TEST	(	LinkTest	,
		TestReturnNull
	)

Definition at line 259 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::Return(), and Interface::VoidFromString().

                               {
  Mock mock;

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestReturnRef
	)

Definition at line 267 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, Interface::IntRefFromString(), and testing::ReturnRef().

                              {
  Mock mock;
  int n = 42;

  EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
  mock.IntRefFromString(NULL);
}

TEST	(	LinkTest	,
		TestAssign
	)

Definition at line 276 of file gmock_link_test.h.

References testing::_, testing::Assign(), ch, EXPECT_CALL, and Interface::VoidFromString().

                           {
  Mock mock;
  char ch = 'x';

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestSetArgPointee
	)

Definition at line 285 of file gmock_link_test.h.

References testing::_, ch, EXPECT_CALL, and Interface::VoidFromString().

                                  {
  Mock mock;
  char ch = 'x';

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArgPointee<0>('y'));
  mock.VoidFromString(&ch);
}

TEST	(	LinkTest	,
		TestSetArrayArgument
	)

Definition at line 294 of file gmock_link_test.h.

References testing::_, ch, EXPECT_CALL, and Interface::VoidFromString().

                                     {
  Mock mock;
  char ch = 'x';
  char ch2 = 'y';

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArrayArgument<0>(&ch2,
                                                                    &ch2 + 1));
  mock.VoidFromString(&ch);
}

TEST	(	LinkTest	,
		TestSetErrnoAndReturn
	)

Definition at line 307 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, Interface::IntFromString(), and testing::SetErrnoAndReturn().

                                      {
  Mock mock;

  int saved_errno = errno;
  EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
  mock.IntFromString(NULL);
  errno = saved_errno;
}

TEST	(	LinkTest	,
		TestInvoke
	)

Definition at line 319 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::Invoke(), InvokeHelper::StaticVoidFromString(), Interface::VoidFromString(), and InvokeHelper::VoidFromString().

                           {
  Mock mock;
  InvokeHelper test_invoke_helper;

  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
      .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
  mock.VoidFromString(NULL);
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestInvokeWithoutArgs
	)

Definition at line 331 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::InvokeWithoutArgs(), InvokeHelper::StaticVoidFromVoid(), Interface::VoidFromString(), and InvokeHelper::VoidFromVoid().

                                      {
  Mock mock;
  InvokeHelper test_invoke_helper;

  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
      .WillOnce(InvokeWithoutArgs(&test_invoke_helper,
                                  &InvokeHelper::VoidFromVoid));
  mock.VoidFromString(NULL);
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestInvokeArgument
	)

Definition at line 344 of file gmock_link_test.h.

References testing::_, ch, EXPECT_CALL, InvokeHelper::StaticVoidFromString(), and Interface::VoidFromFunc().

                                   {
  Mock mock;
  char ch = 'x';

  EXPECT_CALL(mock, VoidFromFunc(_)).WillOnce(InvokeArgument<0>(&ch));
  mock.VoidFromFunc(InvokeHelper::StaticVoidFromString);
}

TEST	(	LinkTest	,
		TestWithArg
	)

Definition at line 353 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::Invoke(), InvokeHelper::StaticVoidFromString(), and Interface::VoidFromString().

                            {
  Mock mock;

  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestWithArgs
	)

Definition at line 362 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::Invoke(), InvokeHelper::StaticVoidFromString(), and Interface::VoidFromString().

                             {
  Mock mock;

  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestWithoutArgs
	)

Definition at line 371 of file gmock_link_test.h.

References testing::_, EXPECT_CALL, testing::Return(), Interface::VoidFromString(), and testing::WithoutArgs().

                                {
  Mock mock;

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestDoAll
	)

Definition at line 379 of file gmock_link_test.h.

References testing::_, ch, testing::DoAll(), EXPECT_CALL, testing::Return(), and Interface::VoidFromString().

                          {
  Mock mock;
  char ch = 'x';

  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(DoAll(SetArgPointee<0>('y'), Return()));
  mock.VoidFromString(&ch);
}

TEST	(	LinkTest	,
		TestDoDefault
	)

Definition at line 389 of file gmock_link_test.h.

References testing::_, ch, testing::DoDefault(), EXPECT_CALL, ON_CALL, testing::Return(), and Interface::VoidFromString().

                              {
  Mock mock;
  char ch = 'x';

  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(DoDefault());
  mock.VoidFromString(&ch);
}

TEST	(	LinkTest	,
		TestIgnoreResult
	)

Definition at line 399 of file gmock_link_test.h.

References testing::_, ACTION, EXPECT_CALL, EXPECT_THROW, testing::IgnoreResult(), LinkTest, testing::Return(), TEST(), and Interface::VoidFromString().

                                 {
  Mock mock;

  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
  mock.VoidFromString(NULL);
}

TEST	(	LinkTest	,
		TestActionMacro
	)

Definition at line 431 of file gmock_link_test.h.

References testing::_, ACTION_P, EXPECT_CALL, and Interface::IntFromString().

                                {
  Mock mock;

  EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
  mock.IntFromString(NULL);
}

TEST	(	LinkTest	,
		TestActionPMacro
	)

Definition at line 443 of file gmock_link_test.h.

References testing::_, ACTION_P2, EXPECT_CALL, folly::gen::first, and Interface::IntFromString().

                                 {
  Mock mock;

  EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
  mock.IntFromString(NULL);
}

TEST	(	LinkTest	,
		TestActionP2Macro
	)

Definition at line 461 of file gmock_link_test.h.

References testing::_, ch, EXPECT_CALL, and Interface::IntFromString().

                                  {
  Mock mock;
  char ch = 'x';

  EXPECT_CALL(mock, IntFromString(_))
      .WillOnce(ReturnEqualsEitherOf("one", "two"));
  mock.IntFromString(&ch);
}

TEST	(	LinkTest	,
		TestMatcherAnything
	)

Definition at line 471 of file gmock_link_test.h.

References testing::_, ON_CALL, testing::Return(), and Interface::VoidFromString().

                                    {
  Mock mock;

  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherA
	)

Definition at line 478 of file gmock_link_test.h.

References ON_CALL, testing::Return(), and Interface::VoidFromString().

                             {
  Mock mock;

  ON_CALL(mock, VoidFromString(A<char*>())).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatchersEq
	)

Definition at line 485 of file gmock_link_test.h.

References testing::Eq(), ON_CALL, testing::Return(), and Interface::VoidFromString().

                               {
  Mock mock;
  const char* p = "x";

  ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(const_cast<char*>("y")))
      .WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatchersRelations
	)

Definition at line 495 of file gmock_link_test.h.

References f, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), testing::Ne(), ON_CALL, testing::Return(), and Interface::VoidFromFloat().

                                      {
  Mock mock;

  ON_CALL(mock, VoidFromFloat(Lt(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Gt(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Le(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Ge(1.0f))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(Ne(1.0f))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherNotNull
	)

Definition at line 506 of file gmock_link_test.h.

References testing::NotNull(), ON_CALL, testing::Return(), and Interface::VoidFromString().

                                   {
  Mock mock;

  ON_CALL(mock, VoidFromString(NotNull())).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherIsNull
	)

Definition at line 513 of file gmock_link_test.h.

References testing::IsNull(), ON_CALL, testing::Return(), and Interface::VoidFromString().

                                  {
  Mock mock;

  ON_CALL(mock, VoidFromString(IsNull())).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherRef
	)

Definition at line 520 of file gmock_link_test.h.

References a, ON_CALL, testing::Ref(), testing::Return(), and Interface::VoidFromIntRef().

                               {
  Mock mock;
  int a = 0;

  ON_CALL(mock, VoidFromIntRef(Ref(a))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherTypedEq
	)

Definition at line 528 of file gmock_link_test.h.

References a, ON_CALL, testing::Return(), and Interface::VoidFromIntRef().

                                   {
  Mock mock;
  long a = 0;

  ON_CALL(mock, VoidFromIntRef(TypedEq<int&>(a))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatchersFloatingPoint
	)

Definition at line 537 of file gmock_link_test.h.

References a, testing::DoubleEq(), testing::FloatEq(), testing::NanSensitiveDoubleEq(), testing::NanSensitiveFloatEq(), ON_CALL, testing::Return(), Interface::VoidFromDouble(), and Interface::VoidFromFloat().

                                          {
  Mock mock;
  float a = 0;

  ON_CALL(mock, VoidFromFloat(FloatEq(a))).WillByDefault(Return());
  ON_CALL(mock, VoidFromDouble(DoubleEq(a))).WillByDefault(Return());
  ON_CALL(mock, VoidFromFloat(NanSensitiveFloatEq(a))).WillByDefault(Return());
  ON_CALL(mock, VoidFromDouble(NanSensitiveDoubleEq(a)))
      .WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherContainsRegex
	)

Definition at line 549 of file gmock_link_test.h.

References testing::ContainsRegex(), ON_CALL, testing::Return(), and Interface::VoidFromString().

                                         {
  Mock mock;

  ON_CALL(mock, VoidFromString(ContainsRegex(".*"))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherMatchesRegex
	)

Definition at line 556 of file gmock_link_test.h.

References testing::MatchesRegex(), ON_CALL, testing::Return(), and Interface::VoidFromString().

                                        {
  Mock mock;

  ON_CALL(mock, VoidFromString(MatchesRegex(".*"))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatchersSubstrings
	)

Definition at line 563 of file gmock_link_test.h.

References testing::EndsWith(), testing::HasSubstr(), ON_CALL, testing::Return(), testing::StartsWith(), and Interface::VoidFromString().

                                       {
  Mock mock;

  ON_CALL(mock, VoidFromString(StartsWith("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(EndsWith("c"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(HasSubstr("b"))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatchersStringEquality
	)

Definition at line 572 of file gmock_link_test.h.

References ON_CALL, testing::Return(), testing::StrCaseEq(), testing::StrCaseNe(), testing::StrEq(), testing::StrNe(), and Interface::VoidFromString().

                                           {
  Mock mock;
  ON_CALL(mock, VoidFromString(StrEq("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(StrNe("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(StrCaseEq("a"))).WillByDefault(Return());
  ON_CALL(mock, VoidFromString(StrCaseNe("a"))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherElementsAre
	)

Definition at line 581 of file gmock_link_test.h.

References testing::_, testing::ElementsAre(), ON_CALL, testing::Return(), and Interface::VoidFromVector().

                                       {
  Mock mock;

  ON_CALL(mock, VoidFromVector(ElementsAre('a', _))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherElementsAreArray
	)

Definition at line 588 of file gmock_link_test.h.

References testing::ElementsAreArray(), ON_CALL, testing::Return(), and Interface::VoidFromVector().

                                            {
  Mock mock;
  char arr[] = { 'a', 'b' };

  ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherContainerEq
	)

Definition at line 596 of file gmock_link_test.h.

References testing::ContainerEq(), ON_CALL, testing::Return(), v, and Interface::VoidFromVector().

                                       {
  Mock mock;
  std::vector<int> v;

  ON_CALL(mock, VoidFromVector(ContainerEq(v))).WillByDefault(Return());
}

TEST	(	LinkTest	,
		TestMatcherField
	)

Definition at line 604 of file gmock_link_test.h.

References testing::Eq(), EXPECT_TRUE, testing::Field(), FieldHelper::field_, m, and testing::internal::MatcherBase< T >::Matches().

                                 {
  FieldHelper helper(0);

  Matcher<const FieldHelper&> m = Field(&FieldHelper::field_, Eq(0));
  EXPECT_TRUE(m.Matches(helper));

  Matcher<const FieldHelper*> m2 = Field(&FieldHelper::field_, Eq(0));
  EXPECT_TRUE(m2.Matches(&helper));
}

TEST	(	LinkTest	,
		TestMatcherProperty
	)

Definition at line 615 of file gmock_link_test.h.

References testing::Eq(), EXPECT_TRUE, FieldHelper::field(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Property().

                                    {
  FieldHelper helper(0);

  Matcher<const FieldHelper&> m = Property(&FieldHelper::field, Eq(0));
  EXPECT_TRUE(m.Matches(helper));

  Matcher<const FieldHelper*> m2 = Property(&FieldHelper::field, Eq(0));
  EXPECT_TRUE(m2.Matches(&helper));
}

TEST	(	LinkTest	,
		TestMatcherResultOf
	)

Definition at line 626 of file gmock_link_test.h.

References testing::Eq(), EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and InvokeHelper::StaticIntFromString().

                                    {
  Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
  EXPECT_TRUE(m.Matches(NULL));
}

TEST	(	LinkTest	,
		TestMatcherPointee
	)

Definition at line 632 of file gmock_link_test.h.

References testing::Eq(), EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                                   {
  int n = 1;

  Matcher<int*> m = Pointee(Eq(1));
  EXPECT_TRUE(m.Matches(&n));
}

TEST	(	LinkTest	,
		TestMatcherTruly
	)

Definition at line 640 of file gmock_link_test.h.

References EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), InvokeHelper::StaticBoolFromString(), and testing::Truly().

                                 {
  Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
  EXPECT_TRUE(m.Matches(NULL));
}

TEST	(	LinkTest	,
		TestMatcherAllOf
	)

Definition at line 646 of file gmock_link_test.h.

References testing::_, testing::Eq(), EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                 {
  Matcher<int> m = AllOf(_, Eq(1));
  EXPECT_TRUE(m.Matches(1));
}

TEST	(	LinkTest	,
		TestMatcherAnyOf
	)

Definition at line 652 of file gmock_link_test.h.

References testing::_, testing::AnyOf(), testing::Eq(), EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                 {
  Matcher<int> m = AnyOf(_, Eq(1));
  EXPECT_TRUE(m.Matches(1));
}

TEST	(	LinkTest	,
		TestMatcherNot
	)

Definition at line 658 of file gmock_link_test.h.

References testing::_, EXPECT_FALSE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Not().

                               {
  Matcher<int> m = Not(_);
  EXPECT_FALSE(m.Matches(1));
}

TEST	(	LinkTest	,
		TestMatcherCast
	)

Definition at line 664 of file gmock_link_test.h.

References testing::_, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                {
  Matcher<const char*> m = MatcherCast<const char*>(_);
  EXPECT_TRUE(m.Matches(NULL));
}