Skip to content

F
folly
Commit 54b83bda authored by Alexander Shaposhnikov's avatar Alexander Shaposhnikov Committed by Facebook Github Bot 0
Browse files
Options

Fix the order of EXPECT_EQ parameters 

Summary:Change the order of EXPECT_EQ parameters to
EXPECT_EQ(expected, actual). It will make gtest print
the correct error message if a test fails.

Reviewed By: yfeldblum

Differential Revision: D3161878

fb-gh-sync-id: 69e4536c6f396858d189a9d25904ef4df639ad49
fbshipit-source-id: 69e4536c6f396858d189a9d25904ef4df639ad49
parent 652d34b9
Show whitespace changes
Inline Side-by-side
Showing with 131 additions and 131 deletions
folly/test/FunctionTest.cpp
View file @ 54b83bda
......@@ -91,7 +91,7 @@ TEST(Function, NoExceptMovable) {
// callable_noexcept can be stored in the Function object
Function<int(int), FunctionMoveCtor::NO_THROW> func(callable_noexcept);
EXPECT_EQ(func(42), 43);
EXPECT_EQ(43, func(42));
EXPECT_FALSE(func.hasAllocatedMemory());
EXPECT_TRUE(std::is_nothrow_move_constructible<decltype(func)>::value);
......@@ -99,7 +99,7 @@ TEST(Function, NoExceptMovable) {
// because Function guarantees noexcept-movability, but
// callable_throw may throw when moved
Function<int(int), FunctionMoveCtor::NO_THROW> func_safe_move(callable_throw);
EXPECT_EQ(func_safe_move(42), 52);
EXPECT_EQ(52, func_safe_move(42));
EXPECT_TRUE(func_safe_move.hasAllocatedMemory());
EXPECT_TRUE(
std::is_nothrow_move_constructible<decltype(func_safe_move)>::value);
......@@ -108,7 +108,7 @@ TEST(Function, NoExceptMovable) {
// the NoExceptMovable template parameter is set to NO
Function<int(int), FunctionMoveCtor::MAY_THROW> func_movethrows(
callable_throw);
EXPECT_EQ(func_movethrows(42), 52);
EXPECT_EQ(52, func_movethrows(42));
EXPECT_FALSE(func_movethrows.hasAllocatedMemory());
EXPECT_FALSE(
std::is_nothrow_move_constructible<decltype(func_movethrows)>::value);
......@@ -137,7 +137,7 @@ void invoke_functor_test() {
// sizeof(func).
EXPECT_EQ(getter.hasAllocatedMemory(), S < 2);
EXPECT_EQ(getter(5), 123);
EXPECT_EQ(123, getter(5));
}
TEST(Function, InvokeFunctor_T0) {
invoke_functor_test<FunctionMoveCtor::MAY_THROW, 0>();
......@@ -174,10 +174,10 @@ void invoke_reference_test() {
Function<int(size_t) const, NEM, 0> getter = std::ref(func);
Function<int(size_t, int), NEM, 0> setter = std::ref(func);
EXPECT_EQ(getter(5), 123);
EXPECT_EQ(setter(5, 456), 123);
EXPECT_EQ(setter(5, 567), 456);
EXPECT_EQ(getter(5), 567);
EXPECT_EQ(123, getter(5));
EXPECT_EQ(123, setter(5, 456));
EXPECT_EQ(456, setter(5, 567));
EXPECT_EQ(567, getter(5));
}
TEST(Function, InvokeReference_T) {
invoke_reference_test<FunctionMoveCtor::MAY_THROW>();
......@@ -201,13 +201,13 @@ void emptiness_test() {
EXPECT_NE(g, nullptr);
EXPECT_NE(nullptr, g);
EXPECT_TRUE(g);
EXPECT_EQ(g(99), 100);
EXPECT_EQ(100, g(99));
Function<int(int), NEM> h(&func_int_int_add_25);
EXPECT_NE(h, nullptr);
EXPECT_NE(nullptr, h);
EXPECT_TRUE(h);
EXPECT_EQ(h(100), 125);
EXPECT_EQ(125, h(100));
h = {};
EXPECT_EQ(h, nullptr);
......@@ -271,8 +271,8 @@ void swap_test() {
Function<int(int), NEM1> mf1(func_int_int_add_25);
Function<int(int), NEM2> mf2(func_int_int_add_111);
EXPECT_EQ(mf1(100), 125);
EXPECT_EQ(mf2(100), 211);
EXPECT_EQ(125, mf1(100));
EXPECT_EQ(211, mf2(100));
if (UseSwapMethod) {
mf1.swap(mf2);
......@@ -280,8 +280,8 @@ void swap_test() {
swap(mf1, mf2);
}
EXPECT_EQ(mf2(100), 125);
EXPECT_EQ(mf1(100), 211);
EXPECT_EQ(125, mf2(100));
EXPECT_EQ(211, mf1(100));
Function<int(int)> mf3(nullptr);
EXPECT_EQ(mf3, nullptr);
......@@ -292,27 +292,27 @@ void swap_test() {
swap(mf1, mf3);
}
EXPECT_EQ(mf3(100), 211);
EXPECT_EQ(mf1, nullptr);
EXPECT_EQ(211, mf3(100));
EXPECT_EQ(nullptr, mf1);
Function<int(int)> mf4([](int x) { return x + 222; });
EXPECT_EQ(mf4(100), 322);
EXPECT_EQ(322, mf4(100));
if (UseSwapMethod) {
mf4.swap(mf3);
} else {
swap(mf4, mf3);
}
EXPECT_EQ(mf4(100), 211);
EXPECT_EQ(mf3(100), 322);
EXPECT_EQ(211, mf4(100));
EXPECT_EQ(322, mf3(100));
if (UseSwapMethod) {
mf3.swap(mf1);
} else {
swap(mf3, mf1);
}
EXPECT_EQ(mf3, nullptr);
EXPECT_EQ(mf1(100), 322);
EXPECT_EQ(nullptr, mf3);
EXPECT_EQ(322, mf1(100));
}
TEST(Function, SwapMethod_TT) {
swap_test<FunctionMoveCtor::MAY_THROW, FunctionMoveCtor::MAY_THROW, true>();
......@@ -347,10 +347,10 @@ void bind_test() {
Function<float(float, float), NEM> fnc = floatMult;
auto task = std::bind(std::move(fnc), 2.f, 4.f);
EXPECT_THROW(fnc(0, 0), std::bad_function_call);
EXPECT_EQ(task(), 8);
EXPECT_EQ(8, task());
auto task2(std::move(task));
EXPECT_THROW(task(), std::bad_function_call);
EXPECT_EQ(task2(), 8);
EXPECT_EQ(8, task2());
}
TEST(Function, Bind_T) {
bind_test<FunctionMoveCtor::MAY_THROW>();
......@@ -365,16 +365,16 @@ TEST(Function, Bind_N) {
template <FunctionMoveCtor NEM, size_t S>
void non_copyable_lambda_test() {
auto unique_ptr_int = folly::make_unique<int>(900);
EXPECT_EQ(*unique_ptr_int, 900);
EXPECT_EQ(900, *unique_ptr_int);
char fooData[64] = {0};
EXPECT_EQ(fooData[0], 0); // suppress gcc warning about fooData not being used
EXPECT_EQ(0, fooData[0]); // suppress gcc warning about fooData not being used
auto functor = std::bind(
[fooData](std::unique_ptr<int>& up) mutable { return ++*up; },
std::move(unique_ptr_int));
EXPECT_EQ(functor(), 901);
EXPECT_EQ(901, functor());
Function<int(void), NEM, sizeof(functor)* S / 2> func = std::move(functor);
EXPECT_EQ(
......@@ -382,7 +382,7 @@ void non_copyable_lambda_test() {
S < 2 || (NEM == FunctionMoveCtor::NO_THROW &&
!std::is_nothrow_move_constructible<decltype(functor)>::value));
EXPECT_EQ(func(), 902);
EXPECT_EQ(902, func());
}
TEST(Function, NonCopyableLambda_T0) {
non_copyable_lambda_test<FunctionMoveCtor::MAY_THROW, 0>();
......@@ -418,15 +418,15 @@ void downsize_test() {
// set element 3
functor(3, 123);
EXPECT_EQ(functor(3), 123);
EXPECT_EQ(123, functor(3));
// Function with large callable storage area (twice the size of
// the functor)
Function<int(size_t, int), NEM, sizeof(functor)* 2> func2x =
std::move(functor);
EXPECT_FALSE(func2x.hasAllocatedMemory());
EXPECT_EQ(func2x(3, 200), 123);
EXPECT_EQ(func2x(3, 201), 200);
EXPECT_EQ(123, func2x(3, 200));
EXPECT_EQ(200, func2x(3, 201));
// Function with sufficient callable storage area (equal to
// size of the functor)
......@@ -434,8 +434,8 @@ void downsize_test() {
EXPECT_THROW(func2x(0, 0), std::bad_function_call);
EXPECT_FALSE(func2x);
EXPECT_FALSE(func1x.hasAllocatedMemory());
EXPECT_EQ(func1x(3, 202), 201);
EXPECT_EQ(func1x(3, 203), 202);
EXPECT_EQ(201, func1x(3, 202));
EXPECT_EQ(202, func1x(3, 203));
// Function with minimal callable storage area (functor does
// not fit and will be moved to memory on the heap)
......@@ -443,8 +443,8 @@ void downsize_test() {
EXPECT_THROW(func1x(0, 0), std::bad_function_call);
EXPECT_FALSE(func1x);
EXPECT_TRUE(func0x.hasAllocatedMemory());
EXPECT_EQ(func0x(3, 204), 203);
EXPECT_EQ(func0x(3, 205), 204);
EXPECT_EQ(203, func0x(3, 204));
EXPECT_EQ(204, func0x(3, 205));
// bonus test: move to Function with opposite NoExceptMovable
// setting
......@@ -457,8 +457,8 @@ void downsize_test() {
EXPECT_THROW(func0x(0, 0), std::bad_function_call);
EXPECT_FALSE(func0x);
EXPECT_TRUE(funcnot.hasAllocatedMemory());
EXPECT_EQ(funcnot(3, 206), 205);
EXPECT_EQ(funcnot(3, 207), 206);
EXPECT_EQ(205, funcnot(3, 206));
EXPECT_EQ(206, funcnot(3, 207));
}
TEST(Function, Downsize_T) {
downsize_test<FunctionMoveCtor::MAY_THROW>();
......@@ -476,47 +476,47 @@ void refcount_test() {
functor(3, 999);
auto shared_int = std::make_shared<int>(100);
EXPECT_EQ(*shared_int, 100);
EXPECT_EQ(shared_int.use_count(), 1);
EXPECT_EQ(100, *shared_int);
EXPECT_EQ(1, shared_int.use_count());
Function<int(void), NEM> func1 = [shared_int]() { return ++*shared_int; };
EXPECT_EQ(shared_int.use_count(), 2);
EXPECT_EQ(func1(), 101);
EXPECT_EQ(*shared_int, 101);
EXPECT_EQ(2, shared_int.use_count());
EXPECT_EQ(101, func1());
EXPECT_EQ(101, *shared_int);
// func2: made to not fit functor.
Function<int(void), NEM, sizeof(functor) / 2> func2 = std::move(func1);
EXPECT_THROW(func1(), std::bad_function_call);
EXPECT_EQ(shared_int.use_count(), 2);
EXPECT_EQ(2, shared_int.use_count());
EXPECT_FALSE(func1);
EXPECT_EQ(func2(), 102);
EXPECT_EQ(*shared_int, 102);
EXPECT_EQ(102, func2());
EXPECT_EQ(102, *shared_int);
func2 = [shared_int]() { return ++*shared_int; };
EXPECT_EQ(shared_int.use_count(), 2);
EXPECT_EQ(func2(), 103);
EXPECT_EQ(*shared_int, 103);
EXPECT_EQ(2, shared_int.use_count());
EXPECT_EQ(103, func2());
EXPECT_EQ(103, *shared_int);
// We set func2 to a lambda that captures 'functor', which forces it on
// the heap
func2 = [functor]() { return functor(3); };
EXPECT_TRUE(func2.hasAllocatedMemory());
EXPECT_EQ(func2(), 999);
EXPECT_EQ(shared_int.use_count(), 1);
EXPECT_EQ(*shared_int, 103);
EXPECT_EQ(999, func2());
EXPECT_EQ(1, shared_int.use_count());
EXPECT_EQ(103, *shared_int);
func2 = [shared_int]() { return ++*shared_int; };
EXPECT_EQ(shared_int.use_count(), 2);
EXPECT_EQ(func2(), 104);
EXPECT_EQ(*shared_int, 104);
EXPECT_EQ(2, shared_int.use_count());
EXPECT_EQ(104, func2());
EXPECT_EQ(104, *shared_int);
// We set func2 to function pointer, which always fits into the
// Function object and is no-except-movable
func2 = &func_int_return_987;
EXPECT_FALSE(func2.hasAllocatedMemory());
EXPECT_EQ(func2(), 987);
EXPECT_EQ(shared_int.use_count(), 1);
EXPECT_EQ(*shared_int, 104);
EXPECT_EQ(987, func2());
EXPECT_EQ(1, shared_int.use_count());
EXPECT_EQ(104, *shared_int);
}
TEST(Function, Refcount_T) {
refcount_test<FunctionMoveCtor::MAY_THROW>();
......@@ -531,13 +531,13 @@ TEST(Function, Refcount_N) {
template <FunctionMoveCtor NEM>
void target_test() {
std::function<int(int)> func = [](int x) { return x + 25; };
EXPECT_EQ(func(100), 125);
EXPECT_EQ(125, func(100));
Function<int(int), NEM> ufunc = std::move(func);
EXPECT_THROW(func(0), std::bad_function_call);
EXPECT_EQ(ufunc(200), 225);
EXPECT_EQ(225, ufunc(200));
EXPECT_EQ(ufunc.target_type(), typeid(std::function<int(int)>));
EXPECT_EQ(typeid(std::function<int(int)>), ufunc.target_type());
EXPECT_FALSE(ufunc.template target<int>());
EXPECT_FALSE(ufunc.template target<std::function<void(void)>>());
......@@ -545,7 +545,7 @@ void target_test() {
std::function<int(int)>& ufunc_target =
*ufunc.template target<std::function<int(int)>>();
EXPECT_EQ(ufunc_target(300), 325);
EXPECT_EQ(325, ufunc_target(300));
}
TEST(Function, Target_T) {
......@@ -593,26 +593,26 @@ TEST(Function, OverloadedFunctor) {
OverloadedFunctor of;
Function<int(int)> variant1 = of;
EXPECT_EQ(variant1(15), 100 + 1 * 15);
EXPECT_EQ(100 + 1 * 15, variant1(15));
Function<int(int) const> variant2 = of;
EXPECT_EQ(variant2(16), 100 + 2 * 16);
EXPECT_EQ(100 + 2 * 16, variant2(16));
Function<int(int, int)> variant3 = of;
EXPECT_EQ(variant3(17, 0), 100 + 3 * 17);
EXPECT_EQ(100 + 3 * 17, variant3(17, 0));
Function<int(int, int) const> variant4 = of;
EXPECT_EQ(variant4(18, 0), 100 + 4 * 18);
EXPECT_EQ(100 + 4 * 18, variant4(18, 0));
Function<int(int, char const*)> variant5 = of;
EXPECT_EQ(variant5(19, "foo"), 100 + 5 * 19);
EXPECT_EQ(100 + 5 * 19, variant5(19, "foo"));
Function<int(int, std::vector<int> const&)> variant6 = of;
EXPECT_EQ(variant6(20, {}), 100 + 6 * 20);
EXPECT_EQ(variant6(20, {1, 2, 3}), 100 + 6 * 20);
EXPECT_EQ(100 + 6 * 20, variant6(20, {}));
EXPECT_EQ(100 + 6 * 20, variant6(20, {1, 2, 3}));
Function<int(int, std::vector<int> const&) const> variant6const = of;
EXPECT_EQ(variant6const(21, {}), 100 + 6 * 21);
EXPECT_EQ(100 + 6 * 21, variant6const(21, {}));
// Cast const-functions to non-const and the other way around: if the functor
// has both const and non-const operator()s for a given parameter signature,
......@@ -626,32 +626,32 @@ TEST(Function, OverloadedFunctor) {
auto variant1_const = folly::constCastFunction(std::move(variant1));
EXPECT_THROW(variant1(0), std::bad_function_call);
EXPECT_EQ(variant1_const(22), 100 + 1 * 22);
EXPECT_EQ(100 + 1 * 22, variant1_const(22));
Function<int(int)> variant2_nonconst = std::move(variant2);
EXPECT_THROW(variant2(0), std::bad_function_call);
EXPECT_EQ(variant2_nonconst(23), 100 + 2 * 23);
EXPECT_EQ(100 + 2 * 23, variant2_nonconst(23));
auto variant3_const = folly::constCastFunction(std::move(variant3));
EXPECT_THROW(variant3(0, 0), std::bad_function_call);
EXPECT_EQ(variant3_const(24, 0), 100 + 3 * 24);
EXPECT_EQ(100 + 3 * 24, variant3_const(24, 0));
Function<int(int, int)> variant4_nonconst = std::move(variant4);
EXPECT_THROW(variant4(0, 0), std::bad_function_call);
EXPECT_EQ(variant4_nonconst(25, 0), 100 + 4 * 25);
EXPECT_EQ(100 + 4 * 25, variant4_nonconst(25, 0));
auto variant5_const = folly::constCastFunction(std::move(variant5));
EXPECT_THROW(variant5(0, ""), std::bad_function_call);
EXPECT_EQ(variant5_const(26, "foo"), 100 + 5 * 26);
EXPECT_EQ(100 + 5 * 26, variant5_const(26, "foo"));
auto variant6_const = folly::constCastFunction(std::move(variant6));
EXPECT_THROW(variant6(0, {}), std::bad_function_call);
EXPECT_EQ(variant6_const(27, {}), 100 + 6 * 27);
EXPECT_EQ(100 + 6 * 27, variant6_const(27, {}));
Function<int(int, std::vector<int> const&)> variant6const_nonconst =
std::move(variant6const);
EXPECT_THROW(variant6const(0, {}), std::bad_function_call);
EXPECT_EQ(variant6const_nonconst(28, {}), 100 + 6 * 28);
EXPECT_EQ(100 + 6 * 28, variant6const_nonconst(28, {}));
}
// TEST =====================================================================
......@@ -660,33 +660,33 @@ TEST(Function, OverloadedFunctor) {
TEST(Function, Lambda) {
// Non-mutable lambdas: can be stored in a non-const...
Function<int(int)> func = [](int x) { return 1000 + x; };
EXPECT_EQ(func(1), 1001);
EXPECT_EQ(1001, func(1));
// ...as well as in a const Function
Function<int(int) const> func_const = [](int x) { return 2000 + x; };
EXPECT_EQ(func_const(1), 2001);
EXPECT_EQ(2001, func_const(1));
// Mutable lambda: can only be stored in a const Function:
int number = 3000;
Function<int()> func_mutable = [number]() mutable { return ++number; };
EXPECT_EQ(func_mutable(), 3001);
EXPECT_EQ(func_mutable(), 3002);
EXPECT_EQ(3001, func_mutable());
EXPECT_EQ(3002, func_mutable());
// test after const-casting
Function<int(int) const> func_made_const =
folly::constCastFunction(std::move(func));
EXPECT_EQ(func_made_const(2), 1002);
EXPECT_EQ(1002, func_made_const(2));
EXPECT_THROW(func(0), std::bad_function_call);
Function<int(int)> func_const_made_nonconst = std::move(func_const);
EXPECT_EQ(func_const_made_nonconst(2), 2002);
EXPECT_EQ(2002, func_const_made_nonconst(2));
EXPECT_THROW(func_const(0), std::bad_function_call);
Function<int() const> func_mutable_made_const =
folly::constCastFunction(std::move(func_mutable));
EXPECT_EQ(func_mutable_made_const(), 3003);
EXPECT_EQ(func_mutable_made_const(), 3004);
EXPECT_EQ(3003, func_mutable_made_const());
EXPECT_EQ(3004, func_mutable_made_const());
EXPECT_THROW(func_mutable(), std::bad_function_call);
}
......@@ -709,13 +709,13 @@ TEST(Function, DataMember) {
mf.x = 123;
Function<int(MemberFunc const*)> data_getter1 = &MemberFunc::x;
EXPECT_EQ(data_getter1(&cmf), 123);
EXPECT_EQ(123, data_getter1(&cmf));
Function<int(MemberFunc*)> data_getter2 = &MemberFunc::x;
EXPECT_EQ(data_getter2(&mf), 123);
EXPECT_EQ(123, data_getter2(&mf));
Function<int(MemberFunc const&)> data_getter3 = &MemberFunc::x;
EXPECT_EQ(data_getter3(cmf), 123);
EXPECT_EQ(123, data_getter3(cmf));
Function<int(MemberFunc&)> data_getter4 = &MemberFunc::x;
EXPECT_EQ(data_getter4(mf), 123);
EXPECT_EQ(123, data_getter4(mf));
}
TEST(Function, MemberFunction) {
......@@ -724,21 +724,21 @@ TEST(Function, MemberFunction) {
mf.x = 123;
Function<int(MemberFunc const*)> getter1 = &MemberFunc::getX;
EXPECT_EQ(getter1(&cmf), 123);
EXPECT_EQ(123, getter1(&cmf));
Function<int(MemberFunc*)> getter2 = &MemberFunc::getX;
EXPECT_EQ(getter2(&mf), 123);
EXPECT_EQ(123, getter2(&mf));
Function<int(MemberFunc const&)> getter3 = &MemberFunc::getX;
EXPECT_EQ(getter3(cmf), 123);
EXPECT_EQ(123, getter3(cmf));
Function<int(MemberFunc&)> getter4 = &MemberFunc::getX;
EXPECT_EQ(getter4(mf), 123);
EXPECT_EQ(123, getter4(mf));
Function<void(MemberFunc*, int)> setter1 = &MemberFunc::setX;
setter1(&mf, 234);
EXPECT_EQ(mf.x, 234);
EXPECT_EQ(234, mf.x);
Function<void(MemberFunc&, int)> setter2 = &MemberFunc::setX;
setter2(mf, 345);
EXPECT_EQ(mf.x, 345);
EXPECT_EQ(345, mf.x);
}
// TEST =====================================================================
......@@ -792,9 +792,9 @@ TEST(Function, CaptureCopyMoveCount) {
// This test checks that no unnecessary copies/moves are made.
CopyMoveTracker cmt(CopyMoveTracker::ConstructorTag{});
EXPECT_EQ(cmt.copyCount(), 0);
EXPECT_EQ(cmt.moveCount(), 0);
EXPECT_EQ(cmt.refCount(), 1);
EXPECT_EQ(0, cmt.copyCount());
EXPECT_EQ(0, cmt.moveCount());
EXPECT_EQ(1, cmt.refCount());
// Move into lambda, move lambda into Function
auto lambda1 = [cmt = std::move(cmt)]() {
......@@ -822,17 +822,17 @@ TEST(Function, CaptureCopyMoveCount) {
cmt.resetCounters();
uf1();
uf2();
EXPECT_EQ(cmt.copyCount(), 0);
EXPECT_EQ(cmt.moveCount(), 0);
EXPECT_EQ(0, cmt.copyCount());
EXPECT_EQ(0, cmt.moveCount());
}
TEST(Function, ParameterCopyMoveCount) {
// This test checks that no unnecessary copies/moves are made.
CopyMoveTracker cmt(CopyMoveTracker::ConstructorTag{});
EXPECT_EQ(cmt.copyCount(), 0);
EXPECT_EQ(cmt.moveCount(), 0);
EXPECT_EQ(cmt.refCount(), 1);
EXPECT_EQ(0, cmt.copyCount());
EXPECT_EQ(0, cmt.moveCount());
EXPECT_EQ(1, cmt.refCount());
// pass by value
Function<size_t(CopyMoveTracker)> uf1 = [](CopyMoveTracker c) {
......@@ -1046,9 +1046,9 @@ TEST(Function, VariadicTemplate) {
Function<int(int, int)> uf2 = VariadicTemplateSum();
Function<int(int, int, int)> uf3 = VariadicTemplateSum();
EXPECT_EQ(uf1(66), 66);
EXPECT_EQ(uf2(55, 44), 99);
EXPECT_EQ(uf3(33, 22, 11), 66);
EXPECT_EQ(66, uf1(66));
EXPECT_EQ(99, uf2(55, 44));
EXPECT_EQ(66, uf3(33, 22, 11));
}
struct VariadicArgumentsSum {
......@@ -1069,9 +1069,9 @@ TEST(Function, VariadicArguments) {
Function<int(int, int)> uf2 = VariadicArgumentsSum();
Function<int(int, int, int)> uf3 = VariadicArgumentsSum();
EXPECT_EQ(uf1(0), 0);
EXPECT_EQ(uf2(1, 66), 66);
EXPECT_EQ(uf3(2, 55, 44), 99);
EXPECT_EQ(0, uf1(0));
EXPECT_EQ(66, uf2(1, 66));
EXPECT_EQ(99, uf3(2, 55, 44));
}
// TEST =====================================================================
......@@ -1107,7 +1107,7 @@ TEST(Function, SafeCaptureByReference) {
// to for_each. Modern compiler versions can compile the following line:
// for_each(vec, [&sum](int x) { sum += x; });
EXPECT_EQ(sum, 999);
EXPECT_EQ(999, sum);
}
// TEST =====================================================================
......@@ -1119,16 +1119,16 @@ TEST(Function, IgnoreReturnValue) {
// Assign a lambda that return int to a folly::Function that returns void.
Function<void()> f = [&]() -> int { return ++x; };
EXPECT_EQ(x, 95);
EXPECT_EQ(95, x);
f();
EXPECT_EQ(x, 96);
EXPECT_EQ(96, x);
Function<int()> g = [&]() -> int { return ++x; };
Function<void()> cg = std::move(g);
EXPECT_EQ(x, 96);
EXPECT_EQ(96, x);
cg();
EXPECT_EQ(x, 97);
EXPECT_EQ(97, x);
}
// TEST =====================================================================
......@@ -1141,38 +1141,38 @@ TEST(Function, ReturnConvertible) {
struct CDerived : CBase {};
Function<double()> f1 = []() -> int { return 5; };
EXPECT_EQ(f1(), 5.0);
EXPECT_EQ(5.0, f1());
Function<int()> f2 = []() -> double { return 5.2; };
EXPECT_EQ(f2(), 5);
EXPECT_EQ(5, f2());
CDerived derived;
derived.x = 55;
Function<CBase const&()> f3 = [&]() -> CDerived const& { return derived; };
EXPECT_EQ(f3().x, 55);
EXPECT_EQ(55, f3().x);
Function<CBase const&()> f4 = [&]() -> CDerived& { return derived; };
EXPECT_EQ(f4().x, 55);
EXPECT_EQ(55, f4().x);
Function<CBase&()> f5 = [&]() -> CDerived& { return derived; };
EXPECT_EQ(f5().x, 55);
EXPECT_EQ(55, f5().x);
Function<CBase const*()> f6 = [&]() -> CDerived const* { return &derived; };
EXPECT_EQ(f6()->x, 55);
Function<CBase const*()> f7 = [&]() -> CDerived* { return &derived; };
EXPECT_EQ(f7()->x, 55);
EXPECT_EQ(55, f7()->x);
Function<CBase*()> f8 = [&]() -> CDerived* { return &derived; };
EXPECT_EQ(f8()->x, 55);
EXPECT_EQ(55, f8()->x);
Function<CBase()> f9 = [&]() -> CDerived {
auto d = derived;
d.x = 66;
return d;
};
EXPECT_EQ(f9().x, 66);
EXPECT_EQ(66, f9().x);
}
TEST(Function, ConvertReturnType) {
......@@ -1183,44 +1183,44 @@ TEST(Function, ConvertReturnType) {
Function<int()> f1 = []() -> int { return 5; };
Function<double()> cf1 = std::move(f1);
EXPECT_EQ(cf1(), 5.0);
EXPECT_EQ(5.0, cf1());
Function<int()> ccf1 = std::move(cf1);
EXPECT_EQ(ccf1(), 5);
EXPECT_EQ(5, ccf1());
Function<double()> f2 = []() -> double { return 5.2; };
Function<int()> cf2 = std::move(f2);
EXPECT_EQ(cf2(), 5);
EXPECT_EQ(5, cf2());
Function<double()> ccf2 = std::move(cf2);
EXPECT_EQ(ccf2(), 5.0);
EXPECT_EQ(5.0, ccf2());
CDerived derived;
derived.x = 55;
Function<CDerived const&()> f3 = [&]() -> CDerived const& { return derived; };
Function<CBase const&()> cf3 = std::move(f3);
EXPECT_EQ(cf3().x, 55);
EXPECT_EQ(55, cf3().x);
Function<CDerived&()> f4 = [&]() -> CDerived& { return derived; };
Function<CBase const&()> cf4 = std::move(f4);
EXPECT_EQ(cf4().x, 55);
EXPECT_EQ(55, cf4().x);
Function<CDerived&()> f5 = [&]() -> CDerived& { return derived; };
Function<CBase&()> cf5 = std::move(f5);
EXPECT_EQ(cf5().x, 55);
EXPECT_EQ(55, cf5().x);
Function<CDerived const*()> f6 = [&]() -> CDerived const* {
return &derived;
};
Function<CBase const*()> cf6 = std::move(f6);
EXPECT_EQ(cf6()->x, 55);
EXPECT_EQ(55, cf6()->x);
Function<CDerived const*()> f7 = [&]() -> CDerived* { return &derived; };
Function<CBase const*()> cf7 = std::move(f7);
EXPECT_EQ(cf7()->x, 55);
EXPECT_EQ(55, cf7()->x);
Function<CDerived*()> f8 = [&]() -> CDerived* { return &derived; };
Function<CBase*()> cf8 = std::move(f8);
EXPECT_EQ(cf8()->x, 55);
EXPECT_EQ(55, cf8()->x);
Function<CDerived()> f9 = [&]() -> CDerived {
auto d = derived;
......@@ -1228,7 +1228,7 @@ TEST(Function, ConvertReturnType) {
return d;
};
Function<CBase()> cf9 = std::move(f9);
EXPECT_EQ(cf9().x, 66);
EXPECT_EQ(66, cf9().x);
}
TEST(Function, asStdFunction_void) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment