/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#define QT_SHAREDPOINTER_TRACK_POINTERS

#include "qsharedpointer.h"

#include <QtTest/QtTest>

#include <QtCore/QHash>

#include <QtCore/QMap>

#include <QtCore/QThread>

#include <QtCore/QVector>

#include "externaltests.h"

#include "wrapper.h"

#include <stdlib.h>

#include <time.h>

QT_BEGIN_NAMESPACE

namespace QtSharedPointer {

    Q_CORE_EXPORT void internalSafetyCheckCleanCheck();

}

QT_END_NAMESPACE

#ifdef Q_OS_SYMBIAN

#define SRCDIR "."

#endif

class tst_QSharedPointer: public QObject

{

    Q_OBJECT

private slots:

    void basics_data();

    void basics();

    void operators();

    void swap();

    void forwardDeclaration1();

    void forwardDeclaration2();

    void memoryManagement();

    void downCast();

    void functionCallDownCast();

    void upCast();

    void qobjectWeakManagement();

    void noSharedPointerFromWeakQObject();

    void weakQObjectFromSharedPointer();

    void objectCast();

    void differentPointers();

    void virtualBaseDifferentPointers();

#ifndef QTEST_NO_RTTI

    void dynamicCast();

    void dynamicCastDifferentPointers();

    void dynamicCastVirtualBase();

    void dynamicCastFailure();

#endif

    void constCorrectness();

    void customDeleter();

    void creating();

    void creatingQObject();

    void mixTrackingPointerCode();

    void reentrancyWhileDestructing();

    void threadStressTest_data();

    void threadStressTest();

    void map();

    void hash();

    void validConstructs();

    void invalidConstructs_data();

    void invalidConstructs();

public slots:

    void cleanup() { check(); }

public:

    inline void check()

    {

#ifdef QT_BUILD_INTERNAL

        QtSharedPointer::internalSafetyCheckCleanCheck();

#endif

    }

};

template <typename Base>

class RefCountHack: public Base

{

public:

    using Base::d;

};

template<typename Base> static inline

QtSharedPointer::ExternalRefCountData *refCountData(const Base &b)

{ return static_cast<const RefCountHack<Base> *>(&b)->d; }

class Data

{

public:

    static int destructorCounter;

    static int generationCounter;

    int generation;

    Data() : generation(++generationCounter)

    { }

    virtual ~Data()

    {

        Q_ASSERT_X(generation > 0, "tst_QSharedPointer", "Double deletion!");

        generation = 0;

        ++destructorCounter;

    }

    void doDelete()

    {

        delete this;

    }

    bool alsoDelete()

    {

        doDelete();

        return true;

    }

    virtual void virtualDelete()

    {

        delete this;

    }

    virtual int classLevel() { return 1; }

};

int Data::generationCounter = 0;

int Data::destructorCounter = 0;

void tst_QSharedPointer::basics_data()

{

    QTest::addColumn<bool>("isNull");

    QTest::newRow("null") << true;

    QTest::newRow("non-null") << false;

}

void tst_QSharedPointer::basics()

{

    {

        QSharedPointer<Data> ptr;

        QWeakPointer<Data> weakref;

        QCOMPARE(sizeof(ptr), 2*sizeof(void*));

        QCOMPARE(sizeof(weakref), 2*sizeof(void*));

    }

    QFETCH(bool, isNull);

    Data *aData = 0;

    if (!isNull)

        aData = new Data;

    Data *otherData = new Data;

    QSharedPointer<Data> ptr(aData);

    {

        // basic self tests

        QCOMPARE(ptr.isNull(), isNull);

        QCOMPARE(bool(ptr), !isNull);

        QCOMPARE(!ptr, isNull);

        QCOMPARE(ptr.data(), aData);

        QCOMPARE(ptr.operator->(), aData);

        Data &dataReference = *ptr;

        QCOMPARE(&dataReference, aData);

        QVERIFY(ptr == aData);

        QVERIFY(!(ptr != aData));

        QVERIFY(aData == ptr);

        QVERIFY(!(aData != ptr));

        QVERIFY(ptr != otherData);

        QVERIFY(otherData != ptr);

        QVERIFY(! (ptr == otherData));

        QVERIFY(! (otherData == ptr));

    }

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->weakref == 1);

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref == 1);

    {

        // create another object:

        QSharedPointer<Data> otherCopy(otherData);

        QVERIFY(ptr != otherCopy);

        QVERIFY(otherCopy != ptr);

        QVERIFY(! (ptr == otherCopy));

        QVERIFY(! (otherCopy == ptr));

        // otherData is deleted here

    }

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->weakref == 1);

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref == 1);

    {

        // create a copy:

        QSharedPointer<Data> copy(ptr);

        QVERIFY(copy == ptr);

        QVERIFY(ptr == copy);

        QVERIFY(! (copy != ptr));

        QVERIFY(! (ptr != copy));

        QCOMPARE(copy, ptr);

        QCOMPARE(ptr, copy);

        QCOMPARE(copy.isNull(), isNull);

        QCOMPARE(copy.data(), aData);

        QVERIFY(copy == aData);

    }

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->weakref == 1);

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref == 1);

    {

        // create a weak reference:

        QWeakPointer<Data> weak(ptr);

        QCOMPARE(weak.isNull(), isNull);

        QCOMPARE(!weak, isNull);

        QCOMPARE(bool(weak), !isNull);

        QVERIFY(ptr == weak);

        QVERIFY(weak == ptr);

        QVERIFY(! (ptr != weak));

        QVERIFY(! (weak != ptr));

        // create another reference:

        QWeakPointer<Data> weak2(weak);

        QCOMPARE(weak2.isNull(), isNull);

        QCOMPARE(!weak2, isNull);

        QCOMPARE(bool(weak2), !isNull);

        QVERIFY(weak2 == weak);

        QVERIFY(weak == weak2);

        QVERIFY(! (weak2 != weak));

        QVERIFY(! (weak != weak2));

        // create a strong reference back:

        QSharedPointer<Data> strong(weak);

        QVERIFY(strong == weak);

        QVERIFY(strong == ptr);

        QCOMPARE(strong.data(), aData);

    }

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->weakref == 1);

    QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref == 1);

    // aData is deleted here

}

void tst_QSharedPointer::operators()

{

    QSharedPointer<char> p1;

    QSharedPointer<char> p2(new char);

    qptrdiff diff = p2.data() - p1.data();

    Q_ASSERT(p1.data() < p2.data());

    Q_ASSERT(diff > 0);

    // operator-

    QCOMPARE(p2 - p1.data(), diff);

    QCOMPARE(p2.data() - p1, diff);

    QCOMPARE(p2 - p1, diff);

    QCOMPARE(p1 - p2, -diff);

    QCOMPARE(p1 - p1, qptrdiff(0));

    QCOMPARE(p2 - p2, qptrdiff(0));

    // operator<

    QVERIFY(p1 < p2.data());

    QVERIFY(p1.data() < p2);

    QVERIFY(p1 < p2);

    QVERIFY(!(p2 < p1));

    QVERIFY(!(p2 < p2));

    QVERIFY(!(p1 < p1));

    // qHash

    QCOMPARE(qHash(p1), qHash(p1.data()));

    QCOMPARE(qHash(p2), qHash(p2.data()));

}

void tst_QSharedPointer::swap()

{

    QSharedPointer<int> p1, p2(new int(42)), control = p2;

    QVERIFY(p1 != control);

    QVERIFY(p1.isNull());

    QVERIFY(p2 == control);

    QVERIFY(!p2.isNull());

    QVERIFY(*p2 == 42);

    p1.swap(p2);

    QVERIFY(p1 == control);

    QVERIFY(!p1.isNull());

    QVERIFY(p2 != control);

    QVERIFY(p2.isNull());

    QVERIFY(*p1 == 42);

    p1.swap(p2);

    QVERIFY(p1 != control);

    QVERIFY(p1.isNull());

    QVERIFY(p2 == control);

    QVERIFY(!p2.isNull());

    QVERIFY(*p2 == 42);

    qSwap(p1, p2);

    QVERIFY(p1 == control);

    QVERIFY(!p1.isNull());

    QVERIFY(p2 != control);

    QVERIFY(p2.isNull());

    QVERIFY(*p1 == 42);

}

class ForwardDeclared;

ForwardDeclared *forwardPointer();

void externalForwardDeclaration();

extern int forwardDeclaredDestructorRunCount;

void tst_QSharedPointer::forwardDeclaration1()

{

#if defined(Q_CC_SUN) || defined(Q_CC_WINSCW) || defined(Q_CC_RVCT)

    QSKIP("This type of forward declaration is not valid with this compiler", SkipAll);

#else

    externalForwardDeclaration();

    struct Wrapper { QSharedPointer<ForwardDeclared> pointer; };

    forwardDeclaredDestructorRunCount = 0;

    {

        Wrapper w;

        w.pointer = QSharedPointer<ForwardDeclared>(forwardPointer());

        QVERIFY(!w.pointer.isNull());

    }

    QCOMPARE(forwardDeclaredDestructorRunCount, 1);

#endif

}

#include "forwarddeclared.h"

void tst_QSharedPointer::forwardDeclaration2()

{

    forwardDeclaredDestructorRunCount = 0;

    {

        struct Wrapper { QSharedPointer<ForwardDeclared> pointer; };

        Wrapper w1, w2;

        w1.pointer = QSharedPointer<ForwardDeclared>(forwardPointer());

        QVERIFY(!w1.pointer.isNull());

    }

    QCOMPARE(forwardDeclaredDestructorRunCount, 1);

}

void tst_QSharedPointer::memoryManagement()

{

    int generation = Data::generationCounter + 1;

    int destructorCounter = Data::destructorCounter;

    QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data);

    QCOMPARE(ptr->generation, generation);

    QCOMPARE(Data::destructorCounter, destructorCounter);

    QCOMPARE(Data::generationCounter, generation);

    ptr = ptr;

    QCOMPARE(ptr->generation, generation);

    QCOMPARE(Data::destructorCounter, destructorCounter);

    QCOMPARE(Data::generationCounter, generation);

    {

        QSharedPointer<Data> copy = ptr;

        QCOMPARE(ptr->generation, generation);

        QCOMPARE(copy->generation, generation);

        // copy goes out of scope, ptr continues

    }

    QCOMPARE(ptr->generation, generation);

    QCOMPARE(Data::destructorCounter, destructorCounter);

    QCOMPARE(Data::generationCounter, generation);

    {

        QWeakPointer<Data> weak = ptr;

        weak = ptr;

        QCOMPARE(ptr->generation, generation);

        QCOMPARE(Data::destructorCounter, destructorCounter);

        QCOMPARE(Data::generationCounter, generation);

        weak = weak;

        QCOMPARE(ptr->generation, generation);

        QCOMPARE(Data::destructorCounter, destructorCounter);

        QCOMPARE(Data::generationCounter, generation);

        QSharedPointer<Data> strong = weak;

        QCOMPARE(ptr->generation, generation);

        QCOMPARE(strong->generation, generation);

        QCOMPARE(Data::destructorCounter, destructorCounter);

        QCOMPARE(Data::generationCounter, generation);

        // both weak and strong go out of scope

    }

    QCOMPARE(ptr->generation, generation);

    QCOMPARE(Data::destructorCounter, destructorCounter);

    QCOMPARE(Data::generationCounter, generation);

    QWeakPointer<Data> weak = ptr;

    ptr = QSharedPointer<Data>();

    // destructor must have been called

    QCOMPARE(Data::destructorCounter, destructorCounter + 1);

    QVERIFY(ptr.isNull());

    QVERIFY(weak.isNull());

    // if we create a strong pointer from the weak, it must still be null

    ptr = weak;

    QVERIFY(ptr.isNull());

    QVERIFY(ptr == 0);

    QCOMPARE(ptr.data(), (Data*)0);

}

class DerivedData: public Data

{

public:

    static int derivedDestructorCounter;

    int moreData;

    DerivedData() : moreData(0) { }

    ~DerivedData() { ++derivedDestructorCounter; }

    virtual void virtualDelete()

    {

        delete this;

    }

    virtual int classLevel() { return 2; }

};

int DerivedData::derivedDestructorCounter = 0;

class Stuffing

{

public:

    char buffer[16];

    Stuffing() { for (uint i = 0; i < sizeof buffer; ++i) buffer[i] = 16 - i; }

    virtual ~Stuffing() { }

};

class DiffPtrDerivedData: public Stuffing, public Data

{

public:

    virtual int classLevel() { return 3; }

};

class VirtualDerived: virtual public Data

{

public:

    int moreData;

    VirtualDerived() : moreData(0xc0ffee) { }

    virtual int classLevel() { return 4; }

};

void tst_QSharedPointer::downCast()

{

    {

        QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData);

        QSharedPointer<Data> baseptr = qSharedPointerCast<Data>(ptr);

        QSharedPointer<Data> other;

        QVERIFY(ptr == baseptr);

        QVERIFY(baseptr == ptr);

        QVERIFY(! (ptr != baseptr));

        QVERIFY(! (baseptr != ptr));

        QVERIFY(ptr != other);

        QVERIFY(other != ptr);

        QVERIFY(! (ptr == other));

        QVERIFY(! (other == ptr));

    }

    {

        QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData);

        QSharedPointer<Data> baseptr = ptr;

    }

    int destructorCount;

    destructorCount = DerivedData::derivedDestructorCounter;

    {

        QSharedPointer<Data> baseptr;

        {

            QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData);

            baseptr = ptr;

            QVERIFY(baseptr == ptr);

        }

    }

    QCOMPARE(DerivedData::derivedDestructorCounter, destructorCount + 1);

    destructorCount = DerivedData::derivedDestructorCounter;

    {

        QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData);

        QWeakPointer<Data> baseptr = ptr;

        QVERIFY(baseptr == ptr);

        ptr = QSharedPointer<DerivedData>();