File Coverage

t/function.cc

Criterion	Covered	Total	%
statement	255	270	94.4
branch	412	1062	38.7
condition			n/a
subroutine			n/a
pod			n/a
total	667	1332	50.0

#include "test.h"
#include
#include
#include
#include

using panda::function;
using panda::make_function;
using panda::iptr;
using panda::function_details::make_method;
using panda::function_details::tmp_abstract_function;
using test::Tracer;

namespace test {


void void_func(){}
void void_func2(){}
void func_int(int){}
void func_int16(int16_t){}
void func_double(int){}

int foo2() {return 1;}
int plus_one(int a) { return a + 1;}

class Test : public panda::Refcnt {
public:
    int value = 0;

    Test(int value) : value(value) {}
    Test() : value(0) {}

    void foo(int) {}
    void foo2(int) {}
    int bar() {return value + 40;}

    int operator()(int v) {return v;}
    bool operator == (const Test& oth) const { return value == oth.value;}
};
}

using namespace test;

TEST_CASE("simplest function", "[function]") {
    function f = &void_func;
    REQUIRE(true);
}

TEST_CASE("simplest function call", "[function]") {
    function f;
    f = &plus_one;
    REQUIRE(f(1) == 2);
}

TEST_CASE("function by reference call", "[function]") {
    function f;
    f = plus_one;
    REQUIRE(f(1) == 2);
}

TEST_CASE("simplest lambda call", "[function]") {
    int a = 13;
    function f = [&](){return a;};
    REQUIRE(f() == 13);
}

TEST_CASE("simplest method call", "[function]") {
    iptr t = new Test();
    t->value = 14;
    auto m = make_function(&Test::bar, t);
    REQUIRE(m() == 54);
}

TEST_CASE("mixedcall", "[function]") {
    iptr t = new Test();
    t->value = 14;
    auto f = make_function(&Test::bar, t);
    REQUIRE(f() == 54);

    f = &foo2;
    REQUIRE(f() == 1);

    int a = 13;
    f = [&](){return a;};
    REQUIRE(f() == 13);
}

TEST_CASE("function ptr comparations", "[function]") {
    function f1_void = &void_func;
    function f2_void = &void_func;
    function f3_void = &void_func2;

    REQUIRE(f1_void == f2_void);
    REQUIRE(f1_void != f3_void);

    REQUIRE(f1_void == tmp_abstract_function(&void_func));
    REQUIRE(f1_void != tmp_abstract_function(&void_func2));
}

TEST_CASE("function ptr comparations covariant", "[function]") {
    struct Int {
        void operator()(int) {}
        bool operator==(const Int&) const {
            return true;
        }
    };

    function    f1(&func_int);
    function f2(&func_int);
    function f3(&func_double);
    function f4(&func_int);

    CHECK(f1 == f2);
    CHECK(f1 != f3);
    CHECK(f2 != f3);
    CHECK(f2 == f4);

    Int i;
    function    ff1(i);
    function ff2(i);

    CHECK(ff1 == ff2);
}

TEST_CASE("function covariant copy comparations", "[function]") {
    bool called = false;
    auto lambda = [&](int a) {
        called = true;
        return a;
    };

    function f1 = lambda;
    function f2(f1);
    CHECK(f1 == f2);
    CHECK(f2 == f1);
}

TEST_CASE("methods comparations", "[function]") {
    iptr t = new Test();
    auto m1 = make_function(&Test::foo, t);
    auto m2 = make_method(&Test::foo);
    REQUIRE(m1 != *m2);

    m2->bind(t);
    REQUIRE(m1 == function(m2));

    iptr t2 = new Test();
    m2->bind(t2);
    REQUIRE(m1 != *m2);

    auto m3 = make_method(&Test::foo2);
    REQUIRE(m1 != *m3);

}

TEST_CASE("lambdas comparations", "[function]") {
    int a = 10;
    function l1 = [&](){return a;};
    auto l2 = l1;
    function l3 = [&](){return a;};

    REQUIRE(l1 == l2);
    REQUIRE(l1 != l3);
}

TEST_CASE("mixed function comparations", "[function]") {
    int a = 10;
    function l = [&](){return a;};
    function f = &foo2;
    iptr t = new Test();
    auto m = make_function(&Test::bar, t);

    REQUIRE(l != f);
    REQUIRE(m != l);
    REQUIRE(m != f);
}

TEST_CASE("null function comparations", "[function]") {
    int a = 10;
    function n;
    function l = [&](){return a;};
    function f = &foo2;
    iptr t = new Test();
    auto m = make_function(&Test::bar, t);

    REQUIRE_FALSE(l == n);
    REQUIRE_FALSE(f == n);
    REQUIRE_FALSE(m == n);

    REQUIRE_FALSE(n == l);
    REQUIRE_FALSE(n == f);
    REQUIRE_FALSE(n == m);
}

TEST_CASE("functors comparations", "[function]") {
    function f1 = Test(1);
    function f2 = Test(2);
    function f11 = Test(1);

    REQUIRE(f1 != f2);
    REQUIRE(f1 == f11);

    auto tmp1 = tmp_abstract_function(Test(1)); // inited from rvalue
    REQUIRE(f1 == tmp1);
}

TEST_CASE("function copy ellision", "[function]") {
    Tracer::refresh();
    {
        function f = Tracer(10);
        auto f2 = f;
        f(11);
        f2(12);
    }
    REQUIRE(Tracer::ctor_calls == 1); // 1 for temporary object Tracer(10);
    REQUIRE(Tracer::copy_calls == 0);
    REQUIRE(Tracer::move_calls == 1); // 1 construction from tmp object function f = Tracer(10);
    REQUIRE(Tracer::dtor_calls == 2);
}

TEST_CASE("covariant return type optional" , "[function]") {
    function (int)> cb = [](int a) -> int {
        return a;
    };
    REQUIRE(cb(3).value_or(42) == 3);
}

TEST_CASE("covariant return type double" , "[function]") {
    function cb = [](int a) -> int {
        return a;
    };
    REQUIRE(cb(3) == 3.0);
}

TEST_CASE("contravariance of arguments" , "[function]") {
    function cb = [](double) -> int {
        return 10;
    };
    REQUIRE(cb(3) == 10);
}
struct Base {
    virtual ~Base(){}
    virtual panda::string name() { return "base";}
};
struct Derrived : Base {
    virtual panda::string name() override { return "override";}
};

TEST_CASE("contravariance of arguments classes" , "[function]") {
    using panda::string;
    function cb = [](Base& b) -> Base& {
        return b;
    };
    Derrived b;
    REQUIRE(cb(b).name() == b.name());
}

function lamda() {
    Tracer t(1);
    auto wrapper = [t](int a) -> int {
        Tracer o = t;
        return a + 1;
    };
    return wrapper;
}


TEST_CASE("function memory", "[function]") {

    Tracer::refresh();
    {
        auto wrapper = lamda();
        REQUIRE(wrapper(10) == 11);
    }

    REQUIRE(Tracer::ctor_total() == Tracer::dtor_calls);
}


TEST_CASE("lambda self reference", "[function]") {
    int a = 1;
    int b;
    function outer;
    {
        auto inner = [=, &b](panda::Ifunction& self) mutable {
            if (a == 1) {
                a++;
                self();;
            } else {
                b = 43;
            }
        };
        outer = inner;
    }
    outer();
    REQUIRE(b == 43);
}

TEST_CASE("no capture self reference", "[function]") {
    static int a = 0;
    function outer;
    {
        auto inner = [](panda::Ifunction& self, int val) {
            while(false) {self(a);}
            a = val;
        };
        outer = inner;
    }
    outer(1);
    REQUIRE(a == 1);
}

TEST_CASE("function from null", "[function]") {
    void (*fptr)();
    fptr = nullptr;
    function f = fptr;
    REQUIRE(!f);
}

TEST_CASE("function from null method", "[function]") {
    auto meth = &Test::bar;
    meth = nullptr;
    auto m = make_function(meth);
    REQUIRE(!m);
}

TEST_CASE("function from nullable object", "[function]") {
    struct S {
        void operator()() const {}
        explicit operator bool() const {
            return val;
        }
        bool val;
    };

    S s{false};
    function f = s;
    REQUIRE(!f);
    s.val = true;
    f = s;
    REQUIRE(f);
}

TEST_CASE("lambda self reference gcc bug", "[function]") {
    struct SomeStruct {
        void method(int val) {
            function ff = [this](panda::Ifunction&, auto... args) mutable {
                this->bar(args...);
            };
            ff(val);
        }

        void bar(int val) {
            a = val;
        }
        int a = 10;
    };
    SomeStruct s;
    s.method(20);
    REQUIRE(s.a == 20);
}

TEST_CASE("lambda self reference auto...", "[function]") {
    int a = 10;
    function f = [&](auto...args) -> int {
        static_assert(sizeof...(args) == 1, "auto... resolved as without SELF");
        return (a = 20) + 1;
    };
    int b = f(42);
    REQUIRE(a == 20);
    REQUIRE(b == 21);

    function f2 = [&](auto&&...args) -> int {
        static_assert(sizeof...(args) == 1, "auto... resolved as without SELF");
        return 111;
    };
    CHECK(f2(123) == 111);

    function f3 = [&](auto&&...args) {
        REQUIRE(sizeof...(args) == 1);
        return 111;
    };
    CHECK(f3(123) == 111);
}