// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <lib/fit/function.h>
#include <unittest/unittest.h>

namespace {

using Closure = void();
using ClosureWrongReturnType = int();
using BinaryOp = int(int a, int b);
using BinaryOpWrongReturnType = void(int a, int b);
using MoveOp = std::unique_ptr<int>(std::unique_ptr<int> value);
using BooleanGenerator = bool();
using IntGenerator = int();

class BuildableFromInt {
public:
    BuildableFromInt(int);
    BuildableFromInt& operator=(int);
};

using BuildableFromIntGenerator = BuildableFromInt();

// A big object which causes a function target to be heap allocated.
struct Big {
    int data[64]{};
};
constexpr size_t HugeCallableSize = sizeof(Big) + sizeof(void*) * 4;

// An object that looks like an "empty" std::function.
template <typename>
struct EmptyFunction;
template <typename R, typename... Args>
struct EmptyFunction<R(Args...)> {
    R operator()(Args... args) const { return fptr(args...); }
    bool operator==(decltype(nullptr)) const { return true; }

    R(*fptr)
    (Args...) = nullptr;
};

// An object whose state we can examine from the outside.
struct SlotMachine {
    void operator()() { value++; }
    int operator()(int a, int b) {
        value += a * b;
        return value;
    }

    int value = 0;
};

// A move-only object which increments a counter when uniquely destroyed.
class DestructionObserver {
public:
    DestructionObserver(int* counter)
        : counter_(counter) {}
    DestructionObserver(DestructionObserver&& other)
        : counter_(other.counter_) {
        other.counter_ = nullptr;
    }
    DestructionObserver(const DestructionObserver& other) = delete;

    ~DestructionObserver() {
        if (counter_)
            *counter_ += 1;
    }

    DestructionObserver& operator=(const DestructionObserver& other) = delete;
    DestructionObserver& operator=(DestructionObserver&& other) {
        if (counter_)
            *counter_ += 1;
        counter_ = other.counter_;
        other.counter_ = nullptr;
        return *this;
    }

private:
    int* counter_;
};

template <typename ClosureFunction>
bool closure() {
    static_assert(fit::is_nullable<ClosureFunction>::value, "");

    BEGIN_TEST;

    // default initialization
    ClosureFunction fdefault;
    EXPECT_FALSE(!!fdefault);

    // nullptr initialization
    ClosureFunction fnull(nullptr);
    EXPECT_FALSE(!!fnull);

    // null function pointer initialization
    Closure* fptr = nullptr;
    ClosureFunction ffunc(fptr);
    EXPECT_FALSE(!!ffunc);

    // "empty std::function" initialization
    EmptyFunction<Closure> empty;
    ClosureFunction fwrapper(empty);
    EXPECT_FALSE(!!fwrapper);

    // inline callable initialization
    int finline_value = 0;
    ClosureFunction finline([&finline_value] { finline_value++; });
    EXPECT_TRUE(!!finline);
    finline();
    EXPECT_EQ(1, finline_value);
    finline();
    EXPECT_EQ(2, finline_value);

    // heap callable initialization
    int fheap_value = 0;
    ClosureFunction fheap([&fheap_value, big = Big()] { fheap_value++; });
    EXPECT_TRUE(!!fheap);
    fheap();
    EXPECT_EQ(1, fheap_value);
    fheap();
    EXPECT_EQ(2, fheap_value);

    // move initialization of a nullptr
    ClosureFunction fnull2(std::move(fnull));
    EXPECT_FALSE(!!fnull2);

    // move initialization of an inline callable
    ClosureFunction finline2(std::move(finline));
    EXPECT_TRUE(!!finline2);
    EXPECT_FALSE(!!finline);
    finline2();
    EXPECT_EQ(3, finline_value);
    finline2();
    EXPECT_EQ(4, finline_value);

    // move initialization of a heap callable
    ClosureFunction fheap2(std::move(fheap));
    EXPECT_TRUE(!!fheap2);
    EXPECT_FALSE(!!fheap);
    fheap2();
    EXPECT_EQ(3, fheap_value);
    fheap2();
    EXPECT_EQ(4, fheap_value);

    // inline mutable lambda
    int fmutinline_value = 0;
    ClosureFunction fmutinline([&fmutinline_value, x = 1]() mutable {
        x *= 2;
        fmutinline_value = x;
    });
    EXPECT_TRUE(!!fmutinline);
    fmutinline();
    EXPECT_EQ(2, fmutinline_value);
    fmutinline();
    EXPECT_EQ(4, fmutinline_value);

    // heap-allocated mutable lambda
    int fmutheap_value = 0;
    ClosureFunction fmutheap([&fmutheap_value, big = Big(), x = 1]() mutable {
        x *= 2;
        fmutheap_value = x;
    });
    EXPECT_TRUE(!!fmutheap);
    fmutheap();
    EXPECT_EQ(2, fmutheap_value);
    fmutheap();
    EXPECT_EQ(4, fmutheap_value);

    // move assignment of non-null
    ClosureFunction fnew([] {});
    fnew = std::move(finline2);
    EXPECT_TRUE(!!fnew);
    fnew();
    EXPECT_EQ(5, finline_value);
    fnew();
    EXPECT_EQ(6, finline_value);

    // move assignment of self
    fnew = std::move(fnew);
    EXPECT_TRUE(!!fnew);
    fnew();
    EXPECT_EQ(7, finline_value);

    // move assignment of null
    fnew = std::move(fnull);
    EXPECT_FALSE(!!fnew);

    // callable assignment with operator=
    int fnew_value = 0;
    fnew = [&fnew_value] { fnew_value++; };
    EXPECT_TRUE(!!fnew);
    fnew();
    EXPECT_EQ(1, fnew_value);
    fnew();
    EXPECT_EQ(2, fnew_value);

    // nullptr assignment
    fnew = nullptr;
    EXPECT_FALSE(!!fnew);

    // swap (currently null)
    swap(fnew, fheap2);
    EXPECT_TRUE(!!fnew);
    EXPECT_FALSE(!!fheap);
    fnew();
    EXPECT_EQ(5, fheap_value);
    fnew();
    EXPECT_EQ(6, fheap_value);

    // swap with self
    swap(fnew, fnew);
    EXPECT_TRUE(!!fnew);
    fnew();
    EXPECT_EQ(7, fheap_value);
    fnew();
    EXPECT_EQ(8, fheap_value);

    // swap with non-null
    swap(fnew, fmutinline);
    EXPECT_TRUE(!!fmutinline);
    EXPECT_TRUE(!!fnew);
    fmutinline();
    EXPECT_EQ(9, fheap_value);
    fmutinline();
    EXPECT_EQ(10, fheap_value);
    fnew();
    EXPECT_EQ(8, fmutinline_value);
    fnew();
    EXPECT_EQ(16, fmutinline_value);

    // nullptr comparison operators
    EXPECT_TRUE(fnull == nullptr);
    EXPECT_FALSE(fnull != nullptr);
    EXPECT_TRUE(nullptr == fnull);
    EXPECT_FALSE(nullptr != fnull);
    EXPECT_FALSE(fnew == nullptr);
    EXPECT_TRUE(fnew != nullptr);
    EXPECT_FALSE(nullptr == fnew);
    EXPECT_TRUE(nullptr != fnew);

    // null function pointer assignment
    fnew = fptr;
    EXPECT_FALSE(!!fnew);

    // "empty std::function" assignment
    fmutinline = empty;
    EXPECT_FALSE(!!fmutinline);

    // target access
    ClosureFunction fslot;
    EXPECT_NULL(fslot.template target<decltype(nullptr)>());
    fslot = SlotMachine{42};
    fslot();
    SlotMachine* fslottarget = fslot.template target<SlotMachine>();
    EXPECT_EQ(43, fslottarget->value);
    const SlotMachine* fslottargetconst =
        const_cast<const ClosureFunction&>(fslot).template target<SlotMachine>();
    EXPECT_EQ(fslottarget, fslottargetconst);
    fslot = nullptr;
    EXPECT_NULL(fslot.template target<decltype(nullptr)>());

    END_TEST;
}

template <typename BinaryOpFunction>
bool binary_op() {
    static_assert(fit::is_nullable<BinaryOpFunction>::value, "");

    BEGIN_TEST;

    // default initialization
    BinaryOpFunction fdefault;
    EXPECT_FALSE(!!fdefault);

    // nullptr initialization
    BinaryOpFunction fnull(nullptr);
    EXPECT_FALSE(!!fnull);

    // null function pointer initialization
    BinaryOp* fptr = nullptr;
    BinaryOpFunction ffunc(fptr);
    EXPECT_FALSE(!!ffunc);

    // "empty std::function" initialization
    EmptyFunction<BinaryOp> empty;
    BinaryOpFunction fwrapper(empty);
    EXPECT_FALSE(!!fwrapper);

    // inline callable initialization
    int finline_value = 0;
    BinaryOpFunction finline([&finline_value](int a, int b) {
        finline_value++;
        return a + b;
    });
    EXPECT_TRUE(!!finline);
    EXPECT_EQ(10, finline(3, 7));
    EXPECT_EQ(1, finline_value);
    EXPECT_EQ(10, finline(3, 7));
    EXPECT_EQ(2, finline_value);

    // heap callable initialization
    int fheap_value = 0;
    BinaryOpFunction fheap([&fheap_value, big = Big()](int a, int b) {
        fheap_value++;
        return a + b;
    });
    EXPECT_TRUE(!!fheap);
    EXPECT_EQ(10, fheap(3, 7));
    EXPECT_EQ(1, fheap_value);
    EXPECT_EQ(10, fheap(3, 7));
    EXPECT_EQ(2, fheap_value);

    // move initialization of a nullptr
    BinaryOpFunction fnull2(std::move(fnull));
    EXPECT_FALSE(!!fnull2);

    // move initialization of an inline callable
    BinaryOpFunction finline2(std::move(finline));
    EXPECT_TRUE(!!finline2);
    EXPECT_FALSE(!!finline);
    EXPECT_EQ(10, finline2(3, 7));
    EXPECT_EQ(3, finline_value);
    EXPECT_EQ(10, finline2(3, 7));
    EXPECT_EQ(4, finline_value);

    // move initialization of a heap callable
    BinaryOpFunction fheap2(std::move(fheap));
    EXPECT_TRUE(!!fheap2);
    EXPECT_FALSE(!!fheap);
    EXPECT_EQ(10, fheap2(3, 7));
    EXPECT_EQ(3, fheap_value);
    EXPECT_EQ(10, fheap2(3, 7));
    EXPECT_EQ(4, fheap_value);

    // inline mutable lambda
    int fmutinline_value = 0;
    BinaryOpFunction fmutinline([&fmutinline_value, x = 1](int a, int b) mutable {
        x *= 2;
        fmutinline_value = x;
        return a + b;
    });
    EXPECT_TRUE(!!fmutinline);
    EXPECT_EQ(10, fmutinline(3, 7));
    EXPECT_EQ(2, fmutinline_value);
    EXPECT_EQ(10, fmutinline(3, 7));
    EXPECT_EQ(4, fmutinline_value);

    // heap-allocated mutable lambda
    int fmutheap_value = 0;
    BinaryOpFunction fmutheap([&fmutheap_value, big = Big(), x = 1](int a, int b) mutable {
        x *= 2;
        fmutheap_value = x;
        return a + b;
    });
    EXPECT_TRUE(!!fmutheap);
    EXPECT_EQ(10, fmutheap(3, 7));
    EXPECT_EQ(2, fmutheap_value);
    EXPECT_EQ(10, fmutheap(3, 7));
    EXPECT_EQ(4, fmutheap_value);

    // move assignment of non-null
    BinaryOpFunction fnew([](int a, int b) { return 0; });
    fnew = std::move(finline2);
    EXPECT_TRUE(!!fnew);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(5, finline_value);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(6, finline_value);

    // self-assignment of non-null
    fnew = std::move(fnew);
    EXPECT_TRUE(!!fnew);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(7, finline_value);

    // move assignment of null
    fnew = std::move(fnull);
    EXPECT_FALSE(!!fnew);

    // self-assignment of non-null
    fnew = std::move(fnew);
    EXPECT_FALSE(!!fnew);

    // callable assignment with operator=
    int fnew_value = 0;
    fnew = [&fnew_value](int a, int b) {
        fnew_value++;
        return a + b;
    };
    EXPECT_TRUE(!!fnew);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(1, fnew_value);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(2, fnew_value);

    // nullptr assignment
    fnew = nullptr;
    EXPECT_FALSE(!!fnew);

    // swap (currently null)
    swap(fnew, fheap2);
    EXPECT_TRUE(!!fnew);
    EXPECT_FALSE(!!fheap);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(5, fheap_value);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(6, fheap_value);

    // swap with self
    swap(fnew, fnew);
    EXPECT_TRUE(!!fnew);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(7, fheap_value);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(8, fheap_value);

    // swap with non-null
    swap(fnew, fmutinline);
    EXPECT_TRUE(!!fmutinline);
    EXPECT_TRUE(!!fnew);
    EXPECT_EQ(10, fmutinline(3, 7));
    EXPECT_EQ(9, fheap_value);
    EXPECT_EQ(10, fmutinline(3, 7));
    EXPECT_EQ(10, fheap_value);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(8, fmutinline_value);
    EXPECT_EQ(10, fnew(3, 7));
    EXPECT_EQ(16, fmutinline_value);

    // nullptr comparison operators
    EXPECT_TRUE(fnull == nullptr);
    EXPECT_FALSE(fnull != nullptr);
    EXPECT_TRUE(nullptr == fnull);
    EXPECT_FALSE(nullptr != fnull);
    EXPECT_FALSE(fnew == nullptr);
    EXPECT_TRUE(fnew != nullptr);
    EXPECT_FALSE(nullptr == fnew);
    EXPECT_TRUE(nullptr != fnew);

    // null function pointer assignment
    fnew = fptr;
    EXPECT_FALSE(!!fnew);

    // "empty std::function" assignment
    fmutinline = empty;
    EXPECT_FALSE(!!fmutinline);

    // target access
    BinaryOpFunction fslot;
    EXPECT_NULL(fslot.template target<decltype(nullptr)>());
    fslot = SlotMachine{42};
    EXPECT_EQ(54, fslot(3, 4));
    SlotMachine* fslottarget = fslot.template target<SlotMachine>();
    EXPECT_EQ(54, fslottarget->value);
    const SlotMachine* fslottargetconst =
        const_cast<const BinaryOpFunction&>(fslot).template target<SlotMachine>();
    EXPECT_EQ(fslottarget, fslottargetconst);
    fslot = nullptr;
    EXPECT_NULL(fslot.template target<decltype(nullptr)>());

    END_TEST;
}

bool sized_function_size_bounds() {
    BEGIN_TEST;

    auto empty = [] {};
    fit::function<Closure, sizeof(empty)> fempty(std::move(empty));
    static_assert(sizeof(fempty) >= sizeof(empty), "size bounds");

    auto small = [x = 1, y = 2] {
        (void)x; // suppress unused lambda capture warning
        (void)y;
    };
    fit::function<Closure, sizeof(small)> fsmall(std::move(small));
    static_assert(sizeof(fsmall) >= sizeof(small), "size bounds");
    fsmall = [] {};

    auto big = [big = Big(), x = 1] { (void)x; };
    fit::function<Closure, sizeof(big)> fbig(std::move(big));
    static_assert(sizeof(fbig) >= sizeof(big), "size bounds");
    fbig = [x = 1, y = 2] {
        (void)x;
        (void)y;
    };
    fbig = [] {};

    // These statements do compile though the lambda will be copied to the heap
    // when they exceed the inline size.
    fempty = [x = 1, y = 2] {
        (void)x;
        (void)y;
    };
    fsmall = [big = Big(), x = 1] { (void)x; };
    fbig = [big = Big(), x = 1, y = 2] {
        (void)x;
        (void)y;
    };

    END_TEST;
}

bool inline_function_size_bounds() {
    BEGIN_TEST;

    auto empty = [] {};
    fit::inline_function<Closure, sizeof(empty)> fempty(std::move(empty));
    static_assert(sizeof(fempty) >= sizeof(empty), "size bounds");

    auto small = [x = 1, y = 2] {
        (void)x; // suppress unused lambda capture warning
        (void)y;
    };
    fit::inline_function<Closure, sizeof(small)> fsmall(std::move(small));
    static_assert(sizeof(fsmall) >= sizeof(small), "size bounds");
    fsmall = [] {};

    auto big = [big = Big(), x = 1] { (void)x; };
    fit::inline_function<Closure, sizeof(big)> fbig(std::move(big));
    static_assert(sizeof(fbig) >= sizeof(big), "size bounds");
    fbig = [x = 1, y = 2] {
        (void)x;
        (void)y;
    };
    fbig = [] {};

// These statements do not compile because the lambdas are too big to fit.
#if 0
    fempty = [ x = 1, y = 2 ] {
        (void)x;
        (void)y;
    };
    fsmall = [ big = Big(), x = 1 ] { (void)x; };
    fbig = [ big = Big(), x = 1, y = 2 ] {
        (void)x;
        (void)y;
    };
#endif

    END_TEST;
}

bool move_only_argument_and_result() {
    BEGIN_TEST;

    std::unique_ptr<int> arg(new int());
    fit::function<MoveOp> f([](std::unique_ptr<int> value) {
        *value += 1;
        return value;
    });
    arg = f(std::move(arg));
    EXPECT_EQ(1, *arg);
    arg = f(std::move(arg));
    EXPECT_EQ(2, *arg);

    END_TEST;
}

void implicit_construction_helper(fit::closure closure) {}

bool implicit_construction() {
    BEGIN_TEST;

    // ensure we can implicitly construct from nullptr
    implicit_construction_helper(nullptr);

    // ensure we can implicitly construct from a lambda
    implicit_construction_helper([] {});

    END_TEST;
}

int arg_count(fit::closure) {
    return 0;
}
int arg_count(fit::function<void(int)>) {
    return 1;
}

bool overload_resolution() {
    BEGIN_TEST;
    EXPECT_EQ(0, arg_count([] {}));
    EXPECT_EQ(1, arg_count([](int) {}));
    END_TEST;
}

// We don't have std::shared in Zircon yet.
#ifndef FIT_NO_STD_FOR_ZIRCON_USERSPACE
bool sharing() {
    BEGIN_TEST;

    fit::function<Closure> fnull;
    fit::function<Closure> fnullshare1 = fnull.share();
    fit::function<Closure> fnullshare2 = fnull.share();
    fit::function<Closure> fnullshare3 = fnullshare1.share();
    EXPECT_FALSE(!!fnull);
    EXPECT_FALSE(!!fnullshare1);
    EXPECT_FALSE(!!fnullshare2);
    EXPECT_FALSE(!!fnullshare3);

    int finlinevalue = 1;
    int finlinedestroy = 0;
    fit::function<Closure> finline =
        [&finlinevalue, d = DestructionObserver(&finlinedestroy)] { finlinevalue++; };
    fit::function<Closure> finlineshare1 = finline.share();
    fit::function<Closure> finlineshare2 = finline.share();
    fit::function<Closure> finlineshare3 = finlineshare1.share();
    EXPECT_TRUE(!!finline);
    EXPECT_TRUE(!!finlineshare1);
    EXPECT_TRUE(!!finlineshare2);
    EXPECT_TRUE(!!finlineshare3);
    finline();
    EXPECT_EQ(2, finlinevalue);
    finlineshare1();
    EXPECT_EQ(3, finlinevalue);
    finlineshare2();
    EXPECT_EQ(4, finlinevalue);
    finlineshare3();
    EXPECT_EQ(5, finlinevalue);
    finlineshare2();
    EXPECT_EQ(6, finlinevalue);
    finline();
    EXPECT_EQ(7, finlinevalue);
    EXPECT_EQ(0, finlinedestroy);
    finline = nullptr;
    EXPECT_EQ(0, finlinedestroy);
    finlineshare3 = nullptr;
    EXPECT_EQ(0, finlinedestroy);
    finlineshare2 = nullptr;
    EXPECT_EQ(0, finlinedestroy);
    finlineshare1 = nullptr;
    EXPECT_EQ(1, finlinedestroy);

    int fheapvalue = 1;
    int fheapdestroy = 0;
    fit::function<Closure> fheap =
        [&fheapvalue, big = Big(), d = DestructionObserver(&fheapdestroy)] { fheapvalue++; };
    fit::function<Closure> fheapshare1 = fheap.share();
    fit::function<Closure> fheapshare2 = fheap.share();
    fit::function<Closure> fheapshare3 = fheapshare1.share();
    EXPECT_TRUE(!!fheap);
    EXPECT_TRUE(!!fheapshare1);
    EXPECT_TRUE(!!fheapshare2);
    EXPECT_TRUE(!!fheapshare3);
    fheap();
    EXPECT_EQ(2, fheapvalue);
    fheapshare1();
    EXPECT_EQ(3, fheapvalue);
    fheapshare2();
    EXPECT_EQ(4, fheapvalue);
    fheapshare3();
    EXPECT_EQ(5, fheapvalue);
    fheapshare2();
    EXPECT_EQ(6, fheapvalue);
    fheap();
    EXPECT_EQ(7, fheapvalue);
    EXPECT_EQ(0, fheapdestroy);
    fheap = nullptr;
    EXPECT_EQ(0, fheapdestroy);
    fheapshare3 = nullptr;
    EXPECT_EQ(0, fheapdestroy);
    fheapshare2 = nullptr;
    EXPECT_EQ(0, fheapdestroy);
    fheapshare1 = nullptr;
    EXPECT_EQ(1, fheapdestroy);

// These statements do not compile because inline functions cannot be shared
#if 0
    fit::inline_function<Closure> fbad;
    fbad.share();
#endif

    END_TEST;
}
#endif // FIT_NO_STD_FOR_ZIRCON_USERSPACE

struct Obj {
    void Call() {
        calls++;
    }

    int AddOne(int x) {
        calls++;
        return x + 1;
    }

    int Sum(int a, int b, int c) {
        calls++;
        return a + b + c;
    }

    std::unique_ptr<int> AddAndReturn(std::unique_ptr<int> value) {
        (*value)++;
        return value;
    }

    uint32_t calls = 0;
};

bool bind_member() {
    BEGIN_TEST;

    Obj obj;
    auto move_only_value = std::make_unique<int>(4);

    fit::bind_member(&obj, &Obj::Call)();
    EXPECT_EQ(23, fit::bind_member(&obj, &Obj::AddOne)(22));
    EXPECT_EQ(6, fit::bind_member(&obj, &Obj::Sum)(1, 2, 3));
    move_only_value = fit::bind_member(&obj, &Obj::AddAndReturn)(std::move(move_only_value));
    EXPECT_EQ(5, *move_only_value);
    EXPECT_EQ(3, obj.calls);

    END_TEST;
}
} // namespace

namespace test_conversions {
static_assert(std::is_convertible<Closure, fit::function<Closure>>::value, "");
static_assert(std::is_convertible<BinaryOp, fit::function<BinaryOp>>::value, "");
static_assert(std::is_assignable<fit::function<Closure>, Closure>::value, "");
static_assert(std::is_assignable<fit::function<BinaryOp>, BinaryOp>::value, "");

static_assert(std::is_assignable<fit::function<BooleanGenerator>, IntGenerator>::value, "");
static_assert(std::is_assignable<fit::function<BuildableFromIntGenerator>, IntGenerator>::value, "");
static_assert(!std::is_assignable<fit::function<IntGenerator>, BuildableFromIntGenerator>::value, "");

static_assert(!std::is_convertible<BinaryOp, fit::function<Closure>>::value, "");
static_assert(!std::is_convertible<Closure, fit::function<BinaryOp>>::value, "");
static_assert(!std::is_assignable<fit::function<Closure>, BinaryOp>::value, "");
static_assert(!std::is_assignable<fit::function<BinaryOp>, Closure>::value, "");

static_assert(!std::is_convertible<ClosureWrongReturnType,
                                   fit::function<Closure>>::value,
              "");
static_assert(!std::is_convertible<BinaryOpWrongReturnType,
                                   fit::function<BinaryOp>>::value,
              "");
static_assert(!std::is_assignable<fit::function<Closure>,
                                  ClosureWrongReturnType>::value,
              "");
static_assert(!std::is_assignable<fit::function<BinaryOp>,
                                  BinaryOpWrongReturnType>::value,
              "");

static_assert(!std::is_convertible<void, fit::function<Closure>>::value, "");
static_assert(!std::is_convertible<void, fit::function<BinaryOp>>::value, "");
static_assert(!std::is_assignable<void, fit::function<Closure>>::value, "");
static_assert(!std::is_assignable<void, fit::function<BinaryOp>>::value, "");
} // namespace test_conversions

BEGIN_TEST_CASE(function_tests)
RUN_TEST((closure<fit::function<Closure>>))
RUN_TEST((binary_op<fit::function<BinaryOp>>))
RUN_TEST((closure<fit::function<Closure, 0u>>))
RUN_TEST((binary_op<fit::function<BinaryOp, 0u>>))
RUN_TEST((closure<fit::function<Closure, HugeCallableSize>>))
RUN_TEST((binary_op<fit::function<BinaryOp, HugeCallableSize>>))
RUN_TEST((closure<fit::inline_function<Closure, HugeCallableSize>>))
RUN_TEST((binary_op<fit::inline_function<BinaryOp, HugeCallableSize>>))
RUN_TEST(sized_function_size_bounds);
RUN_TEST(inline_function_size_bounds);
RUN_TEST(move_only_argument_and_result);
RUN_TEST(implicit_construction);
RUN_TEST(overload_resolution);
#ifndef FIT_NO_STD_FOR_ZIRCON_USERSPACE
RUN_TEST(sharing)
#endif
RUN_TEST(bind_member);
END_TEST_CASE(function_tests)