1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #define QT_SHAREDPOINTER_TRACK_POINTERS

    43 #include "qsharedpointer.h"

    44 #include <QtTest/QtTest>

    45 #include <QtCore/QThread>

    46 #include <QtCore/QVector>

    47 

    48 #include "externaltests.h"

    49 #include "wrapper.h"

    50 

    51 #include <stdlib.h>

    52 #include <time.h>

    53 

    54 QT_BEGIN_NAMESPACE

    55 namespace QtSharedPointer {

    56     Q_CORE_EXPORT void internalSafetyCheckCleanCheck();

    57 }

    58 QT_END_NAMESPACE

    59 

    60 #ifdef Q_OS_SYMBIAN

    61 #define SRCDIR "."

    62 #endif

    63 

    64 class tst_QSharedPointer: public QObject

    65 {

    66     Q_OBJECT

    67 

    68 private slots:

    69     void basics_data();

    70     void basics();

    71     void swap();

    72     void forwardDeclaration1();

    73     void forwardDeclaration2();

    74     void memoryManagement();

    75     void downCast();

    76     void functionCallDownCast();

    77     void upCast();

    78     void qobjectWeakManagement();

    79     void noSharedPointerFromWeakQObject();

    80     void weakQObjectFromSharedPointer();

    81     void objectCast();

    82     void differentPointers();

    83     void virtualBaseDifferentPointers();

    84 #ifndef QTEST_NO_RTTI

    85     void dynamicCast();

    86     void dynamicCastDifferentPointers();

    87     void dynamicCastVirtualBase();

    88     void dynamicCastFailure();

    89 #endif

    90     void constCorrectness();

    91     void customDeleter();

    92     void creating();

    93     void creatingQObject();

    94     void mixTrackingPointerCode();

    95     void threadStressTest_data();

    96     void threadStressTest();

    97     void validConstructs();

    98     void invalidConstructs_data();

    99     void invalidConstructs();

   100 

   101 public slots:

   102     void cleanup() { check(); }

   103 

   104 public:

   105     inline void check()

   106     {

   107 #ifdef QT_BUILD_INTERNAL

   108         QtSharedPointer::internalSafetyCheckCleanCheck();

   109 #endif

   110     }

   111 };

   112 

   113 template <typename Base>

   114 class RefCountHack: public Base

   115 {

   116 public:

   117     using Base::d;

   118 };

   119 template<typename Base> static inline

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

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

   122 

   123 class Data

   124 {

   125 public:

   126     static int destructorCounter;

   127     static int generationCounter;

   128     int generation;

   129 

   130     Data() : generation(++generationCounter)

   131     { }

   132 

   133     virtual ~Data()

   134     {

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

   136         generation = 0;

   137         ++destructorCounter;

   138     }

   139 

   140     void doDelete()

   141     {

   142         delete this;

   143     }

   144 

   145     bool alsoDelete()

   146     {

   147         doDelete();

   148         return true;

   149     }

   150 

   151     virtual void virtualDelete()

   152     {

   153         delete this;

   154     }

   155 

   156     virtual int classLevel() { return 1; }

   157 };

   158 int Data::generationCounter = 0;

   159 int Data::destructorCounter = 0;

   160 

   161 void tst_QSharedPointer::basics_data()

   162 {

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

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

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

   166 }

   167 

   168 void tst_QSharedPointer::basics()

   169 {

   170     {

   171         QSharedPointer<Data> ptr;

   172         QWeakPointer<Data> weakref;

   173 

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

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

   176     }

   177 

   178     QFETCH(bool, isNull);

   179     Data *aData = 0;

   180     if (!isNull)

   181         aData = new Data;

   182     Data *otherData = new Data;

   183     QSharedPointer<Data> ptr(aData);

   184 

   185     {

   186         // basic self tests

   187         QCOMPARE(ptr.isNull(), isNull);

   188         QCOMPARE(bool(ptr), !isNull);

   189         QCOMPARE(!ptr, isNull);

   190 

   191         QCOMPARE(ptr.data(), aData);

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

   193         Data &dataReference = *ptr;

   194         QCOMPARE(&dataReference, aData);

   195 

   196         QVERIFY(ptr == aData);

   197         QVERIFY(!(ptr != aData));

   198         QVERIFY(aData == ptr);

   199         QVERIFY(!(aData != ptr));

   200 

   201         QVERIFY(ptr != otherData);

   202         QVERIFY(otherData != ptr);

   203         QVERIFY(! (ptr == otherData));

   204         QVERIFY(! (otherData == ptr));

   205     }

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

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

   208 

   209     {

   210         // create another object:

   211         QSharedPointer<Data> otherCopy(otherData);

   212         QVERIFY(ptr != otherCopy);

   213         QVERIFY(otherCopy != ptr);

   214         QVERIFY(! (ptr == otherCopy));

   215         QVERIFY(! (otherCopy == ptr));

   216 

   217         // otherData is deleted here

   218     }

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

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

   221 

   222     {

   223         // create a copy:

   224         QSharedPointer<Data> copy(ptr);

   225         QVERIFY(copy == ptr);

   226         QVERIFY(ptr == copy);

   227         QVERIFY(! (copy != ptr));

   228         QVERIFY(! (ptr != copy));

   229         QCOMPARE(copy, ptr);

   230         QCOMPARE(ptr, copy);

   231 

   232         QCOMPARE(copy.isNull(), isNull);

   233         QCOMPARE(copy.data(), aData);

   234         QVERIFY(copy == aData);

   235     }

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

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

   238 

   239     {

   240         // create a weak reference:

   241         QWeakPointer<Data> weak(ptr);

   242         QCOMPARE(weak.isNull(), isNull);

   243         QCOMPARE(!weak, isNull);

   244         QCOMPARE(bool(weak), !isNull);

   245 

   246         QVERIFY(ptr == weak);

   247         QVERIFY(weak == ptr);

   248         QVERIFY(! (ptr != weak));

   249         QVERIFY(! (weak != ptr));

   250 

   251         // create another reference:

   252         QWeakPointer<Data> weak2(weak);

   253         QCOMPARE(weak2.isNull(), isNull);

   254         QCOMPARE(!weak2, isNull);

   255         QCOMPARE(bool(weak2), !isNull);

   256 

   257         QVERIFY(weak2 == weak);

   258         QVERIFY(weak == weak2);

   259         QVERIFY(! (weak2 != weak));

   260         QVERIFY(! (weak != weak2));

   261 

   262         // create a strong reference back:

   263         QSharedPointer<Data> strong(weak);

   264         QVERIFY(strong == weak);

   265         QVERIFY(strong == ptr);

   266         QCOMPARE(strong.data(), aData);

   267     }

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

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

   270 

   271     // aData is deleted here

   272 }

   273 

   274 void tst_QSharedPointer::swap()

   275 {

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

   277     QVERIFY(p1 != control);

   278     QVERIFY(p1.isNull());

   279     QVERIFY(p2 == control);

   280     QVERIFY(!p2.isNull());

   281     QVERIFY(*p2 == 42);

   282 

   283     p1.swap(p2);

   284     QVERIFY(p1 == control);

   285     QVERIFY(!p1.isNull());

   286     QVERIFY(p2 != control);

   287     QVERIFY(p2.isNull());

   288     QVERIFY(*p1 == 42);

   289 

   290     p1.swap(p2);

   291     QVERIFY(p1 != control);

   292     QVERIFY(p1.isNull());

   293     QVERIFY(p2 == control);

   294     QVERIFY(!p2.isNull());

   295     QVERIFY(*p2 == 42);

   296 

   297     qSwap(p1, p2);

   298     QVERIFY(p1 == control);

   299     QVERIFY(!p1.isNull());

   300     QVERIFY(p2 != control);

   301     QVERIFY(p2.isNull());

   302     QVERIFY(*p1 == 42);

   303 }

   304 

   305 class ForwardDeclared;

   306 ForwardDeclared *forwardPointer();

   307 void externalForwardDeclaration();

   308 extern int forwardDeclaredDestructorRunCount;

   309 

   310 void tst_QSharedPointer::forwardDeclaration1()

   311 {

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

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

   314 #else

   315     externalForwardDeclaration();

   316 

   317     struct Wrapper { QSharedPointer<ForwardDeclared> pointer; };

   318 

   319     forwardDeclaredDestructorRunCount = 0;

   320     {

   321         Wrapper w;

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

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

   324     }

   325     QCOMPARE(forwardDeclaredDestructorRunCount, 1);

   326 #endif

   327 }

   328 

   329 #include "forwarddeclared.h"

   330 

   331 void tst_QSharedPointer::forwardDeclaration2()

   332 {

   333     forwardDeclaredDestructorRunCount = 0;

   334     {

   335         struct Wrapper { QSharedPointer<ForwardDeclared> pointer; };

   336         Wrapper w1, w2;

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

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

   339     }

   340     QCOMPARE(forwardDeclaredDestructorRunCount, 1);

   341 }

   342 

   343 void tst_QSharedPointer::memoryManagement()

   344 {

   345     int generation = Data::generationCounter + 1;

   346     int destructorCounter = Data::destructorCounter;

   347 

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

   349     QCOMPARE(ptr->generation, generation);

   350     QCOMPARE(Data::destructorCounter, destructorCounter);

   351     QCOMPARE(Data::generationCounter, generation);

   352 

   353     ptr = ptr;

   354     QCOMPARE(ptr->generation, generation);

   355     QCOMPARE(Data::destructorCounter, destructorCounter);

   356     QCOMPARE(Data::generationCounter, generation);

   357 

   358     {

   359         QSharedPointer<Data> copy = ptr;

   360         QCOMPARE(ptr->generation, generation);

   361         QCOMPARE(copy->generation, generation);

   362 

   363         // copy goes out of scope, ptr continues

   364     }

   365     QCOMPARE(ptr->generation, generation);

   366     QCOMPARE(Data::destructorCounter, destructorCounter);

   367     QCOMPARE(Data::generationCounter, generation);

   368 

   369     {

   370         QWeakPointer<Data> weak = ptr;

   371         weak = ptr;

   372         QCOMPARE(ptr->generation, generation);

   373         QCOMPARE(Data::destructorCounter, destructorCounter);

   374         QCOMPARE(Data::generationCounter, generation);

   375 

   376         weak = weak;

   377         QCOMPARE(ptr->generation, generation);

   378         QCOMPARE(Data::destructorCounter, destructorCounter);

   379         QCOMPARE(Data::generationCounter, generation);

   380 

   381         QSharedPointer<Data> strong = weak;

   382         QCOMPARE(ptr->generation, generation);

   383         QCOMPARE(strong->generation, generation);

   384         QCOMPARE(Data::destructorCounter, destructorCounter);

   385         QCOMPARE(Data::generationCounter, generation);

   386 

   387         // both weak and strong go out of scope

   388     }

   389     QCOMPARE(ptr->generation, generation);

   390     QCOMPARE(Data::destructorCounter, destructorCounter);

   391     QCOMPARE(Data::generationCounter, generation);

   392 

   393     QWeakPointer<Data> weak = ptr;

   394     ptr = QSharedPointer<Data>();

   395 

   396     // destructor must have been called

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

   398     QVERIFY(ptr.isNull());

   399     QVERIFY(weak.isNull());

   400 

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

   402     ptr = weak;

   403     QVERIFY(ptr.isNull());

   404     QVERIFY(ptr == 0);

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

   406 }

   407 

   408 class DerivedData: public Data

   409 {

   410 public:

   411     static int derivedDestructorCounter;

   412     int moreData;

   413     DerivedData() : moreData(0) { }

   414     ~DerivedData() { ++derivedDestructorCounter; }

   415 

   416     virtual void virtualDelete()

   417     {

   418         delete this;

   419     }

   420 

   421     virtual int classLevel() { return 2; }

   422 };

   423 int DerivedData::derivedDestructorCounter = 0;

   424 

   425 class Stuffing

   426 {

   427 public:

   428     char buffer[16];

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

   430     virtual ~Stuffing() { }

   431 };

   432 

   433 class DiffPtrDerivedData: public Stuffing, public Data

   434 {

   435 public:

   436     virtual int classLevel() { return 3; }

   437 };

   438 

   439 class VirtualDerived: virtual public Data

   440 {

   441 public:

   442     int moreData;

   443 

   444     VirtualDerived() : moreData(0xc0ffee) { }

   445     virtual int classLevel() { return 4; }

   446 };

   447 

   448 void tst_QSharedPointer::downCast()

   449 {

   450     {

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

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

   453         QSharedPointer<Data> other;

   454 

   455         QVERIFY(ptr == baseptr);

   456         QVERIFY(baseptr == ptr);

   457         QVERIFY(! (ptr != baseptr));

   458         QVERIFY(! (baseptr != ptr));

   459 

   460         QVERIFY(ptr != other);

   461         QVERIFY(other != ptr);

   462         QVERIFY(! (ptr == other));

   463         QVERIFY(! (other == ptr));

   464     }

   465 

   466     {

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

   468         QSharedPointer<Data> baseptr = ptr;

   469     }

   470 

   471     int destructorCount;

   472     destructorCount = DerivedData::derivedDestructorCounter;

   473     {

   474         QSharedPointer<Data> baseptr;

   475         {

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

   477             baseptr = ptr;

   478             QVERIFY(baseptr == ptr);

   479         }

   480     }

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

   482 

   483     destructorCount = DerivedData::derivedDestructorCounter;

   484     {

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

   486         QWeakPointer<Data> baseptr = ptr;

   487         QVERIFY(baseptr == ptr);

   488 

   489         ptr = QSharedPointer<DerivedData>();

   490         QVERIFY(baseptr.isNull());

   491     }

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

   493 

   494     destructorCount = DerivedData::derivedDestructorCounter;

   495     {

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

   497         QWeakPointer<DerivedData> weakptr(ptr);

   498 

   499         QSharedPointer<Data> baseptr = weakptr;

   500         QVERIFY(baseptr == ptr);

   501         QWeakPointer<Data> baseweakptr = weakptr;

   502         QVERIFY(baseweakptr == ptr);

   503     }

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

   505 }

   506 

   507 void functionDataByValue(QSharedPointer<Data> p) { Q_UNUSED(p); };

   508 void functionDataByRef(const QSharedPointer<Data> &p) { Q_UNUSED(p); };

   509 void tst_QSharedPointer::functionCallDownCast()

   510 {

   511     QSharedPointer<DerivedData> p(new DerivedData());

   512     functionDataByValue(p);

   513     functionDataByRef(p);

   514 }

   515 

   516 void tst_QSharedPointer::upCast()

   517 {

   518     QSharedPointer<Data> baseptr = QSharedPointer<Data>(new DerivedData);

   519 

   520     {

   521         QSharedPointer<DerivedData> derivedptr = qSharedPointerCast<DerivedData>(baseptr);

   522         QVERIFY(baseptr == derivedptr);

   523         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   524     }

   525     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   526     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   527 

   528     {

   529         QWeakPointer<DerivedData> derivedptr = qWeakPointerCast<DerivedData>(baseptr);

   530         QVERIFY(baseptr == derivedptr);

   531     }

   532     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   533     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   534 

   535     {

   536         QWeakPointer<Data> weakptr = baseptr;

   537         QSharedPointer<DerivedData> derivedptr = qSharedPointerCast<DerivedData>(weakptr);

   538         QVERIFY(baseptr == derivedptr);

   539         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   540     }

   541     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   542     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   543 

   544     {

   545         QSharedPointer<DerivedData> derivedptr = baseptr.staticCast<DerivedData>();

   546         QVERIFY(baseptr == derivedptr);

   547         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   548     }

   549     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   550     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   551 }

   552 

   553 class OtherObject: public QObject

   554 {

   555     Q_OBJECT

   556 };

   557 

   558 void tst_QSharedPointer::qobjectWeakManagement()

   559 {

   560     {

   561         QWeakPointer<QObject> weak;

   562         weak = QWeakPointer<QObject>();

   563         QVERIFY(weak.isNull());

   564         QVERIFY(!weak.data());

   565     }

   566 

   567     {

   568         QObject *obj = new QObject;

   569         QWeakPointer<QObject> weak(obj);

   570         QVERIFY(!weak.isNull());

   571         QVERIFY(weak.data() == obj);

   572 

   573         // now delete

   574         delete obj;

   575         QVERIFY(weak.isNull());

   576     }

   577     check();

   578 

   579     {

   580         // same, bit with operator=

   581         QObject *obj = new QObject;

   582         QWeakPointer<QObject> weak;

   583         weak = obj;

   584         QVERIFY(!weak.isNull());

   585         QVERIFY(weak.data() == obj);

   586 

   587         // now delete

   588         delete obj;

   589         QVERIFY(weak.isNull());

   590     }

   591     check();

   592 

   593     {

   594         // delete triggered by parent

   595         QObject *obj, *parent;

   596         parent = new QObject;

   597         obj = new QObject(parent);

   598         QWeakPointer<QObject> weak(obj);

   599 

   600         // now delete the parent

   601         delete parent;

   602         QVERIFY(weak.isNull());

   603     }

   604     check();

   605 

   606     {

   607         // same as above, but set the parent after QWeakPointer is created

   608         QObject *obj, *parent;

   609         obj = new QObject;

   610         QWeakPointer<QObject> weak(obj);

   611 

   612         parent = new QObject;

   613         obj->setParent(parent);

   614 

   615         // now delete the parent

   616         delete parent;

   617         QVERIFY(weak.isNull());

   618     }

   619     check();

   620 

   621     {

   622         // with two QWeakPointers

   623         QObject *obj = new QObject;

   624         QWeakPointer<QObject> weak(obj);

   625 

   626         {

   627             QWeakPointer<QObject> weak2(obj);

   628             QVERIFY(!weak2.isNull());

   629             QVERIFY(weak == weak2);

   630         }

   631         QVERIFY(!weak.isNull());

   632 

   633         delete obj;

   634         QVERIFY(weak.isNull());

   635     }

   636     check();

   637 

   638     {

   639         // same, but delete the pointer while two QWeakPointers exist

   640         QObject *obj = new QObject;

   641         QWeakPointer<QObject> weak(obj);

   642 

   643         {

   644             QWeakPointer<QObject> weak2(obj);

   645             QVERIFY(!weak2.isNull());

   646 

   647             delete obj;

   648             QVERIFY(weak.isNull());

   649             QVERIFY(weak2.isNull());

   650         }

   651         QVERIFY(weak.isNull());

   652     }

   653     check();

   654 }

   655 

   656 void tst_QSharedPointer::noSharedPointerFromWeakQObject()

   657 {

   658     // you're not allowed to create a QSharedPointer from an unmanaged QObject

   659     QObject obj;

   660     QWeakPointer<QObject> weak(&obj);

   661 

   662     QSharedPointer<QObject> strong = weak.toStrongRef();

   663     QVERIFY(strong.isNull());

   664 

   665     // is something went wrong, we'll probably crash here

   666 }

   667 

   668 void tst_QSharedPointer::weakQObjectFromSharedPointer()

   669 {

   670     // this is the inverse of the above: you're allowed to create a QWeakPointer

   671     // from a managed QObject

   672     QSharedPointer<QObject> shared(new QObject);

   673     QWeakPointer<QObject> weak = shared.data();

   674     QVERIFY(!weak.isNull());

   675 

   676     // delete:

   677     shared.clear();

   678     QVERIFY(weak.isNull());

   679 }

   680 

   681 void tst_QSharedPointer::objectCast()

   682 {

   683     {

   684         OtherObject *data = new OtherObject;

   685         QSharedPointer<QObject> baseptr = QSharedPointer<QObject>(data);

   686         QVERIFY(baseptr == data);

   687         QVERIFY(data == baseptr);

   688 

   689         // perform object cast

   690         QSharedPointer<OtherObject> ptr = qSharedPointerObjectCast<OtherObject>(baseptr);

   691         QVERIFY(!ptr.isNull());

   692         QCOMPARE(ptr.data(), data);

   693         QVERIFY(ptr == data);

   694 

   695         // again:

   696         ptr = baseptr.objectCast<OtherObject>();

   697         QVERIFY(ptr == data);

   698 

   699 #ifndef QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION

   700         // again:

   701         ptr = qobject_cast<OtherObject *>(baseptr);

   702         QVERIFY(ptr == data);

   703 

   704         // again:

   705         ptr = qobject_cast<QSharedPointer<OtherObject> >(baseptr);

   706         QVERIFY(ptr == data);

   707 #endif

   708     }

   709     check();

   710 

   711     {

   712         const OtherObject *data = new OtherObject;

   713         QSharedPointer<const QObject> baseptr = QSharedPointer<const QObject>(data);

   714         QVERIFY(baseptr == data);

   715         QVERIFY(data == baseptr);

   716 

   717         // perform object cast

   718         QSharedPointer<const OtherObject> ptr = qSharedPointerObjectCast<const OtherObject>(baseptr);

   719         QVERIFY(!ptr.isNull());

   720         QCOMPARE(ptr.data(), data);

   721         QVERIFY(ptr == data);

   722 

   723         // again:

   724         ptr = baseptr.objectCast<const OtherObject>();

   725         QVERIFY(ptr == data);

   726 

   727 #ifndef QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION

   728         // again:

   729         ptr = qobject_cast<const OtherObject *>(baseptr);

   730         QVERIFY(ptr == data);

   731 

   732         // again:

   733         ptr = qobject_cast<QSharedPointer<const OtherObject> >(baseptr);

   734         QVERIFY(ptr == data);

   735 #endif

   736     }

   737     check();

   738 

   739     {

   740         OtherObject *data = new OtherObject;

   741         QPointer<OtherObject> qptr = data;

   742         QSharedPointer<OtherObject> ptr = QSharedPointer<OtherObject>(data);

   743         QWeakPointer<QObject> weakptr = ptr;

   744 

   745         {

   746             // perform object cast

   747             QSharedPointer<OtherObject> otherptr = qSharedPointerObjectCast<OtherObject>(weakptr);

   748             QVERIFY(otherptr == ptr);

   749 

   750             // again:

   751             otherptr = qobject_cast<OtherObject *>(weakptr);

   752             QVERIFY(otherptr == ptr);

   753 

   754             // again:

   755             otherptr = qobject_cast<QSharedPointer<OtherObject> >(weakptr);

   756             QVERIFY(otherptr == ptr);

   757         }

   758 

   759         // drop the reference:

   760         ptr.clear();

   761         QVERIFY(ptr.isNull());

   762         QVERIFY(qptr.isNull());

   763         QVERIFY(weakptr.toStrongRef().isNull());

   764 

   765         // verify that the object casts fail without crash

   766         QSharedPointer<OtherObject> otherptr = qSharedPointerObjectCast<OtherObject>(weakptr);

   767         QVERIFY(otherptr.isNull());

   768 

   769 #ifndef QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION

   770         // again:

   771         otherptr = qobject_cast<OtherObject *>(weakptr);

   772         QVERIFY(otherptr.isNull());

   773 

   774         // again:

   775         otherptr = qobject_cast<QSharedPointer<OtherObject> >(weakptr);

   776         QVERIFY(otherptr.isNull());

   777 #endif

   778     }

   779     check();

   780 }

   781 

   782 void tst_QSharedPointer::differentPointers()

   783 {

   784     {

   785         DiffPtrDerivedData *aData = new DiffPtrDerivedData;

   786         Data *aBase = aData;

   787 

   788         // ensure that this compiler isn't broken

   789         if (*reinterpret_cast<quintptr *>(&aData) == *reinterpret_cast<quintptr *>(&aBase))

   790             qFatal("Something went very wrong -- we couldn't create two different pointers to the same object");

   791         if (aData != aBase)

   792             QSKIP("Broken compiler", SkipAll);

   793         if (aBase != aData)

   794             QSKIP("Broken compiler", SkipAll);

   795 

   796         QSharedPointer<DiffPtrDerivedData> ptr = QSharedPointer<DiffPtrDerivedData>(aData);

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

   798         qDebug("naked: orig: %p; base: %p (%s) -- QSharedPointer: orig: %p; base %p (%s) -- result: %s",

   799                aData, aBase, aData == aBase ? "equal" : "not equal",

   800                ptr.data(), baseptr.data(), ptr.data() == baseptr.data() ? "equal" : "not equal",

   801                baseptr.data() == aData ? "equal" : "not equal");

   802 

   803         QVERIFY(ptr.data() == baseptr.data());

   804         QVERIFY(baseptr.data() == ptr.data());

   805         QVERIFY(ptr == baseptr);

   806         QVERIFY(baseptr == ptr);

   807 

   808         QVERIFY(ptr.data() == aBase);

   809         QVERIFY(aBase == ptr.data());

   810         QVERIFY(ptr.data() == aData);

   811         QVERIFY(aData == ptr.data());

   812 

   813         QVERIFY(ptr == aBase);

   814         QVERIFY(aBase == ptr);

   815         QVERIFY(ptr == aData);

   816         QVERIFY(aData == ptr);

   817 

   818         QVERIFY(baseptr.data() == aBase);

   819         QVERIFY(aBase == baseptr.data());

   820         QVERIFY(baseptr == aBase);

   821         QVERIFY(aBase == baseptr);

   822 

   823         QVERIFY(baseptr.data() == aData);

   824         QVERIFY(aData == baseptr.data());

   825 

   826 #if defined(Q_CC_MSVC) && _MSC_VER < 1400

   827         QEXPECT_FAIL("", "Compiler bug", Continue);

   828 #endif

   829         QVERIFY(baseptr == aData);

   830 #if defined(Q_CC_MSVC) && _MSC_VER < 1400

   831         QEXPECT_FAIL("", "Compiler bug", Continue);

   832 #endif

   833         QVERIFY(aData == baseptr);

   834     }

   835     check();

   836 

   837     {

   838         DiffPtrDerivedData *aData = new DiffPtrDerivedData;

   839         Data *aBase = aData;

   840         Q_ASSERT(aData == aBase);

   841         Q_ASSERT(*reinterpret_cast<quintptr *>(&aData) != *reinterpret_cast<quintptr *>(&aBase));

   842 

   843         QSharedPointer<Data> baseptr = QSharedPointer<Data>(aData);

   844         QSharedPointer<DiffPtrDerivedData> ptr = qSharedPointerCast<DiffPtrDerivedData>(baseptr);

   845         QVERIFY(ptr == baseptr);

   846         QVERIFY(ptr.data() == baseptr.data());

   847         QVERIFY(ptr == aBase);

   848 #if defined(Q_CC_MSVC) && _MSC_VER < 1400

   849         QEXPECT_FAIL("", "Compiler bug", Continue);

   850 #endif

   851         QVERIFY(baseptr == aData);

   852     }

   853     check();

   854 

   855     {

   856         DiffPtrDerivedData *aData = new DiffPtrDerivedData;

   857         Data *aBase = aData;

   858         Q_ASSERT(aData == aBase);

   859         Q_ASSERT(*reinterpret_cast<quintptr *>(&aData) != *reinterpret_cast<quintptr *>(&aBase));

   860 

   861         QSharedPointer<DiffPtrDerivedData> ptr = QSharedPointer<DiffPtrDerivedData>(aData);

   862         QSharedPointer<Data> baseptr = ptr;

   863         QVERIFY(ptr == baseptr);

   864         QVERIFY(ptr.data() == baseptr.data());

   865         QVERIFY(ptr == aBase);

   866         QVERIFY(ptr == aData);

   867 #if defined(Q_CC_MSVC) && _MSC_VER < 1400

   868         QEXPECT_FAIL("", "Compiler bug", Continue);

   869 #endif

   870         QVERIFY(baseptr == aData);

   871         QVERIFY(baseptr == aBase);

   872     }

   873     check();

   874 }

   875 

   876 void tst_QSharedPointer::virtualBaseDifferentPointers()

   877 {

   878     {

   879         VirtualDerived *aData = new VirtualDerived;

   880         Data *aBase = aData;

   881         Q_ASSERT(aData == aBase);

   882         Q_ASSERT(*reinterpret_cast<quintptr *>(&aData) != *reinterpret_cast<quintptr *>(&aBase));

   883 

   884         QSharedPointer<VirtualDerived> ptr = QSharedPointer<VirtualDerived>(aData);

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

   886         QVERIFY(ptr == baseptr);

   887         QVERIFY(ptr.data() == baseptr.data());

   888         QVERIFY(ptr == aBase);

   889         QVERIFY(ptr == aData);

   890 #if defined(Q_CC_MSVC) && _MSC_VER < 1400

   891         QEXPECT_FAIL("", "Compiler bug", Continue);

   892 #endif

   893         QVERIFY(baseptr == aData);

   894         QVERIFY(baseptr == aBase);

   895     }

   896     check();

   897 

   898     {

   899         VirtualDerived *aData = new VirtualDerived;

   900         Data *aBase = aData;

   901         Q_ASSERT(aData == aBase);

   902         Q_ASSERT(*reinterpret_cast<quintptr *>(&aData) != *reinterpret_cast<quintptr *>(&aBase));

   903 

   904         QSharedPointer<VirtualDerived> ptr = QSharedPointer<VirtualDerived>(aData);

   905         QSharedPointer<Data> baseptr = ptr;

   906         QVERIFY(ptr == baseptr);

   907         QVERIFY(ptr.data() == baseptr.data());

   908         QVERIFY(ptr == aBase);

   909         QVERIFY(ptr == aData);

   910 #if defined(Q_CC_MSVC) && _MSC_VER < 1400

   911         QEXPECT_FAIL("", "Compiler bug", Continue);

   912 #endif

   913         QVERIFY(baseptr == aData);

   914         QVERIFY(baseptr == aBase);

   915     }

   916     check();

   917 }

   918 

   919 #ifndef QTEST_NO_RTTI

   920 void tst_QSharedPointer::dynamicCast()

   921 {

   922     DerivedData *aData = new DerivedData;

   923     QSharedPointer<Data> baseptr = QSharedPointer<Data>(aData);

   924 

   925     {

   926         QSharedPointer<DerivedData> derivedptr = qSharedPointerDynamicCast<DerivedData>(baseptr);

   927         QVERIFY(baseptr == derivedptr);

   928         QCOMPARE(derivedptr.data(), aData);

   929         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   930     }

   931     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   932     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   933 

   934     {

   935         QWeakPointer<Data> weakptr = baseptr;

   936         QSharedPointer<DerivedData> derivedptr = qSharedPointerDynamicCast<DerivedData>(weakptr);

   937         QVERIFY(baseptr == derivedptr);

   938         QCOMPARE(derivedptr.data(), aData);

   939         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   940     }

   941     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   942     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   943 

   944     {

   945         QSharedPointer<DerivedData> derivedptr = baseptr.dynamicCast<DerivedData>();

   946         QVERIFY(baseptr == derivedptr);

   947         QCOMPARE(derivedptr.data(), aData);

   948         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   949     }

   950     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   951     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   952 }

   953 

   954 void tst_QSharedPointer::dynamicCastDifferentPointers()

   955 {

   956     // DiffPtrDerivedData derives from both Data and Stuffing

   957     DiffPtrDerivedData *aData = new DiffPtrDerivedData;

   958     QSharedPointer<Data> baseptr = QSharedPointer<Data>(aData);

   959 

   960     {

   961         QSharedPointer<DiffPtrDerivedData> derivedptr = qSharedPointerDynamicCast<DiffPtrDerivedData>(baseptr);

   962         QVERIFY(baseptr == derivedptr);

   963         QCOMPARE(derivedptr.data(), aData);

   964         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   965     }

   966     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   967     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   968 

   969     {

   970         QWeakPointer<Data> weakptr = baseptr;

   971         QSharedPointer<DiffPtrDerivedData> derivedptr = qSharedPointerDynamicCast<DiffPtrDerivedData>(weakptr);

   972         QVERIFY(baseptr == derivedptr);

   973         QCOMPARE(derivedptr.data(), aData);

   974         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   975     }

   976     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   977     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   978 

   979     {

   980         QSharedPointer<DiffPtrDerivedData> derivedptr = baseptr.dynamicCast<DiffPtrDerivedData>();

   981         QVERIFY(baseptr == derivedptr);

   982         QCOMPARE(derivedptr.data(), aData);

   983         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

   984     }

   985     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

   986     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

   987 

   988     {

   989         Stuffing *nakedptr = dynamic_cast<Stuffing *>(baseptr.data());

   990         QVERIFY(nakedptr);

   991 

   992         QSharedPointer<Stuffing> otherbaseptr = qSharedPointerDynamicCast<Stuffing>(baseptr);

   993         QVERIFY(!otherbaseptr.isNull());

   994         QVERIFY(otherbaseptr == nakedptr);

   995         QCOMPARE(otherbaseptr.data(), nakedptr);

   996         QCOMPARE(static_cast<DiffPtrDerivedData*>(otherbaseptr.data()), aData);

   997     }

   998 }

   999 

  1000 void tst_QSharedPointer::dynamicCastVirtualBase()

  1001 {

  1002     VirtualDerived *aData = new VirtualDerived;

  1003     QSharedPointer<Data> baseptr = QSharedPointer<Data>(aData);

  1004 

  1005     {

  1006         QSharedPointer<VirtualDerived> derivedptr = qSharedPointerDynamicCast<VirtualDerived>(baseptr);

  1007         QVERIFY(baseptr == derivedptr);

  1008         QCOMPARE(derivedptr.data(), aData);

  1009         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

  1010     }

  1011     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

  1012     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

  1013 

  1014     {

  1015         QWeakPointer<Data> weakptr = baseptr;

  1016         QSharedPointer<VirtualDerived> derivedptr = qSharedPointerDynamicCast<VirtualDerived>(weakptr);

  1017         QVERIFY(baseptr == derivedptr);

  1018         QCOMPARE(derivedptr.data(), aData);

  1019         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

  1020     }

  1021     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

  1022     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

  1023 

  1024     {

  1025         QSharedPointer<VirtualDerived> derivedptr = baseptr.dynamicCast<VirtualDerived>();

  1026         QVERIFY(baseptr == derivedptr);

  1027         QCOMPARE(derivedptr.data(), aData);

  1028         QCOMPARE(static_cast<Data *>(derivedptr.data()), baseptr.data());

  1029     }

  1030     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

  1031     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

  1032 }

  1033 

  1034 void tst_QSharedPointer::dynamicCastFailure()

  1035 {

  1036     QSharedPointer<Data> baseptr = QSharedPointer<Data>(new Data);

  1037     QVERIFY(dynamic_cast<DerivedData *>(baseptr.data()) == 0);

  1038 

  1039     {

  1040         QSharedPointer<DerivedData> derivedptr = qSharedPointerDynamicCast<DerivedData>(baseptr);

  1041         QVERIFY(derivedptr.isNull());

  1042     }

  1043     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

  1044     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

  1045 

  1046     {

  1047         QSharedPointer<DerivedData> derivedptr = baseptr.dynamicCast<DerivedData>();

  1048         QVERIFY(derivedptr.isNull());

  1049     }

  1050     QCOMPARE(int(refCountData(baseptr)->weakref), 1);

  1051     QCOMPARE(int(refCountData(baseptr)->strongref), 1);

  1052 }

  1053 #endif

  1054 

  1055 void tst_QSharedPointer::constCorrectness()

  1056 {

  1057     {

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

  1059         QSharedPointer<const Data> cptr(ptr);

  1060         QSharedPointer<volatile Data> vptr(ptr);

  1061         cptr = ptr;

  1062         vptr = ptr;

  1063 

  1064         ptr = qSharedPointerConstCast<Data>(cptr);

  1065         ptr = qSharedPointerConstCast<Data>(vptr);

  1066         ptr = cptr.constCast<Data>();

  1067         ptr = vptr.constCast<Data>();

  1068 

  1069 #if !defined(Q_CC_HPACC) && !defined(QT_ARCH_PARISC)

  1070         // the aCC series 3 compiler we have on the PA-RISC

  1071         // machine crashes compiling this code

  1072 

  1073         QSharedPointer<const volatile Data> cvptr(ptr);

  1074         QSharedPointer<const volatile Data> cvptr2(cptr);

  1075         QSharedPointer<const volatile Data> cvptr3(vptr);

  1076         cvptr = ptr;

  1077         cvptr2 = cptr;

  1078         cvptr3 = vptr;

  1079         ptr = qSharedPointerConstCast<Data>(cvptr);

  1080         ptr = cvptr.constCast<Data>();

  1081 #endif

  1082     }

  1083     check();

  1084 

  1085     {

  1086         Data *aData = new Data;

  1087         QSharedPointer<Data> ptr = QSharedPointer<Data>(aData);

  1088         const QSharedPointer<Data> cptr = ptr;

  1089 

  1090         ptr = cptr;

  1091         QSharedPointer<Data> other = qSharedPointerCast<Data>(cptr);

  1092 

  1093 #ifndef QT_NO_DYNAMIC_CAST

  1094         other = qSharedPointerDynamicCast<Data>(cptr);

  1095 #endif

  1096 

  1097         QCOMPARE(cptr.data(), aData);

  1098         QCOMPARE(cptr.operator->(), aData);

  1099     }

  1100     check();

  1101 }

  1102 

  1103 static int customDeleterFnCallCount;

  1104 void customDeleterFn(Data *ptr)

  1105 {

  1106     ++customDeleterFnCallCount;

  1107     delete ptr;

  1108 }

  1109 

  1110 static int refcount;

  1111 

  1112 template <typename T>

  1113 struct CustomDeleter

  1114 {

  1115     CustomDeleter() { ++refcount; }

  1116     CustomDeleter(const CustomDeleter &) { ++refcount; }

  1117     ~CustomDeleter() { --refcount; }

  1118     inline void operator()(T *ptr)

  1119     {

  1120         delete ptr;

  1121         ++callCount;

  1122     }

  1123     static int callCount;

  1124 };

  1125 template<typename T> int CustomDeleter<T>::callCount = 0;

  1126 

  1127 void tst_QSharedPointer::customDeleter()

  1128 {

  1129     {

  1130         QSharedPointer<Data> ptr(new Data, &Data::doDelete);

  1131         QSharedPointer<Data> ptr2(new Data, &Data::alsoDelete);

  1132         QSharedPointer<Data> ptr3(new Data, &Data::virtualDelete);

  1133     }

  1134     check();

  1135     {