PartialTest.cpp File Reference

#include <memory>
#include <folly/Function.h>
#include <folly/functional/Partial.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	Foo
struct	RefQualifiers
struct	RefQualifiers2

Functions
int	add3 (int x, int y, int z)
	TEST (Partial, Simple)
	TEST (Partial, ReferenceArguments)
	TEST (Partial, RefQualifiers)
	TEST (Partial, RefQualifiers2)
std::unique_ptr< int >	calc_uptr (std::unique_ptr< int > x, std::unique_ptr< int > y)
	TEST (Partial, MoveOnly)
	TEST (Partial, WrapInStdFunction)
	TEST (Partial, WrapInFollyFunction)

Function Documentation

int add3	(	int	x,
		int	y,
		int	z
	)

Definition at line 26 of file PartialTest.cpp.

Referenced by TEST().

                              {
  return 100 * x + 10 * y + z;
}

std::unique_ptr<int> calc_uptr	(	std::unique_ptr< int >	x,
		std::unique_ptr< int >	y
	)

Definition at line 110 of file PartialTest.cpp.

References x.

Referenced by TEST().

                                                                         {
  *x = 100 * *x + 10 * *y;
  return x;
}

TEST	(	Partial	,
		Simple
	)

Definition at line 30 of file PartialTest.cpp.

References add3(), EXPECT_EQ, and folly::partial().

                      {
  auto p0 = partial(&add3);
  EXPECT_EQ(123, p0(1, 2, 3));

  auto p1 = partial(&add3, 2);
  EXPECT_EQ(234, p1(3, 4));

  auto p2 = partial(&add3, 3, 4);
  EXPECT_EQ(345, p2(5));

  auto p3 = partial(&add3, 4, 5, 6);
  EXPECT_EQ(456, p3());
}

TEST	(	Partial	,
		ReferenceArguments
	)

Definition at line 56 of file PartialTest.cpp.

References EXPECT_EQ, folly::gen::move, and folly::partial().

                                  {
  auto p0 = partial(&Foo::method, Foo{}, 2, 3);
  int four = 4;
  EXPECT_EQ(1234, p0(four));

  auto const p1 = partial(&Foo::constMethod, Foo{}, 3, 4);
  EXPECT_EQ(2345, p1(5));

  auto p2 = partial(&Foo::tempMethod, Foo{}, 4, 5);
  EXPECT_EQ(3456, std::move(p2)(6));
}

TEST	(	Partial	,
		RefQualifiers
	)

Definition at line 80 of file PartialTest.cpp.

References EXPECT_EQ, folly::gen::move, and folly::partial().

                             {
  auto p = partial(RefQualifiers{});
  auto const& pconst = p;

  EXPECT_EQ(1234, p(2, 3, 4));
  EXPECT_EQ(2345, pconst(3, 4, 5));
  EXPECT_EQ(3456, std::move(p)(4, 5, 6));
}

TEST	(	Partial	,
		RefQualifiers2
	)

Definition at line 101 of file PartialTest.cpp.

References EXPECT_EQ, folly::gen::move, and folly::partial().

                              {
  auto p = partial(RefQualifiers2{}, 9, 8);
  auto const& pconst = p;

  EXPECT_EQ(1984, p(4));
  EXPECT_EQ(2985, pconst(5));
  EXPECT_EQ(3986, std::move(p)(6));
}

TEST	(	Partial	,
		MoveOnly
	)

Definition at line 115 of file PartialTest.cpp.

References calc_uptr(), EXPECT_EQ, EXPECT_FALSE, folly::gen::move, and folly::partial().

                        {
  auto five = std::make_unique<int>(5);
  auto six = std::make_unique<int>(6);

  // create a partial object which holds a pointer to the `calc_uptr` function
  // and a `unique_ptr<int>` for the first argument
  auto p = partial(&calc_uptr, std::move(five));

  // `five` should be moved out of
  EXPECT_FALSE(five);

  // call to the partial object as rvalue, which allows the call to consume
  // captured data (here: the `unique_ptr<int>` storing 5), and pass it
  // the other `unique_ptr`
  auto result = std::move(p)(std::move(six));

  // ...which now should be moved out of
  EXPECT_FALSE(six);

  EXPECT_EQ(560, *result);
}

TEST	(	Partial	,
		WrapInStdFunction
	)

Definition at line 137 of file PartialTest.cpp.

References add3(), EXPECT_EQ, and folly::partial().

                                 {
  auto p1 = partial(&add3, 2);
  std::function<int(int, int)> func = p1;
  EXPECT_EQ(234, func(3, 4));
}

TEST	(	Partial	,
		WrapInFollyFunction
	)

Definition at line 143 of file PartialTest.cpp.

References add3(), EXPECT_EQ, and folly::partial().

                                   {
  auto p1 = partial(&add3, 2);
  folly::Function<int(int, int)> func = p1;
  EXPECT_EQ(234, func(3, 4));
}