InvokeTest.cpp File Reference

#include <folly/functional/Invoke.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	InvokeTest

Namespaces
	x
	y
	z
	swappable

Functions
	TEST_F (InvokeTest, invoke)
	TEST_F (InvokeTest, invoke_result)
	TEST_F (InvokeTest, is_invocable)
	TEST_F (InvokeTest, is_invocable_r)
	TEST_F (InvokeTest, is_nothrow_invocable)
	TEST_F (InvokeTest, is_nothrow_invocable_r)
	TEST_F (InvokeTest, free_invoke)
	TEST_F (InvokeTest, free_invoke_result)
	TEST_F (InvokeTest, free_is_invocable)
	TEST_F (InvokeTest, free_is_invocable_r)
	TEST_F (InvokeTest, free_is_nothrow_invocable)
	TEST_F (InvokeTest, free_is_nothrow_invocable_r)
	TEST_F (InvokeTest, free_invoke_swap)
	TEST_F (InvokeTest, member_invoke)
	TEST_F (InvokeTest, member_invoke_result)
	TEST_F (InvokeTest, member_is_invocable)
	TEST_F (InvokeTest, member_is_invocable_r)
	TEST_F (InvokeTest, member_is_nothrow_invocable)
	TEST_F (InvokeTest, member_is_nothrow_invocable_r)

Function Documentation

TEST_F	(	InvokeTest	,
		invoke
	)

Definition at line 92 of file InvokeTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::invoke(), and folly::pushmi::__adl::noexcept().

                           {
  Fn fn;

  EXPECT_TRUE(noexcept(folly::invoke(fn, 1, 2)));
  EXPECT_FALSE(noexcept(folly::invoke(fn, 1, "2")));

  EXPECT_EQ('a', folly::invoke(fn, 1, 2));
  EXPECT_EQ(17, folly::invoke(fn, 1, "2"));

  using FnA = char (Fn::*)(int, int);
  using FnB = int volatile && (Fn::*)(int, char const*);
  EXPECT_EQ('a', folly::invoke(static_cast<FnA>(&Fn::operator()), fn, 1, 2));
  EXPECT_EQ(17, folly::invoke(static_cast<FnB>(&Fn::operator()), fn, 1, "2"));
}

TEST_F	(	InvokeTest	,
		invoke_result
	)

Definition at line 107 of file InvokeTest.cpp.

References EXPECT_TRUE, and value.

                                  {
  EXPECT_TRUE(
      (std::is_same<char, folly::invoke_result_t<Fn, int, char>>::value));
  EXPECT_TRUE(
      (std::is_same<int volatile&&, folly::invoke_result_t<Fn, int, char*>>::
           value));
}

TEST_F	(	InvokeTest	,
		is_invocable
	)

Definition at line 115 of file InvokeTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                                 {
  EXPECT_TRUE((folly::is_invocable<Fn, int, char>::value));
  EXPECT_TRUE((folly::is_invocable<Fn, int, char*>::value));
  EXPECT_FALSE((folly::is_invocable<Fn, int>::value));
}

TEST_F	(	InvokeTest	,
		is_invocable_r
	)

Definition at line 121 of file InvokeTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                                   {
  EXPECT_TRUE((folly::is_invocable_r<int, Fn, int, char>::value));
  EXPECT_TRUE((folly::is_invocable_r<int, Fn, int, char*>::value));
  EXPECT_FALSE((folly::is_invocable_r<int, Fn, int>::value));
}

TEST_F	(	InvokeTest	,
		is_nothrow_invocable
	)

Definition at line 127 of file InvokeTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                                         {
  EXPECT_TRUE((folly::is_nothrow_invocable<Fn, int, char>::value));
  EXPECT_FALSE((folly::is_nothrow_invocable<Fn, int, char*>::value));
  EXPECT_FALSE((folly::is_nothrow_invocable<Fn, int>::value));
}

TEST_F	(	InvokeTest	,
		is_nothrow_invocable_r
	)

Definition at line 133 of file InvokeTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                                           {
  EXPECT_TRUE((folly::is_nothrow_invocable_r<int, Fn, int, char>::value));
  EXPECT_FALSE((folly::is_nothrow_invocable_r<int, Fn, int, char*>::value));
  EXPECT_FALSE((folly::is_nothrow_invocable_r<int, Fn, int>::value));
}

TEST_F	(	InvokeTest	,
		free_invoke
	)

Definition at line 139 of file InvokeTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::pushmi::invoke, folly::pushmi::__adl::noexcept(), x_, and y_.

                                {
  using traits = go_invoke_traits;

  x::Obj x_;
  y::Obj y_;

  EXPECT_TRUE(noexcept(traits::invoke(x_, 3)));
  EXPECT_FALSE(noexcept(traits::invoke(y_, "hello")));

  EXPECT_EQ(3, traits::invoke(x_, 3));
  EXPECT_EQ('a', traits::invoke(y_, "hello"));
}

TEST_F	(	InvokeTest	,
		free_invoke_result
	)

Definition at line 152 of file InvokeTest.cpp.

References EXPECT_TRUE, and value.

                                       {
  using traits = go_invoke_traits;

  EXPECT_TRUE((std::is_same<int, traits::invoke_result_t<x::Obj, int>>::value));
  EXPECT_TRUE((
      std::is_same<char, traits::invoke_result_t<y::Obj, char const*>>::value));
}

TEST_F	(	InvokeTest	,
		free_is_invocable
	)

Definition at line 160 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                      {
  using traits = go_invoke_traits;

  EXPECT_TRUE((traits::is_invocable<x::Obj, int>::value));
  EXPECT_TRUE((traits::is_invocable<y::Obj, char const*>::value));
  EXPECT_FALSE((traits::is_invocable<z::Obj, int>::value));
  EXPECT_FALSE((traits::is_invocable<float>::value));
}

TEST_F	(	InvokeTest	,
		free_is_invocable_r
	)

Definition at line 169 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                        {
  using traits = go_invoke_traits;

  EXPECT_TRUE((traits::is_invocable_r<int, x::Obj, int>::value));
  EXPECT_TRUE((traits::is_invocable_r<char, y::Obj, char const*>::value));
  EXPECT_FALSE((traits::is_invocable_r<float, z::Obj, int>::value));
  EXPECT_FALSE((traits::is_invocable_r<from_any, float>::value));
}

TEST_F	(	InvokeTest	,
		free_is_nothrow_invocable
	)

Definition at line 178 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                              {
  using traits = go_invoke_traits;

  EXPECT_TRUE((traits::is_nothrow_invocable<x::Obj, int>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable<y::Obj, char const*>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable<z::Obj, int>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable<float>::value));
}

TEST_F	(	InvokeTest	,
		free_is_nothrow_invocable_r
	)

Definition at line 187 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                                {
  using traits = go_invoke_traits;

  EXPECT_TRUE((traits::is_nothrow_invocable_r<int, x::Obj, int>::value));
  EXPECT_FALSE(
      (traits::is_nothrow_invocable_r<char, y::Obj, char const*>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable_r<float, z::Obj, int>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable_r<from_any, float>::value));
}

TEST_F	(	InvokeTest	,
		free_invoke_swap
	)

Definition at line 197 of file InvokeTest.cpp.

References a, b, EXPECT_EQ, folly::pushmi::invoke, and folly::f14::swap().

                                     {
  using traits = swap_invoke_traits;

  int a = 3;
  int b = 4;

  traits::invoke(a, b);
  EXPECT_EQ(4, a);
  EXPECT_EQ(3, b);

  swappable::Obj x{3};
  swappable::Obj y{4};

  traits::invoke(x, y);
  EXPECT_EQ(3, x.x_);
  EXPECT_EQ(4, y.x_);

  std::swap(x, y);
  EXPECT_EQ(4, x.x_);
  EXPECT_EQ(3, y.x_);
}

TEST_F	(	InvokeTest	,
		member_invoke
	)

Definition at line 219 of file InvokeTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::pushmi::invoke, and folly::pushmi::__adl::noexcept().

                                  {
  using traits = test_invoke_traits;

  Obj fn;

  EXPECT_TRUE(noexcept(traits::invoke(fn, 1, 2)));
  EXPECT_FALSE(noexcept(traits::invoke(fn, 1, "2")));

  EXPECT_EQ('a', traits::invoke(fn, 1, 2));
  EXPECT_EQ(17, traits::invoke(fn, 1, "2"));
}

TEST_F	(	InvokeTest	,
		member_invoke_result
	)

Definition at line 231 of file InvokeTest.cpp.

References EXPECT_TRUE, and value.

                                         {
  using traits = test_invoke_traits;

  EXPECT_TRUE(
      (std::is_same<char, traits::invoke_result_t<Obj, int, char>>::value));
  EXPECT_TRUE(
      (std::is_same<int volatile&&, traits::invoke_result_t<Obj, int, char*>>::
           value));
}

TEST_F	(	InvokeTest	,
		member_is_invocable
	)

Definition at line 241 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                        {
  using traits = test_invoke_traits;

  EXPECT_TRUE((traits::is_invocable<Obj, int, char>::value));
  EXPECT_TRUE((traits::is_invocable<Obj, int, char*>::value));
  EXPECT_FALSE((traits::is_invocable<Obj, int>::value));
}

TEST_F	(	InvokeTest	,
		member_is_invocable_r
	)

Definition at line 249 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                          {
  using traits = test_invoke_traits;

  EXPECT_TRUE((traits::is_invocable_r<int, Obj, int, char>::value));
  EXPECT_TRUE((traits::is_invocable_r<int, Obj, int, char*>::value));
  EXPECT_FALSE((traits::is_invocable_r<int, Obj, int>::value));
}

TEST_F	(	InvokeTest	,
		member_is_nothrow_invocable
	)

Definition at line 257 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                                {
  using traits = test_invoke_traits;

  EXPECT_TRUE((traits::is_nothrow_invocable<Obj, int, char>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable<Obj, int, char*>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable<Obj, int>::value));
}

TEST_F	(	InvokeTest	,
		member_is_nothrow_invocable_r
	)

Definition at line 265 of file InvokeTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                                  {
  using traits = test_invoke_traits;

  EXPECT_TRUE((traits::is_nothrow_invocable_r<int, Obj, int, char>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable_r<int, Obj, int, char*>::value));
  EXPECT_FALSE((traits::is_nothrow_invocable_r<int, Obj, int>::value));
}