diff options
Diffstat (limited to 'tests/auto/corelib/kernel')
8 files changed, 363 insertions, 7 deletions
diff --git a/tests/auto/corelib/kernel/kernel.pro b/tests/auto/corelib/kernel/kernel.pro index fe3e4b7e0a..4b3b2e824e 100644 --- a/tests/auto/corelib/kernel/kernel.pro +++ b/tests/auto/corelib/kernel/kernel.pro @@ -13,6 +13,7 @@ SUBDIRS=\ qobject \ qpointer \ qsharedmemory \ + qsignalblocker \ qsignalmapper \ qsocketnotifier \ qsystemsemaphore \ @@ -34,6 +35,6 @@ SUBDIRS=\ qsharedmemory # This test is only applicable on Windows -!win32*:SUBDIRS -= qwineventnotifier +!win32*|winrt: SUBDIRS -= qwineventnotifier android|qnx: SUBDIRS -= qsharedmemory qsystemsemaphore diff --git a/tests/auto/corelib/kernel/qeventloop/qeventloop.pro b/tests/auto/corelib/kernel/qeventloop/qeventloop.pro index e5bcc31e6a..5593aa2430 100644 --- a/tests/auto/corelib/kernel/qeventloop/qeventloop.pro +++ b/tests/auto/corelib/kernel/qeventloop/qeventloop.pro @@ -4,7 +4,7 @@ TARGET = tst_qeventloop QT = core network testlib core-private SOURCES = $$PWD/tst_qeventloop.cpp -win32:!wince*:LIBS += -luser32 +win32:!wince*:!winrt:LIBS += -luser32 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0 contains(QT_CONFIG, glib): DEFINES += HAVE_GLIB diff --git a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp index 5cf3e6d97c..0e7005799e 100644 --- a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp +++ b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp @@ -1323,8 +1323,8 @@ bool tst_QMetaObjectBuilder::sameMetaObject return false; } - const QMetaObject **objects1 = meta1->d.relatedMetaObjects; - const QMetaObject **objects2 = meta2->d.relatedMetaObjects; + const QMetaObject * const *objects1 = meta1->d.relatedMetaObjects; + const QMetaObject * const *objects2 = meta2->d.relatedMetaObjects; if (objects1 && !objects2) return false; if (objects2 && !objects1) diff --git a/tests/auto/corelib/kernel/qmetatype/qmetatype.pro b/tests/auto/corelib/kernel/qmetatype/qmetatype.pro index 23a8e6d23a..d19ec23760 100644 --- a/tests/auto/corelib/kernel/qmetatype/qmetatype.pro +++ b/tests/auto/corelib/kernel/qmetatype/qmetatype.pro @@ -6,11 +6,11 @@ SOURCES = tst_qmetatype.cpp TESTDATA=./typeFlags.bin DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0 -win32-msvc*|wince { +win32-msvc*|wince|winrt { # Prevents "fatal error C1128: number of sections exceeded object file format limit". QMAKE_CXXFLAGS += /bigobj # Reduce compile time - win32-msvc2012|wince { + win32-msvc2012|wince|winrt { QMAKE_CXXFLAGS_RELEASE -= -O2 QMAKE_CFLAGS_RELEASE -= -O2 } diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp index f1e04511cd..b6be7f0f3e 100644 --- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp +++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp @@ -102,6 +102,7 @@ private slots: #ifndef QT_NO_PROCESS void recursiveSignalEmission(); #endif + void signalBlocking(); void blockingQueuedConnection(); void childEvents(); void installEventFilter(); @@ -454,7 +455,7 @@ void tst_QObject::connectSlotsByName() sender.setObjectName("Sender"); QTest::ignoreMessage(QtWarningMsg, "QMetaObject::connectSlotsByName: No matching signal for on_child_signal()"); - QTest::ignoreMessage(QtWarningMsg, "QMetaObject::connectSlotsByName: Connecting slot on_Sender_signalManyParams() with the first of the following compatible signals: (\"signalManyParams(int,int,int,QString,bool)\", \"signalManyParams(int,int,int,QString,bool,bool)\") "); + QTest::ignoreMessage(QtWarningMsg, "QMetaObject::connectSlotsByName: Connecting slot on_Sender_signalManyParams() with the first of the following compatible signals: (\"signalManyParams(int,int,int,QString,bool)\", \"signalManyParams(int,int,int,QString,bool,bool)\")"); QMetaObject::connectSlotsByName(&receiver); receiver.called_slots.clear(); @@ -2949,6 +2950,9 @@ void tst_QObject::dynamicProperties() QVERIFY(!obj.setProperty("myuserproperty", "Hello")); QCOMPARE(obj.changedDynamicProperties.count(), 1); QCOMPARE(obj.changedDynamicProperties.first(), QByteArray("myuserproperty")); + //check if there is no redundant DynamicPropertyChange events + QVERIFY(!obj.setProperty("myuserproperty", "Hello")); + QCOMPARE(obj.changedDynamicProperties.count(), 1); obj.changedDynamicProperties.clear(); QCOMPARE(obj.property("myuserproperty").toString(), QString("Hello")); @@ -2981,6 +2985,30 @@ void tst_QObject::recursiveSignalEmission() } #endif +void tst_QObject::signalBlocking() +{ + SenderObject sender; + ReceiverObject receiver; + + receiver.connect(&sender, SIGNAL(signal1()), SLOT(slot1())); + + sender.emitSignal1(); + QVERIFY(receiver.called(1)); + receiver.reset(); + + sender.blockSignals(true); + + sender.emitSignal1(); + QVERIFY(!receiver.called(1)); + receiver.reset(); + + sender.blockSignals(false); + + sender.emitSignal1(); + QVERIFY(receiver.called(1)); + receiver.reset(); +} + void tst_QObject::blockingQueuedConnection() { { @@ -4731,6 +4759,9 @@ class LotsOfSignalsAndSlots: public QObject #endif*/ static void static_slot_vPFvvE(fptr) {} + void slot_vcRQObject(const QObject &) {} + void slot_vRQObject(QObject &) {} + signals: void signal_v(); void signal_vi(int); @@ -4748,6 +4779,9 @@ class LotsOfSignalsAndSlots: public QObject void const_signal_v() const; void const_signal_vi(int) const; + void signal_vcRQObject(const QObject &); + void signal_vRQObject(QObject &); + void signal(short&, short, long long, short); void otherSignal(const char *); }; @@ -4865,6 +4899,14 @@ void tst_QObject::connectCxx0xTypeMatching() QVERIFY(QObject::connect(&obj, &Foo::const_signal_vi, &obj, &Foo::slot_vi)); QVERIFY(QObject::connect(&obj, &Foo::signal_vi, &obj, &Foo::const_slot_vi)); QVERIFY(QObject::connect(&obj, &Foo::signal_vi, &obj, &Foo::const_slot_v)); + + QVERIFY(QObject::connect(&obj, &Foo::signal_vcRQObject, &obj, &Foo::slot_vcRQObject)); + QVERIFY(QObject::connect(&obj, &Foo::signal_vRQObject, &obj, &Foo::slot_vRQObject)); + QVERIFY(QObject::connect(&obj, &Foo::signal_vRQObject, &obj, &Foo::slot_vcRQObject)); + // QVERIFY(QObject::connect(&obj, &Foo::signal_vcRQObject, &obj, &Foo::slot_vRQObject)); // Should be an error (const& -> &) + + QVERIFY(QObject::connect(&obj, &Foo::signal_vRi, &obj, &Foo::slot_vs)); + } class StringVariant : public QObject diff --git a/tests/auto/corelib/kernel/qsignalblocker/.gitignore b/tests/auto/corelib/kernel/qsignalblocker/.gitignore new file mode 100644 index 0000000000..a841a2a0a8 --- /dev/null +++ b/tests/auto/corelib/kernel/qsignalblocker/.gitignore @@ -0,0 +1 @@ +tst_qsignalblocker diff --git a/tests/auto/corelib/kernel/qsignalblocker/qsignalblocker.pro b/tests/auto/corelib/kernel/qsignalblocker/qsignalblocker.pro new file mode 100644 index 0000000000..c6c6f379eb --- /dev/null +++ b/tests/auto/corelib/kernel/qsignalblocker/qsignalblocker.pro @@ -0,0 +1,7 @@ +CONFIG += testcase console +CONFIG += parallel_test +TARGET = tst_qsignalblocker +QT = core testlib +SOURCES = tst_qsignalblocker.cpp + +DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0 diff --git a/tests/auto/corelib/kernel/qsignalblocker/tst_qsignalblocker.cpp b/tests/auto/corelib/kernel/qsignalblocker/tst_qsignalblocker.cpp new file mode 100644 index 0000000000..1f71692ffe --- /dev/null +++ b/tests/auto/corelib/kernel/qsignalblocker/tst_qsignalblocker.cpp @@ -0,0 +1,305 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@woboq.com> +** Contact: http://www.qt-project.org/legal +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** 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, Digia gives you certain additional +** rights. These rights are described in the Digia 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. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtTest/QtTest> + +#include "qobject.h" + +class tst_QSignalBlocker : public QObject +{ + Q_OBJECT +private slots: + void signalBlocking(); + void signalBlockingMoveAssignment(); +}; + +class SenderObject : public QObject +{ + Q_OBJECT + +public: + SenderObject() : aPublicSlotCalled(0), recursionCount(0) {} + + void emitSignal1AfterRecursion() + { + if (recursionCount++ < 100) + emitSignal1AfterRecursion(); + else + emitSignal1(); + } + + void emitSignal1() { emit signal1(); } + void emitSignal2() { emit signal2(); } + void emitSignal3() { emit signal3(); } + void emitSignal4() { emit signal4(); } + +signals: + void signal1(); + void signal2(); + void signal3(); + void signal4(); + QT_MOC_COMPAT void signal5(); + void signal6(void); + void signal7(int, const QString &); + +public slots: + void aPublicSlot() { aPublicSlotCalled++; } + +public: + Q_INVOKABLE void invoke1(){} + Q_SCRIPTABLE void sinvoke1(){} + int aPublicSlotCalled; +protected: + Q_INVOKABLE QT_MOC_COMPAT void invoke2(){} + Q_INVOKABLE QT_MOC_COMPAT void invoke2(int){} + Q_SCRIPTABLE QT_MOC_COMPAT void sinvoke2(){} +private: + Q_INVOKABLE void invoke3(int hinz = 0, int kunz = 0){Q_UNUSED(hinz) Q_UNUSED(kunz)} + Q_SCRIPTABLE void sinvoke3(){} + + int recursionCount; +}; + +class ReceiverObject : public QObject +{ + Q_OBJECT + +public: + ReceiverObject() + : sequence_slot1( 0 ) + , sequence_slot2( 0 ) + , sequence_slot3( 0 ) + , sequence_slot4( 0 ) + {} + + void reset() + { + sequence_slot4 = 0; + sequence_slot3 = 0; + sequence_slot2 = 0; + sequence_slot1 = 0; + count_slot1 = 0; + count_slot2 = 0; + count_slot3 = 0; + count_slot4 = 0; + } + + int sequence_slot1; + int sequence_slot2; + int sequence_slot3; + int sequence_slot4; + int count_slot1; + int count_slot2; + int count_slot3; + int count_slot4; + + bool called(int slot) + { + switch (slot) { + case 1: return sequence_slot1; + case 2: return sequence_slot2; + case 3: return sequence_slot3; + case 4: return sequence_slot4; + default: return false; + } + } + + static int sequence; + +public slots: + void slot1() { sequence_slot1 = ++sequence; count_slot1++; } + void slot2() { sequence_slot2 = ++sequence; count_slot2++; } + void slot3() { sequence_slot3 = ++sequence; count_slot3++; } + void slot4() { sequence_slot4 = ++sequence; count_slot4++; } + +}; + +int ReceiverObject::sequence = 0; + +void tst_QSignalBlocker::signalBlocking() +{ + SenderObject sender; + ReceiverObject receiver; + + receiver.connect(&sender, SIGNAL(signal1()), SLOT(slot1())); + + sender.emitSignal1(); + QVERIFY(receiver.called(1)); + receiver.reset(); + + { + QSignalBlocker blocker(&sender); + + sender.emitSignal1(); + QVERIFY(!receiver.called(1)); + receiver.reset(); + + sender.blockSignals(false); + + sender.emitSignal1(); + QVERIFY(receiver.called(1)); + receiver.reset(); + + sender.blockSignals(true); + + sender.emitSignal1(); + QVERIFY(!receiver.called(1)); + receiver.reset(); + + blocker.unblock(); + + sender.emitSignal1(); + QVERIFY(receiver.called(1)); + receiver.reset(); + + blocker.reblock(); + + sender.emitSignal1(); + QVERIFY(!receiver.called(1)); + receiver.reset(); + } + + sender.emitSignal1(); + QVERIFY(receiver.called(1)); + receiver.reset(); +} + +void tst_QSignalBlocker::signalBlockingMoveAssignment() +{ +#ifdef Q_COMPILER_RVALUE_REFS + QObject o1, o2; + + // move-assignment: both block other objects + { + QSignalBlocker b(&o1); + QVERIFY(o1.signalsBlocked()); + + QVERIFY(!o2.signalsBlocked()); + b = QSignalBlocker(&o2); + QVERIFY(!o1.signalsBlocked()); + QVERIFY(o2.signalsBlocked()); + } + + QVERIFY(!o1.signalsBlocked()); + QVERIFY(!o2.signalsBlocked()); + + // move-assignment: from inert other + { + QSignalBlocker b(&o1); + QVERIFY(o1.signalsBlocked()); + b = QSignalBlocker(0); + } + + QVERIFY(!o1.signalsBlocked()); + QVERIFY(!o2.signalsBlocked()); + + // move-assignment: to inert *this + { + QSignalBlocker b(0); + QVERIFY(!o1.signalsBlocked()); + { + QSignalBlocker inner(&o1); + QVERIFY(o1.signalsBlocked()); + b = std::move(inner); + } + QVERIFY(o1.signalsBlocked()); + } + + QVERIFY(!o1.signalsBlocked()); + QVERIFY(!o2.signalsBlocked()); + + // move-assignment: both block the same object, neither is unblocked + { + QSignalBlocker b(&o1); + QVERIFY(o1.signalsBlocked()); + { + b.unblock(); // make sure inner.m_blocked = false + QVERIFY(!o1.signalsBlocked()); + QSignalBlocker inner(&o1); + QVERIFY(o1.signalsBlocked()); + b.reblock(); + QVERIFY(o1.signalsBlocked()); + b = std::move(inner); + } + QVERIFY(o1.signalsBlocked()); + } + + QVERIFY(!o1.signalsBlocked()); + QVERIFY(!o2.signalsBlocked()); + + // move-assignment: both block the same object, but *this is unblocked + { + QSignalBlocker b(&o1); + QVERIFY(o1.signalsBlocked()); + b.unblock(); + QVERIFY(!o1.signalsBlocked()); + b = QSignalBlocker(&o1); + QVERIFY(o1.signalsBlocked()); + } + + QVERIFY(!o1.signalsBlocked()); + QVERIFY(!o2.signalsBlocked()); + + // move-assignment: both block the same object, but other is unblocked + { + QSignalBlocker b(&o1); + { + QVERIFY(o1.signalsBlocked()); + QSignalBlocker inner(&o1); + QVERIFY(o1.signalsBlocked()); + inner.unblock(); + QVERIFY(o1.signalsBlocked()); + b = std::move(inner); + QVERIFY(!o1.signalsBlocked()); + } + QVERIFY(!o1.signalsBlocked()); + } + + QVERIFY(!o1.signalsBlocked()); + QVERIFY(!o2.signalsBlocked()); + +#else + QSKIP("This compiler is not in C++11 mode or doesn't support move semantics"); +#endif // Q_COMPILER_RVALUE_REFS +} + +QTEST_MAIN(tst_QSignalBlocker) +#include "tst_qsignalblocker.moc" |