source: code/branches/cpp11_v2/test/core/command/FunctorPtrTest.cc @ 10865

#include <gtest/gtest.h>
#include "core/command/Functor.h"

namespace orxonox
{
    namespace
    {
        class Testclass : public Destroyable
        {
            public:
                void testMember() {}
                static void testStatic() {}
        };

        class Subclass : public Testclass
        {
        };

        // Fixture
        class FunctorPtrTest : public ::testing::Test
        {
            public:
                virtual void SetUp() override
                {
                }

                virtual void TearDown() override
                {
                }
        };

        void f1(int, double)
        {
        }

        void f2(int, double, double)
        {
        }

        int f3(int, double, double)
        {
            return 0;
        }
    }

    TEST_F(FunctorPtrTest, emptyPtr)
    {
        FunctorMemberPtr<Testclass> ptr1;
        FunctorStaticPtr ptr2;
        FunctorPtr ptr3;

        ASSERT_FALSE(static_cast<bool>(ptr1));
        ASSERT_FALSE(static_cast<bool>(ptr2));
        ASSERT_FALSE(static_cast<bool>(ptr3));
    }

    TEST_F(FunctorPtrTest, canAssignToFunctorMemberPtr)
    {
        FunctorMemberPtr<Testclass> ptr = createFunctor(&Testclass::testMember);
        ASSERT_TRUE(static_cast<bool>(ptr));
    }

    TEST_F(FunctorPtrTest, canAssignToFunctorStaticPtr)
    {
        FunctorStaticPtr ptr = createFunctor(&Testclass::testStatic);
        ASSERT_TRUE(static_cast<bool>(ptr));
    }

    TEST_F(FunctorPtrTest, canAssignToFunctorPtr)
    {
        FunctorPtr ptr1 = createFunctor(&Testclass::testMember);
        ASSERT_TRUE(static_cast<bool>(ptr1));
        FunctorPtr ptr2 = createFunctor(&Testclass::testStatic);
        ASSERT_TRUE(static_cast<bool>(ptr2));
    }

    TEST_F(FunctorPtrTest, canCastFromFunctorMemberPtr)
    {
        FunctorMemberPtr<Testclass> ptr1 = createFunctor(&Testclass::testMember);
        FunctorPtr ptr2 = ptr1;
        ASSERT_TRUE(static_cast<bool>(ptr2));
    }

    TEST_F(FunctorPtrTest, canCastFromFunctorStaticPtr)
    {
        FunctorStaticPtr ptr1 = createFunctor(&Testclass::testStatic);
        FunctorPtr ptr2 = ptr1;
        ASSERT_TRUE(static_cast<bool>(ptr2));
    }

    TEST_F(FunctorPtrTest, canCastToFunctorMemberOfSubclass)
    {
        FunctorPtr ptr1 = createFunctor(&Subclass::testMember);
        FunctorMemberPtr<Subclass> ptr2 = std::static_pointer_cast<FunctorMember<Subclass>>(ptr1);
        ASSERT_TRUE(static_cast<bool>(ptr2));
    }

    TEST_F(FunctorPtrTest, canCompareHeaderIdentifiers)
    {
        FunctorPtr fp1 = createFunctor(&f1);
        FunctorPtr fp2 = createFunctor(&f2);
        FunctorPtr fp3 = createFunctor(&f3);
        ASSERT_TRUE(fp1->getHeaderIdentifier(1) == fp2->getHeaderIdentifier(1));
        ASSERT_TRUE(fp1->getHeaderIdentifier(2) == fp2->getHeaderIdentifier(2));
        ASSERT_FALSE(fp1->getHeaderIdentifier(1) == fp2->getHeaderIdentifier(2));
        ASSERT_FALSE(fp1->getHeaderIdentifier(10) == fp2->getHeaderIdentifier(10));
        ASSERT_FALSE(fp2->getHeaderIdentifier(2) == fp3->getHeaderIdentifier(2));
        ASSERT_FALSE(fp1->getHeaderIdentifier() == fp2->getHeaderIdentifier());
        ASSERT_FALSE(fp2->getHeaderIdentifier() == fp3->getHeaderIdentifier());
    }

    TEST_F(FunctorPtrTest, canCompareTypenames)
    {
        FunctorPtr fp1 = createFunctor(&f1);
        FunctorPtr fp2 = createFunctor(&f2);
        FunctorPtr fp3 = createFunctor(&f3);
        ASSERT_TRUE(fp1->getTypenameReturnvalue() == fp2->getTypenameReturnvalue());
        ASSERT_TRUE(fp1->getTypenameParam(0) == fp3->getTypenameParam(0));
        ASSERT_EQ("void", fp1->getTypenameReturnvalue());
        ASSERT_EQ("int", fp3->getTypenameReturnvalue());
        ASSERT_EQ("int", fp2->getTypenameParam(0));
        ASSERT_EQ("double", fp3->getTypenameParam(2));
        ASSERT_EQ("", fp3->getTypenameParam(6));
    }

    TEST_F(FunctorPtrTest, testGetParamCountAndHasReturnValue)
    {
        FunctorPtr fp1 = createFunctor(&f1);
        FunctorPtr fp2 = createFunctor(&f2);
        FunctorPtr fp3 = createFunctor(&f3);
        ASSERT_EQ(3, fp2->getParamCount());
        ASSERT_FALSE(fp1->getParamCount() == fp3->getParamCount());
        ASSERT_FALSE(fp2->hasReturnvalue());
        ASSERT_TRUE(fp3->hasReturnvalue());
    }

    TEST_F(FunctorPtrTest, canEvaluateArgument)
    {
        FunctorPtr fp1 = createFunctor(&f1);
        MultiType mttype = "2";
        fp1->evaluateArgument(0, mttype);
        ASSERT_TRUE(mttype.isType<int>());
        ASSERT_EQ(2, mttype.get<int>());
        fp1->evaluateArgument(1, mttype);
        ASSERT_TRUE(mttype.isType<double>());
        ASSERT_EQ(2.0, mttype.get<double>());
        mttype.reset();
        fp1->evaluateArgument(5, mttype);
        ASSERT_TRUE(mttype.null());
    }
}