NonCopyableLambdaTest.cpp File Reference

#include <folly/futures/Future.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (NonCopyableLambda, basic)
	TEST (NonCopyableLambda, unique_ptr)
	TEST (NonCopyableLambda, Function)
	TEST (NonCopyableLambda, FunctionConst)

Function Documentation

TEST	(	NonCopyableLambda	,
		basic
	)

Definition at line 22 of file NonCopyableLambdaTest.cpp.

References folly::netops::bind(), EXPECT_EQ, EXPECT_TRUE, folly::Promise< T >::getFuture(), folly::futures::detail::FutureBase< T >::isReady(), folly::gen::move, and folly::Promise< T >::setValue().

                               {
  Promise<int> promise;
  Future<int> future = promise.getFuture();

  Future<Unit>().thenValue(std::bind(
      [](Promise<int>& p2, folly::Unit) mutable { p2.setValue(123); },
      std::move(promise),
      std::placeholders::_1));

  // The previous statement can be simplified in C++14:
  //  Future<Unit>().then([promise = std::move(promise)]() mutable {
  //    promise.setValue(123);
  //  });

  EXPECT_TRUE(future.isReady());
  EXPECT_EQ(std::move(future).get(), 123);
}

TEST	(	NonCopyableLambda	,
		unique_ptr
	)

Definition at line 40 of file NonCopyableLambdaTest.cpp.

References folly::netops::bind(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::Promise< T >::getFuture(), folly::gen::move, and folly::Promise< T >::setValue().

                                    {
  Promise<Unit> promise;
  auto int_ptr = std::make_unique<int>(1);

  EXPECT_EQ(*int_ptr, 1);

  auto future = promise.getFuture().thenValue(std::bind(
      [](std::unique_ptr<int>& p, folly::Unit) mutable {
        ++*p;
        return std::move(p);
      },
      std::move(int_ptr),
      std::placeholders::_1));

  // The previous statement can be simplified in C++14:
  //  auto future =
  //      promise.getFuture().then([int_ptr = std::move(int_ptr)]() mutable {
  //        ++*int_ptr;
  //        return std::move(int_ptr);
  //      });

  EXPECT_FALSE(future.isReady());
  promise.setValue();
  EXPECT_TRUE(future.isReady());
  EXPECT_EQ(*std::move(future).get(), 2);
}

TEST	(	NonCopyableLambda	,
		Function
	)

Definition at line 67 of file NonCopyableLambdaTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, folly::Promise< T >::getFuture(), folly::gen::move, folly::Promise< T >::setValue(), and x.

                                  {
  Promise<int> promise;

  Function<int(int)> callback = [](int x) { return x + 1; };

  auto future = promise.getFuture().then(std::move(callback));
  EXPECT_THROW(callback(0), std::bad_function_call);

  EXPECT_FALSE(future.isReady());
  promise.setValue(100);
  EXPECT_TRUE(future.isReady());
  EXPECT_EQ(std::move(future).get(), 101);
}

TEST	(	NonCopyableLambda	,
		FunctionConst
	)

Definition at line 81 of file NonCopyableLambdaTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, folly::Promise< T >::getFuture(), folly::gen::move, folly::Promise< T >::setValue(), and x.

                                       {
  Promise<int> promise;

  Function<int(int) const> callback = [](int x) { return x + 1; };

  auto future = promise.getFuture().then(std::move(callback));
  EXPECT_THROW(callback(0), std::bad_function_call);

  EXPECT_FALSE(future.isReady());
  promise.setValue(100);
  EXPECT_TRUE(future.isReady());
  EXPECT_EQ(std::move(future).get(), 101);
}