Revert "Revert "Add support for creating the object alongside the Data structure in QSharedPointer""

This restores the original implementation of the creating
function. The next commit will make it suitable for use.

1 files changed, 100 insertions, 2 deletions

diff --git a/tests/auto/qsharedpointer/tst_qsharedpointer.cpp b/tests/auto/qsharedpointer/tst_qsharedpointer.cpp
index 5cb435a..dd53e3c 100644
--- a/tests/auto/qsharedpointer/tst_qsharedpointer.cpp
+++ b/tests/auto/qsharedpointer/tst_qsharedpointer.cpp
@@ -65,8 +65,9 @@ private slots:
     void dynamicCastVirtualBase();
     void dynamicCastFailure();
 #endif
-    void customDeleter();
     void constCorrectness();
+    void customDeleter();
+    void creating();
     void validConstructs();
     void invalidConstructs_data();
     void invalidConstructs();
@@ -104,6 +105,8 @@ public:
     {
         delete this;
     }
+
+    virtual int classLevel() { return 1; }
 };
 int Data::generationCounter = 0;
 int Data::destructorCounter = 0;
@@ -332,6 +335,8 @@ public:
     {
         delete this;
     }
+
+    virtual int classLevel() { return 2; }
 };
 int DerivedData::derivedDestructorCounter = 0;
 
@@ -339,15 +344,23 @@ 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()
@@ -993,6 +1006,82 @@ void tst_QSharedPointer::customDeleter()
     QCOMPARE(derivedDataDeleter.callCount, 1);
 }
 
+void tst_QSharedPointer::creating()
+{
+    Data::generationCounter = Data::destructorCounter = 0;
+    {
+        QSharedPointer<Data> ptr = QSharedPointer<Data>::create();
+        QVERIFY(ptr.data());
+        QCOMPARE(Data::generationCounter, 1);
+        QCOMPARE(ptr->generation, 1);
+        QCOMPARE(Data::destructorCounter, 0);
+
+        QCOMPARE(ptr->classLevel(), 1);
+
+        ptr.clear();
+        QCOMPARE(Data::destructorCounter, 1);
+    }
+
+    Data::generationCounter = Data::destructorCounter = 0;
+    {
+        QSharedPointer<Data> ptr = QSharedPointer<Data>::create();
+        QWeakPointer<Data> weakptr = ptr;
+        QtSharedPointer::ExternalRefCountData *d = ptr.d;
+
+        ptr.clear();
+        QVERIFY(ptr.isNull());
+        QCOMPARE(Data::destructorCounter, 1);
+
+        // valgrind will complain here if something happened to the pointer
+        QVERIFY(d->weakref == 1);
+        QVERIFY(d->strongref == 0);
+    }
+
+    Data::generationCounter = Data::destructorCounter = 0;
+    DerivedData::derivedDestructorCounter = 0;
+    {
+        QSharedPointer<Data> ptr = QSharedPointer<DerivedData>::create();
+        QCOMPARE(ptr->classLevel(), 2);
+        QCOMPARE(ptr.staticCast<DerivedData>()->moreData, 0);
+        ptr.clear();
+
+        QCOMPARE(Data::destructorCounter, 1);
+        QCOMPARE(DerivedData::derivedDestructorCounter, 1);
+    }
+
+    {
+        QSharedPointer<Data> ptr = QSharedPointer<DiffPtrDerivedData>::create();
+        QCOMPARE(ptr->classLevel(), 3);
+        QCOMPARE(ptr.staticCast<DiffPtrDerivedData>()->buffer[7]+0, 16-7);
+        QCOMPARE(ptr.staticCast<DiffPtrDerivedData>()->buffer[3]+0, 16-3);
+        QCOMPARE(ptr.staticCast<DiffPtrDerivedData>()->buffer[0]+0, 16);
+    }
+
+    {
+        QSharedPointer<VirtualDerived> ptr = QSharedPointer<VirtualDerived>::create();
+        QCOMPARE(ptr->classLevel(), 4);
+        QCOMPARE(ptr->moreData, 0xc0ffee);
+
+        QSharedPointer<Data> baseptr = ptr;
+        QCOMPARE(baseptr->classLevel(), 4);
+    }
+
+    {
+        QSharedPointer<QObject> ptr = QSharedPointer<QObject>::create();
+        QCOMPARE(ptr->metaObject(), &QObject::staticMetaObject);
+
+        QPointer<QObject> qptr = ptr.data();
+        ptr.clear();
+
+        QVERIFY(qptr.isNull());
+    }
+
+    {
+        QSharedPointer<QObject> ptr = QSharedPointer<OtherObject>::create();
+        QCOMPARE(ptr->metaObject(), &OtherObject::staticMetaObject);
+    }
+}
+
 void tst_QSharedPointer::validConstructs()
 {
     {
@@ -1044,6 +1133,9 @@ void tst_QSharedPointer::invalidConstructs_data()
         << "forwardDeclaredDestructorRunCount = 0;\n"
            "{ QSharedPointer<ForwardDeclared> ptr = QSharedPointer<ForwardDeclared>(forwardPointer()); }\n"
            "exit(forwardDeclaredDestructorRunCount);";
+    QTest::newRow("creating-forward-declaration")
+        << &QTest::QExternalTest::tryCompileFail
+        << "QSharedPointer<ForwardDeclared>::create();";
 
     // upcast without cast operator:
     QTest::newRow("upcast1")
@@ -1076,10 +1168,16 @@ void tst_QSharedPointer::invalidConstructs_data()
         << "QSharedPointer<const Data> baseptr = QSharedPointer<const Data>(new Data);\n"
         "qSharedPointerDynamicCast<DerivedData>(baseptr);";
 #endif
-    QTest::newRow("const-dropping-object-cast")
+    QTest::newRow("const-dropping-object-cast1")
         << &QTest::QExternalTest::tryCompileFail
         << "QSharedPointer<const QObject> baseptr = QSharedPointer<const QObject>(new QObject);\n"
         "qSharedPointerObjectCast<QCoreApplication>(baseptr);";
+#ifndef QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION
+    QTest::newRow("const-dropping-object-cast2")
+        << &QTest::QExternalTest::tryCompileFail
+        << "QSharedPointer<const QObject> baseptr = QSharedPointer<const QObject>(new QObject);\n"
+        "qobject_cast<QCoreApplication *>(baseptr);";
+#endif
 
     // arithmethics through automatic cast operators
     QTest::newRow("arithmethic1")