From 3a7e6157d1a9865a31a5641605bbe9b0fc25e1d4 Mon Sep 17 00:00:00 2001 From: Holger Ihrig Date: Thu, 25 Aug 2011 12:16:22 +0200 Subject: Moving relevant tests to corelib/kernel Added Test for qmetaproperty Marked QSocketNotifier Autotest as insignificant. See QTBUG-21204 Marked qtranslator Autotest as insignificant. See QTBUG-21125 Marked corelib/io/qfile/largefile as insignificant. See QTBUG-21175 Task-number: QTBUG-21066 Change-Id: I2a7f6587845c355091bb07c8dd3d1557d16db0be Reviewed-on: http://codereview.qt.nokia.com/3598 Reviewed-by: Qt Sanity Bot Reviewed-by: Sergio Ahumada --- .../auto/corelib/kernel/qpointer/tst_qpointer.cpp | 343 +++++++++++++++++++++ 1 file changed, 343 insertions(+) create mode 100644 tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp (limited to 'tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp') diff --git a/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp b/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp new file mode 100644 index 0000000000..fed98ec86a --- /dev/null +++ b/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp @@ -0,0 +1,343 @@ +/**************************************************************************** +** +** Copyright (C) 2011 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$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include + +#include +#include + +class tst_QPointer : public QObject +{ + Q_OBJECT +public: + inline tst_QPointer *me() const + { return const_cast(this); } + +private slots: + void constructors(); + void destructor(); + void assignment_operators(); + void equality_operators(); + void isNull(); + void dereference_operators(); + void disconnect(); + void castDuringDestruction(); + void threadSafety(); +}; + +void tst_QPointer::constructors() +{ + QPointer p1; + QPointer p2(this); + QPointer p3(p2); + QCOMPARE(p1, QPointer(0)); + QCOMPARE(p2, QPointer(this)); + QCOMPARE(p3, QPointer(this)); +} + +void tst_QPointer::destructor() +{ + // Make two QPointer's to the same object + QObject *object = new QObject; + QPointer p1 = object; + QPointer p2 = object; + // Check that they point to the correct object + QCOMPARE(p1, QPointer(object)); + QCOMPARE(p2, QPointer(object)); + QCOMPARE(p1, p2); + // Destroy the guarded object + delete object; + // Check that both pointers were zeroed + QCOMPARE(p1, QPointer(0)); + QCOMPARE(p2, QPointer(0)); + QCOMPARE(p1, p2); +} + +void tst_QPointer::assignment_operators() +{ + QPointer p1; + QPointer p2; + + // Test assignment with a QObject-derived object pointer + p1 = this; + p2 = p1; + QCOMPARE(p1, QPointer(this)); + QCOMPARE(p2, QPointer(this)); + QCOMPARE(p1, QPointer(p2)); + + // Test assignment with a null pointer + p1 = 0; + p2 = p1; + QCOMPARE(p1, QPointer(0)); + QCOMPARE(p2, QPointer(0)); + QCOMPARE(p1, QPointer(p2)); + + // Test assignment with a real QObject pointer + QObject *object = new QObject; + + p1 = object; + p2 = p1; + QCOMPARE(p1, QPointer(object)); + QCOMPARE(p2, QPointer(object)); + QCOMPARE(p1, QPointer(p2)); + + // Test assignment with the same pointer that's already guarded + p1 = object; + p2 = p1; + QCOMPARE(p1, QPointer(object)); + QCOMPARE(p2, QPointer(object)); + QCOMPARE(p1, QPointer(p2)); + + // Cleanup + delete object; +} + +void tst_QPointer::equality_operators() +{ + QPointer p1; + QPointer p2; + + QVERIFY(p1 == p2); + + QObject *object = 0; + QWidget *widget = 0; + + p1 = object; + QVERIFY(p1 == p2); + QVERIFY(p1 == object); + p2 = object; + QVERIFY(p2 == p1); + QVERIFY(p2 == object); + + p1 = this; + QVERIFY(p1 != p2); + p2 = p1; + QVERIFY(p1 == p2); + + // compare to zero + p1 = 0; + QVERIFY(p1 == 0); + QVERIFY(0 == p1); + QVERIFY(p2 != 0); + QVERIFY(0 != p2); + QVERIFY(p1 == object); + QVERIFY(object == p1); + QVERIFY(p2 != object); + QVERIFY(object != p2); + QVERIFY(p1 == widget); + QVERIFY(widget == p1); + QVERIFY(p2 != widget); + QVERIFY(widget != p2); +} + +void tst_QPointer::isNull() +{ + QPointer p1; + QVERIFY(p1.isNull()); + p1 = this; + QVERIFY(!p1.isNull()); + p1 = 0; + QVERIFY(p1.isNull()); +} + +void tst_QPointer::dereference_operators() +{ + QPointer p1 = this; + QPointer p2; + + // operator->() -- only makes sense if not null + QObject *object = p1->me(); + QCOMPARE(object, this); + + // operator*() -- only makes sense if not null + QObject &ref = *p1; + QCOMPARE(&ref, this); + + // operator T*() + QCOMPARE(static_cast(p1), this); + QCOMPARE(static_cast(p2), static_cast(0)); + + // data() + QCOMPARE(p1.data(), this); + QCOMPARE(p2.data(), static_cast(0)); +} + +void tst_QPointer::disconnect() +{ + // Verify that pointer remains guarded when all signals are disconencted. + QPointer p1 = new QObject; + QVERIFY(!p1.isNull()); + p1->disconnect(); + QVERIFY(!p1.isNull()); + delete static_cast(p1); + QVERIFY(p1.isNull()); +} + +class ChildObject : public QObject +{ + QPointer guardedPointer; + +public: + ChildObject(QObject *parent) + : QObject(parent), guardedPointer(parent) + { } + ~ChildObject(); +}; + +ChildObject::~ChildObject() +{ + QCOMPARE(static_cast(guardedPointer), static_cast(0)); + QCOMPARE(qobject_cast(guardedPointer), static_cast(0)); +} + +class ChildWidget : public QWidget +{ + QPointer guardedPointer; + +public: + ChildWidget(QWidget *parent) + : QWidget(parent), guardedPointer(parent) + { } + ~ChildWidget(); +}; + +ChildWidget::~ChildWidget() +{ + QCOMPARE(static_cast(guardedPointer), static_cast(0)); + QCOMPARE(qobject_cast(guardedPointer), static_cast(0)); +} + +class DerivedChild; + +class DerivedParent : public QObject +{ + Q_OBJECT + + DerivedChild *derivedChild; + +public: + DerivedParent(); + ~DerivedParent(); +}; + +class DerivedChild : public QObject +{ + Q_OBJECT + + DerivedParent *parentPointer; + QPointer guardedParentPointer; + +public: + DerivedChild(DerivedParent *parent) + : QObject(parent), parentPointer(parent), guardedParentPointer(parent) + { } + ~DerivedChild(); +}; + +DerivedParent::DerivedParent() + : QObject() +{ + derivedChild = new DerivedChild(this); +} + +DerivedParent::~DerivedParent() +{ + delete derivedChild; +} + +DerivedChild::~DerivedChild() +{ + QCOMPARE(static_cast(guardedParentPointer), parentPointer); + QCOMPARE(qobject_cast(guardedParentPointer), parentPointer); +} + +void tst_QPointer::castDuringDestruction() +{ + { + QObject *parentObject = new QObject(); + (void) new ChildObject(parentObject); + delete parentObject; + } + + { + QWidget *parentWidget = new QWidget(); + (void) new ChildWidget(parentWidget); + delete parentWidget; + } + + { + delete new DerivedParent(); + } +} + +class TestRunnable : public QObject, public QRunnable { + void run() { + QPointer obj1 = new QObject; + QPointer obj2 = new QObject; + obj1->moveToThread(thread()); // this is the owner thread + obj1->deleteLater(); // the delete will happen in the owner thread + obj2->moveToThread(thread()); // this is the owner thread + obj2->deleteLater(); // the delete will happen in the owner thread + } +}; + +void tst_QPointer::threadSafety() +{ + + QThread owner; + owner.start(); + + QThreadPool pool; + for (int i = 0; i < 300; i++) { + QPointer task = new TestRunnable; + task->setAutoDelete(true); + task->moveToThread(&owner); + pool.start(task); + } + pool.waitForDone(); + + owner.quit(); + owner.wait(); +} + + +QTEST_MAIN(tst_QPointer) +#include "tst_qpointer.moc" -- cgit v1.2.3