ApplyTupleTest.cpp File Reference

#include <iostream>
#include <folly/Overload.h>
#include <folly/functional/ApplyTuple.h>
#include <folly/portability/GTest.h>
#include <array>
#include <memory>

Go to the source code of this file.

Classes
struct	MemberFunc

Functions
	TEST (ApplyTuple, Test)
	TEST (ApplyTuple, Mutable)
	TEST (ApplyTuple, ConstOverloads)
	TEST (ApplyTuple, RefOverloads)
	TEST (ApplyTuple, MemberFunction)
	TEST (ApplyTuple, MemberFunctionWithRefWrapper)
	TEST (ApplyTuple, MemberFunctionWithConstPointer)
	TEST (ApplyTuple, MemberFunctionWithSharedPtr)
	TEST (ApplyTuple, MemberFunctionWithUniquePtr)
	TEST (ApplyTuple, Array)
	TEST (ApplyTuple, Pair)
	TEST (ApplyTuple, MultipleTuples)
	TEST (ApplyTuple, UncurryCopyMove)
	TEST (ApplyTuple, Uncurry)
	TEST (ApplyTuple, UncurryStdFind)
	TEST (MakeFromTupleTest, make_from_tuple)
	TEST (MakeIndexSequenceFromTuple, Basic)
	TEST (ApplyResult, Basic)
	TEST (IsApplicable, Basic)
	TEST (IsNothrowApplicable, Basic)
	TEST (IsApplicableR, Basic)
	TEST (IsNothrowApplicableR, Basic)
	TEST (ForwardTuple, Basic)

Function Documentation

TEST	(	ApplyTuple	,
		Test
	)

Definition at line 125 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, folly::gen::guard(), m, and std::tr1::make_tuple().

                       {
  auto argsTuple = std::make_tuple(1, 2, 3.0);
  auto func2 = func;
  folly::apply(func2, argsTuple);
  folly::apply(func, argsTuple);
  folly::apply(func, std::make_tuple(1, 2, 3.0));
  folly::apply(makeFunc(), std::make_tuple(1, 2, 3.0));
  folly::apply(makeFunc(), argsTuple);

  std::unique_ptr<Wat> wat(new Wat);
  folly::apply(&Wat::func, std::make_tuple(wat.get(), 1, 2, 3.0));
  auto argsTuple2 = std::make_tuple(wat.get(), 1, 2, 3.0);
  folly::apply(&Wat::func, argsTuple2);

  EXPECT_EQ(
      10.0, folly::apply(&Wat::retVal, std::make_tuple(wat.get(), 1, 9.0)));

  auto test = guard(func, 1, 2, 3.0);
  CopyCount cpy;
  auto test2 = guard(anotherFunc, cpy);
  auto test3 = guard(anotherFunc, std::cref(cpy));

  Overloaded ovl;
  EXPECT_EQ(
      0,
      folly::apply(
          static_cast<int (Overloaded::*)(int)>(&Overloaded::func),
          std::make_tuple(&ovl, 12)));
  EXPECT_EQ(
      /* do not code-mode to EXPECT_TRUE */ true,
      folly::apply(
          static_cast<bool (Overloaded::*)(bool)>(&Overloaded::func),
          std::make_tuple(&ovl, false)));

  int x = folly::apply(std::plus<int>(), std::make_tuple(12, 12));
  EXPECT_EQ(24, x);

  Mover m;
  folly::apply(
      move_only_func, std::forward_as_tuple(std::forward<Mover>(Mover())));
  const auto tuple3 = std::make_tuple(1, 2, 3.0);
  folly::apply(func, tuple3);
}

TEST	(	ApplyTuple	,
		Mutable
	)

Definition at line 169 of file ApplyTupleTest.cpp.

References a, folly::apply(), b, c, and std::tr1::make_tuple().

                          {
  auto argsTuple = std::make_tuple(1, 2, 3.0);

  folly::apply(
      [](int a, int b, double c) mutable { func(a, b, c); }, argsTuple);
}

TEST	(	ApplyTuple	,
		ConstOverloads
	)

Definition at line 176 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, std::tr1::make_tuple(), and folly::gen::move.

                                 {
  struct ConstOverloaded {
    ConstOverloaded() {}
    int operator()() {
      return 101;
    }
    int operator()() const {
      return 102;
    }
  };

  ConstOverloaded covl;

  // call operator()()
  EXPECT_EQ(folly::apply(covl, std::make_tuple()), 101);
  EXPECT_EQ(folly::apply(std::ref(covl), std::make_tuple()), 101);
  EXPECT_EQ(folly::apply(std::move(covl), std::make_tuple()), 101);

  // call operator()() const
  EXPECT_EQ(
      folly::apply(const_cast<ConstOverloaded const&>(covl), std::make_tuple()),
      102);
  EXPECT_EQ(folly::apply(std::cref(covl), std::make_tuple()), 102);
}

TEST	(	ApplyTuple	,
		RefOverloads
	)

Definition at line 201 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, std::tr1::make_tuple(), and folly::gen::move.

                               {
  struct RefOverloaded {
    RefOverloaded() {}
    int operator()() & {
      return 201;
    }
    int operator()() const& {
      return 202;
    }
    int operator()() && {
      return 203;
    }
  };

  RefOverloaded rovl;

  // call operator()() &
  EXPECT_EQ(folly::apply(rovl, std::make_tuple()), 201);
  EXPECT_EQ(folly::apply(std::ref(rovl), std::make_tuple()), 201);

  // call operator()() const &
  EXPECT_EQ(
      folly::apply(const_cast<RefOverloaded const&>(rovl), std::make_tuple()),
      202);
  EXPECT_EQ(folly::apply(std::cref(rovl), std::make_tuple()), 202);

  // call operator()() &&
  EXPECT_EQ(folly::apply(std::move(rovl), std::make_tuple()), 203);
}

TEST	(	ApplyTuple	,
		MemberFunction
	)

Definition at line 241 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, MemberFunc::getX(), std::tr1::make_tuple(), MemberFunc::setX(), and MemberFunc::x.

                                 {
  MemberFunc mf;
  mf.x = 123;

  // call getter
  EXPECT_EQ(folly::apply(&MemberFunc::getX, std::make_tuple(&mf)), 123);

  // call setter
  folly::apply(&MemberFunc::setX, std::make_tuple(&mf, 234));
  EXPECT_EQ(mf.x, 234);
  EXPECT_EQ(folly::apply(&MemberFunc::getX, std::make_tuple(&mf)), 234);
}

TEST	(	ApplyTuple	,
		MemberFunctionWithRefWrapper
	)

Definition at line 254 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, MemberFunc::getX(), std::tr1::make_tuple(), and MemberFunc::x.

                                               {
  MemberFunc mf;
  mf.x = 234;

  EXPECT_EQ(
      folly::apply(&MemberFunc::getX, std::make_tuple(std::ref(mf))), 234);
}

TEST	(	ApplyTuple	,
		MemberFunctionWithConstPointer
	)

Definition at line 262 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, MemberFunc::getX(), std::tr1::make_tuple(), and MemberFunc::x.

                                                 {
  MemberFunc mf;
  mf.x = 234;

  EXPECT_EQ(
      folly::apply(
          &MemberFunc::getX,
          std::make_tuple(const_cast<MemberFunc const*>(&mf))),
      234);
}

TEST	(	ApplyTuple	,
		MemberFunctionWithSharedPtr
	)

Definition at line 273 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, MemberFunc::getX(), std::tr1::make_tuple(), and MemberFunc::x.

                                              {
  MemberFunc mf;
  mf.x = 234;

  EXPECT_EQ(
      folly::apply(
          &MemberFunc::getX, std::make_tuple(std::make_shared<MemberFunc>(mf))),
      234);
}

TEST	(	ApplyTuple	,
		MemberFunctionWithUniquePtr
	)

Definition at line 283 of file ApplyTupleTest.cpp.

References folly::apply(), EXPECT_EQ, MemberFunc::getX(), std::tr1::make_tuple(), and MemberFunc::x.

                                              {
  MemberFunc mf;
  mf.x = 234;

  EXPECT_EQ(
      folly::apply(
          &MemberFunc::getX, std::make_tuple(std::make_unique<MemberFunc>(mf))),
      234);
}

TEST	(	ApplyTuple	,
		Array
	)

Definition at line 293 of file ApplyTupleTest.cpp.

References folly::apply().

                        {
  folly::apply(func, std::array<int, 3>{{1, 2, 3}});
  folly::apply(func, std::array<double, 3>{{1, 2, 3}});
}

TEST	(	ApplyTuple	,
		Pair
	)

Definition at line 298 of file ApplyTupleTest.cpp.

References add, folly::apply(), EXPECT_EQ, and x.

                       {
  auto add = [](int x, int y) { return x + y; };

  EXPECT_EQ(folly::apply(add, std::pair<int, int>{1200, 34}), 1234);
}

TEST	(	ApplyTuple	,
		MultipleTuples
	)

Definition at line 304 of file ApplyTupleTest.cpp.

References add, folly::apply(), EXPECT_EQ, std::tr1::make_tuple(), and x.

                                 {
  auto add = [](int x, int y, int z) { return x * 100 + y * 10 + z; };

  EXPECT_EQ(123, folly::apply(add, std::make_tuple(1, 2, 3)));
  EXPECT_EQ(
      123,
      folly::apply(
          add, std::tuple_cat(std::make_tuple(1, 2, 3), std::make_tuple())));
  EXPECT_EQ(
      123,
      folly::apply(
          add, std::tuple_cat(std::make_tuple(1, 2), std::make_tuple(3))));
  EXPECT_EQ(
      123,
      folly::apply(
          add, std::tuple_cat(std::make_tuple(1), std::make_tuple(2, 3))));
  EXPECT_EQ(
      123,
      folly::apply(
          add, std::tuple_cat(std::make_tuple(), std::make_tuple(1, 2, 3))));

  EXPECT_EQ(
      123,
      folly::apply(
          add,
          std::tuple_cat(
              std::make_tuple(1, 2, 3), std::make_tuple(), std::make_tuple())));
  EXPECT_EQ(
      123,
      folly::apply(
          add,
          std::tuple_cat(
              std::make_tuple(1), std::make_tuple(2), std::make_tuple(3))));
  EXPECT_EQ(
      123,
      folly::apply(
          add,
          std::tuple_cat(
              std::make_tuple(1), std::make_tuple(), std::make_tuple(2, 3))));
}

TEST	(	ApplyTuple	,
		UncurryCopyMove
	)

Definition at line 345 of file ApplyTupleTest.cpp.

References a, b, EXPECT_EQ, EXPECT_NE, std::tr1::make_tuple(), folly::gen::move, string, and folly::uncurry().

                                  {
  std::string separator = "================================\n";
  auto formatRow = folly::uncurry([=](std::string a, std::string b) {
    // capture separator by copy
    return separator + a + "\n" + b + "\n" + separator;
  });
  auto row = std::make_tuple("hello", "world");
  auto expected = separator + "hello\nworld\n" + separator;
  EXPECT_EQ(expected, formatRow(row));
  auto formatRowCopy = formatRow;
  EXPECT_EQ(expected, formatRowCopy(row));
  auto formatRowMove = std::move(formatRow);
  EXPECT_EQ(expected, formatRowMove(row));

  // capture value moved out from formatRow
  EXPECT_NE(expected, formatRow(row));
}

TEST	(	ApplyTuple	,
		Uncurry
	)

Definition at line 363 of file ApplyTupleTest.cpp.

References a, b, cat, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, string, and folly::uncurry().

                          {
  EXPECT_EQ(42, folly::uncurry([](int x, int y) {
              return x * y;
            })(std::pair<int, int>(6, 7)));
  EXPECT_EQ(42, folly::uncurry([](int&& x, int&& y) {
              return x * y;
            })(std::pair<int&&, int&&>(6, 7)));
  EXPECT_EQ(42, folly::uncurry([](int&& x, int&& y) {
              return x * y;
            })(std::pair<int&&, int&&>(6, 7)));

  std::string long1 = "a long string exceeding small string size";
  std::string long2 = "and here is another one!";
  std::string expected = long1 + long2;

  auto cat = folly::uncurry(
      [](std::string a, std::string b) { return std::move(a) + std::move(b); });

  EXPECT_EQ(expected, cat(std::make_pair(long1, long2)));
  EXPECT_FALSE(long1.empty());
  EXPECT_FALSE(long2.empty());
  EXPECT_EQ(expected, cat(std::tie(long1, long2)));
  EXPECT_FALSE(long1.empty());
  EXPECT_FALSE(long2.empty());
  EXPECT_EQ(
      expected, cat(std::forward_as_tuple(std::move(long1), std::move(long2))));
  EXPECT_TRUE(long1.empty());
  EXPECT_TRUE(long2.empty());
}

TEST	(	ApplyTuple	,
		UncurryStdFind
	)

Definition at line 393 of file ApplyTupleTest.cpp.

References a, testing::Args(), b, EXPECT_EQ, and folly::uncurry().

                                 {
  std::vector<std::pair<int, int>> v{{1, 9}, {2, 8}, {3, 7}, {4, 6}, {5, 5}};
  EXPECT_EQ(
      3, std::count_if(v.begin(), v.end(), folly::uncurry([](int a, int b) {
                         return b % a == 0;
                       })));
}

TEST	(	MakeFromTupleTest	,
		make_from_tuple
	)

Definition at line 410 of file ApplyTupleTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::gen::move, and string.

                                         {
  S expected{42, 1.0, "foobar"};

  // const lvalue ref
  auto s1 = folly::make_from_tuple<S>(expected.tuple_);
  EXPECT_EQ(expected.tuple_, s1.tuple_);

  // rvalue ref
  S sCopy{expected.tuple_};
  auto s2 = folly::make_from_tuple<S>(std::move(sCopy.tuple_));
  EXPECT_EQ(expected.tuple_, s2.tuple_);
  EXPECT_TRUE(std::get<2>(sCopy.tuple_).empty());

  // forward
  std::string str{"foobar"};
  auto s3 =
      folly::make_from_tuple<S>(std::forward_as_tuple(42, 1.0, std::move(str)));
  EXPECT_EQ(expected.tuple_, s3.tuple_);
  EXPECT_TRUE(str.empty());
}

TEST	(	MakeIndexSequenceFromTuple	,
		Basic
	)

Definition at line 431 of file ApplyTupleTest.cpp.

References EXPECT_TRUE, and value.

                                        {
  using folly::index_sequence;
  using folly::index_sequence_for_tuple;
  using OneElementTuple = std::tuple<int>;
  using TwoElementTuple = std::tuple<int>;

  EXPECT_TRUE((std::is_same<
               index_sequence_for_tuple<OneElementTuple>,
               index_sequence<0>>::value));
  EXPECT_TRUE((std::is_same<
               index_sequence_for_tuple<const OneElementTuple>,
               index_sequence<0>>::value));

  EXPECT_TRUE((std::is_same<
               index_sequence_for_tuple<TwoElementTuple>,
               index_sequence<0>>::value));
  EXPECT_TRUE((std::is_same<
               index_sequence_for_tuple<const TwoElementTuple>,
               index_sequence<0>>::value));
}

TEST	(	ApplyResult	,
		Basic
	)

Definition at line 452 of file ApplyTupleTest.cpp.

References EXPECT_TRUE, f, folly::overload(), and value.

                         {
  {
    auto f = [](auto) -> int { return {}; };
    EXPECT_TRUE((std::is_same<
                 folly::apply_result_t<decltype(f), std::tuple<int>>,
                 int>{}));
  }

  {
    auto f = folly::overload(
        [](int) {},
        [](double) -> double { return {}; },
        [](int, int) -> int { return {}; });

    EXPECT_TRUE((std::is_same<
                 folly::apply_result_t<decltype(f), std::tuple<int>>,
                 void>::value));
    EXPECT_TRUE((std::is_same<
                 folly::apply_result_t<decltype(f), std::tuple<double>>,
                 double>::value));
    EXPECT_TRUE((std::is_same<
                 folly::apply_result_t<decltype(f), std::tuple<int, int>>,
                 int>::value));
  }
}

TEST	(	IsApplicable	,
		Basic
	)

Definition at line 478 of file ApplyTupleTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::overload(), and value.

                          {
  {
    auto f = [] {};
    EXPECT_TRUE((folly::is_applicable<decltype(f), std::tuple<>>::value));
    EXPECT_FALSE((folly::is_applicable<decltype(f), std::tuple<int>>::value));
  }
  {
    auto f = folly::overload([](int) {}, [](double) -> double { return {}; });
    EXPECT_TRUE((folly::is_applicable<decltype(f), std::tuple<double>>::value));
    EXPECT_TRUE((folly::is_applicable<decltype(f), std::tuple<int>>::value));
    EXPECT_FALSE((folly::is_applicable<decltype(f), std::tuple<>>::value));
    EXPECT_FALSE(
        (folly::is_applicable<decltype(f), std::tuple<int, double>>::value));
  }
}

TEST	(	IsNothrowApplicable	,
		Basic
	)

Definition at line 494 of file ApplyTupleTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::pushmi::__adl::noexcept(), folly::overload(), and value.

                                 {
  {
    auto f = []() noexcept {};
    EXPECT_TRUE((folly::is_nothrow_applicable<decltype(f), std::tuple<>>{}));
    EXPECT_FALSE(
        (folly::is_nothrow_applicable<decltype(f), std::tuple<int>>{}));
  }
  {
    auto f = folly::overload(
        [](int) noexcept {}, [](double) -> double { return {}; });
    EXPECT_FALSE(
        (folly::is_nothrow_applicable<decltype(f), std::tuple<double>>{}));
    EXPECT_TRUE((folly::is_nothrow_applicable<decltype(f), std::tuple<int>>{}));
    EXPECT_FALSE((folly::is_nothrow_applicable<decltype(f), std::tuple<>>{}));
    EXPECT_FALSE(
        (folly::is_nothrow_applicable<decltype(f), std::tuple<int, double>>::
             value));
  }
}

TEST	(	IsApplicableR	,
		Basic
	)

Definition at line 514 of file ApplyTupleTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::pushmi::__adl::noexcept(), folly::overload(), and value.

                           {
  {
    auto f = []() -> int { return {}; };
    EXPECT_TRUE((folly::is_applicable_r<double, decltype(f), std::tuple<>>{}));
    EXPECT_FALSE(
        (folly::is_applicable_r<double, decltype(f), std::tuple<int>>{}));
  }
  {
    auto f = folly::overload(
        [](int) noexcept {}, [](double) -> double { return {}; });
    EXPECT_TRUE(
        (folly::is_applicable_r<float, decltype(f), std::tuple<double>>{}));
    EXPECT_TRUE((folly::is_applicable_r<void, decltype(f), std::tuple<int>>{}));
    EXPECT_FALSE((folly::is_applicable_r<void, decltype(f), std::tuple<>>{}));
    EXPECT_FALSE(
        (folly::is_applicable_r<double, decltype(f), std::tuple<int, double>>::
             value));
  }
}

TEST	(	IsNothrowApplicableR	,
		Basic
	)

Definition at line 534 of file ApplyTupleTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::pushmi::__adl::noexcept(), folly::overload(), and value.

                                  {
  {
    auto f = []() noexcept->int {
      return {};
    };
    EXPECT_TRUE(
        (folly::is_nothrow_applicable_r<double, decltype(f), std::tuple<>>{}));
    EXPECT_FALSE(
        (folly::
             is_nothrow_applicable_r<double, decltype(f), std::tuple<int>>{}));
  }
  {
    auto f = folly::overload(
        [](int) noexcept {}, [](double) -> double { return {}; });
    EXPECT_FALSE((
        folly::
            is_nothrow_applicable_r<float, decltype(f), std::tuple<double>>{}));
    EXPECT_TRUE(
        (folly::is_nothrow_applicable_r<void, decltype(f), std::tuple<int>>{}));
    EXPECT_FALSE(
        (folly::is_nothrow_applicable_r<void, decltype(f), std::tuple<>>{}));
    EXPECT_FALSE((folly::is_nothrow_applicable_r<
                  double,
                  decltype(f),
                  std::tuple<int, double>>::value));
  }
}

TEST	(	ForwardTuple	,
		Basic
	)

Definition at line 562 of file ApplyTupleTest.cpp.

References folly::as_const(), EXPECT_EQ, EXPECT_TRUE, folly::forward_tuple(), std::tr1::make_tuple(), folly::gen::move, and value.

                          {
  auto tuple = std::make_tuple(1, 2.0);

  EXPECT_TRUE((std::is_same<
               decltype(folly::forward_tuple(tuple)),
               std::tuple<int&, double&>>::value));
  EXPECT_EQ(folly::forward_tuple(tuple), tuple);
  EXPECT_TRUE((std::is_same<
               decltype(folly::forward_tuple(folly::as_const(tuple))),
               std::tuple<const int&, const double&>>::value));
  EXPECT_EQ(folly::forward_tuple(folly::as_const(tuple)), tuple);

  EXPECT_TRUE((std::is_same<
               decltype(folly::forward_tuple(std::move(tuple))),
               std::tuple<int&&, double&&>>::value));
  EXPECT_EQ(folly::forward_tuple(std::move(tuple)), tuple);
  EXPECT_TRUE(
      (std::is_same<
          decltype(folly::forward_tuple(std::move(folly::as_const(tuple)))),
          std::tuple<const int&, const double&>>::value));
  EXPECT_EQ(folly::forward_tuple(std::move(folly::as_const(tuple))), tuple);

  auto integer = 1;
  auto floating_point = 2.0;
  auto ref_tuple = std::forward_as_tuple(integer, std::move(floating_point));

  EXPECT_TRUE((std::is_same<
               decltype(folly::forward_tuple(ref_tuple)),
               std::tuple<int&, double&>>::value));

  EXPECT_TRUE((std::is_same<
               decltype(folly::forward_tuple(std::move(ref_tuple))),
               std::tuple<int&, double&&>>::value));

  EXPECT_TRUE((std::is_same<
               decltype(std::tuple_cat(
                   folly::forward_tuple(tuple),
                   folly::forward_tuple(std::move(tuple)))),
               std::tuple<int&, double&, int&&, double&&>>::value));
}