source: liblaziness/test/test_lazy.cc @ 25

#include <iostream>
#include "test_base.h"
#include "../primitive.h"
#include "../r.h"
#include "../lazy.h"
#include "../delegate.h"

Int cCount = 0;
Int dCount = 0;

class A
{
        public:
                A(Int i) : i(i) { ++cCount; }
                ~A() { ++dCount; }
                Int i;
};

class B
{
        public:
                B(Int i) : i(i) { }
                virtual ~B() { }
                virtual Int getI() { return i; }
        protected:
                Int i;
};

class C : public B
{
        public:
                C(Int i) : B(i) { }
                virtual ~C() { }
                virtual Int getI() { return i + 1; }
};

void test();

int main()
{
        try
        {
                test();
                std::cout << "Test SUCCEEDED!" << std::endl;
        }
        catch (TestFailed& ex)
        {
                std::cout << "Failed" << std::endl << "Test FAILED: " << ex.what() << std::endl;
        }
        catch (...)
        {
                std::cout << "Failed" << std::endl << "Test FAILED with unknown exception" << std::endl;
        }
}

R<A> mkA()
{
        return Ref::mk<A> (10L);
}

void test()
{
        StringStream ss;
        std::cout << "Basic tests";

        auto la = mkLazy<A>(mkFun(&mkA));

        assertEq(0L, cCount, "Object should not have been created, but it has!");
        R<A> a = la.getR();
        assertEq(1L, cCount, "Object should have been created, but it has not!");
        R<A> b = la.getR();
        assertEq(1L, cCount, "Object should have been created only once, but it has not!");

        auto lb = mkLazy(mkLFun([] { return Ref::mk<A> (20L); }));

        assertEq(1L, cCount, "Object should not have been created, but it has!");
        a = lb.getR();
        assertEq(2L, cCount, "Object should have been created, but it has not!");
        b = lb.getR();
        assertEq(2L, cCount, "Object should have been created only once, but it has not!");

        auto lc = mkLazy<A>([]() { return Ref::mk<A> (30L);     });
        std::cout << "Success" << std::endl << "Polimorphism tests";
        auto ld = mkLazy<C>([]() { return Ref::mk<C, Int>(40L); });

        R<B> c = ld.getR();
        Int deref = c->getI();
        ss.empty() << "c.deref().getI() should return 41L but it returns " << deref;
        assertEq(41L, deref, ss.str());

        std::cout << "Success" << std::endl << "Closure tests";
        auto fun = mkLFun([] (R<Int> i) {
                ++*i;
                return i;
        }, Ref::mk (1L));
        auto le = mkLazy(fun);
        auto lf = mkLazy(fun);
        ss.empty() << "*le should return 2L but it returns " << *le;
        assertEq(2L, *le, ss.str());
        ss.empty() << "*lf should return 3L but it returns " << *lf;
        assertEq(3L, *lf, ss.str());
        std::cout << "Success" << std::endl << "Lazifying tests";

        auto lfun = lazify([] () { return Ref::mk (20L); });
        Lazy<Int> lg = lfun();
        ss.empty() << "*lg should return 20L but it returns " << *lg;
        assertEq(20L, *lg, ss.str());

        auto lfun1 = lazify([] (R<Int> i) { return Ref::mk (*i + 20L); });
        Lazy<Int> lh = lfun1(lg);
        ss.empty() << "*lh should return 40L but it returns " << *lh;
        assertEq(40L, *lh, ss.str());

        std::cout << "Success" << std::endl;
}