source: code/branches/core7/test/core/object/StrongPtrTest.cc @ 10683

#include <gtest/gtest.h>
#include "core/object/StrongPtr.h"

namespace orxonox
{
    namespace
    {
        class DestroyableTest : public Destroyable
        {
            public:
                DestroyableTest(bool& destroyed) : destroyed_(destroyed) { destroyed_ = false; }
                virtual ~DestroyableTest() { destroyed_ = true; }

            private:
                bool& destroyed_;
        };
    }

    TEST(StrongPtrTest, CanReferenceObject)
    {
        bool bla;
        DestroyableTest* test = new DestroyableTest(bla);
        StrongPtr<DestroyableTest> strongPtr = test;
        EXPECT_EQ(test, strongPtr.get());
        test->destroy();
    }

    TEST(StrongPtrTest, IncreasesReferenceCount)
    {
        bool bla;
        DestroyableTest* test = new DestroyableTest(bla);
        EXPECT_EQ(0u, test->getReferenceCount());
        {
            StrongPtr<DestroyableTest> strongPtr = test;
            EXPECT_EQ(1u, test->getReferenceCount());
        }
        EXPECT_EQ(0u, test->getReferenceCount());
        test->destroy();
    }

    TEST(StrongPtrTest, DestroyDeletesInstance)
    {
        bool destroyed = false;
        DestroyableTest* test = new DestroyableTest(destroyed);
        EXPECT_FALSE(destroyed);
        test->destroy();
        EXPECT_TRUE(destroyed);
    }

    TEST(StrongPtrTest, PreventsDestruction)
    {
        bool destroyed = false;
        DestroyableTest* test = new DestroyableTest(destroyed);
        EXPECT_FALSE(destroyed);
        StrongPtr<DestroyableTest> strongPtr = test;
        test->destroy();
        EXPECT_FALSE(destroyed);
    }

    TEST(StrongPtrTest, DestroysIfStrongPtrRemoved)
    {
        bool destroyed = false;
        DestroyableTest* test = new DestroyableTest(destroyed);
        EXPECT_FALSE(destroyed);
        {
            StrongPtr<DestroyableTest> strongPtr = test;
            test->destroy();
            EXPECT_FALSE(destroyed);
        }
        EXPECT_TRUE(destroyed);
    }

    TEST(StrongPtrTest, DestroysIfAllStrongPtrsRemoved)
    {
        bool destroyed = false;
        DestroyableTest* test = new DestroyableTest(destroyed);
        EXPECT_FALSE(destroyed);
        {
            StrongPtr<DestroyableTest> strongPtr1 = test;
            {
                StrongPtr<DestroyableTest> strongPtr2 = test;
                {
                    StrongPtr<DestroyableTest> strongPtr3 = test;
                    test->destroy();
                    EXPECT_FALSE(destroyed);
                }
                EXPECT_FALSE(destroyed);
            }
            EXPECT_FALSE(destroyed);
        }
        EXPECT_TRUE(destroyed);
    }

    void isNull(const StrongPtr<DestroyableTest> strongPtr)
    {
        EXPECT_TRUE(strongPtr == NULL);
        EXPECT_TRUE(strongPtr == 0);
        EXPECT_TRUE(!strongPtr);
        EXPECT_FALSE(strongPtr != NULL);
        EXPECT_FALSE(strongPtr != 0);
        EXPECT_FALSE(strongPtr);
    }

    TEST(StrongPtrTest, IsNull)
    {
        {
            StrongPtr<DestroyableTest> strongPtr;
            isNull(strongPtr);
        }
        {
            StrongPtr<DestroyableTest> strongPtr = NULL;
            isNull(strongPtr);
        }
        {
            StrongPtr<DestroyableTest> strongPtr;
            strongPtr = NULL;
            isNull(strongPtr);
        }
        {
            StrongPtr<DestroyableTest> strongPtr = 0;
            isNull(strongPtr);
        }
        {
            StrongPtr<DestroyableTest> strongPtr;
            strongPtr = 0;
            isNull(strongPtr);
        }
    }

    TEST(StrongPtrTest, IsNotNull)
    {
        bool destroyed = false;
        DestroyableTest* test = new DestroyableTest(destroyed);
        StrongPtr<DestroyableTest> strongPtr = test;
        EXPECT_FALSE(strongPtr == NULL);
        EXPECT_FALSE(strongPtr == 0);
        EXPECT_FALSE(!strongPtr);
        EXPECT_TRUE(strongPtr != NULL);
        EXPECT_TRUE(strongPtr != 0);
        EXPECT_TRUE(strongPtr);
        test->destroy();
    }
}