Add tst_QEventDispatcher to tests/auto/corelib/kernel

This will test the event dispatcher in corelib for proper timer and
posted event handling. The test makes sure all of the necessary virtual
functions are implemented and working as expected.

This test doesn't test socket notifiers or Win32 event notifiers, as
these are already covered in existing tests.

Change-Id: I5540ffc4e6d7f97bcd6c3725d7e74c0ab9c97015
Reviewed-by: Robin Burchell <robin+qt@viroteck.net>

tests/auto/corelib/kernel/kernel.pro

@@ -1,6 +1,7 @@
 TEMPLATE=subdirs
 SUBDIRS=\
     qcoreapplication \
+    qeventdispatcher \
     qeventloop \
     qmath \
     qmetaobject \

tests/auto/corelib/kernel/qeventdispatcher/qeventdispatcher.pro

@@ -0,0 +1,4 @@
+CONFIG += testcase
+TARGET = tst_qeventdispatcher
+QT = core testlib
+SOURCES += tst_qeventdispatcher.cpp

tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp

@@ -0,0 +1,186 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** 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 <QtCore/QCoreApplication>
+#include <QtTest/QtTest>
+
+enum {
+    PreciseTimerInterval    =   10,
+    CoarseTimerInterval     =  200,
+    VeryCoarseTimerInterval = 1000
+};
+
+class tst_QEventDispatcher : public QObject
+{
+    Q_OBJECT
+
+    QAbstractEventDispatcher *eventDispatcher;
+    int receivedEventType;
+    int timerIdFromEvent;
+
+protected:
+    bool event(QEvent *e);
+
+public:
+    inline tst_QEventDispatcher()
+        : QObject(),
+          eventDispatcher(QAbstractEventDispatcher::instance(thread())),
+          receivedEventType(-1),
+          timerIdFromEvent(-1)
+    { }
+
+private slots:
+    void registerTimer();
+    /* void registerSocketNotifier(); */ // Not implemented here, see tst_QSocketNotifier instead
+    /* void registerEventNotifiier(); */ // Not implemented here, see tst_QWinEventNotifier instead
+    void sendPostedEvents();
+};
+
+bool tst_QEventDispatcher::event(QEvent *e)
+{
+    switch (receivedEventType = e->type()) {
+    case QEvent::Timer:
+    {
+        timerIdFromEvent = static_cast<QTimerEvent *>(e)->timerId();
+        return true;
+    }
+    default:
+        break;
+    }
+    return QObject::event(e);
+}
+
+// test that the eventDispatcher's timer implementation is complete and working
+void tst_QEventDispatcher::registerTimer()
+{
+#define FIND_TIMERS() \
+        do { \
+            foundPrecise = false; \
+            foundCoarse = false; \
+            foundVeryCoarse = false; \
+            for (int i = 0; i < registeredTimers.count(); ++i) { \
+                const QAbstractEventDispatcher::TimerInfo &timerInfo = registeredTimers.at(i); \
+                if (timerInfo.timerId == preciseTimerId) { \
+                    QCOMPARE(timerInfo.interval, int(PreciseTimerInterval)); \
+                    QCOMPARE(timerInfo.timerType, Qt::PreciseTimer); \
+                    foundPrecise = true; \
+                } else if (timerInfo.timerId == coarseTimerId) { \
+                    QCOMPARE(timerInfo.interval, int(CoarseTimerInterval)); \
+                    QCOMPARE(timerInfo.timerType, Qt::CoarseTimer); \
+                    foundCoarse = true; \
+                } else if (timerInfo.timerId == veryCoarseTimerId) { \
+                    QCOMPARE(timerInfo.interval, int(VeryCoarseTimerInterval)); \
+                    QCOMPARE(timerInfo.timerType, Qt::VeryCoarseTimer); \
+                    foundVeryCoarse = true; \
+                } \
+            } \
+        } while (0)
+
+    // start 3 timers, each with the different timer types and different intervals
+    int preciseTimerId = eventDispatcher->registerTimer(PreciseTimerInterval, Qt::PreciseTimer, this);
+    int coarseTimerId = eventDispatcher->registerTimer(CoarseTimerInterval, Qt::CoarseTimer, this);
+    int veryCoarseTimerId = eventDispatcher->registerTimer(VeryCoarseTimerInterval, Qt::VeryCoarseTimer, this);
+    QVERIFY(preciseTimerId > 0);
+    QVERIFY(coarseTimerId > 0);
+    QVERIFY(veryCoarseTimerId > 0);
+
+    // check that all 3 are present in the eventDispatcher's registeredTimer() list
+    QList<QAbstractEventDispatcher::TimerInfo> registeredTimers = eventDispatcher->registeredTimers(this);
+    QCOMPARE(registeredTimers.count(), 3);
+    bool foundPrecise, foundCoarse, foundVeryCoarse;
+    FIND_TIMERS();
+    QVERIFY(foundPrecise && foundCoarse && foundVeryCoarse);
+
+    // process events, waiting for the next event... this should only fire the precise timer
+    receivedEventType = -1;
+    timerIdFromEvent = -1;
+    QVERIFY(eventDispatcher->processEvents(QEventLoop::WaitForMoreEvents));
+    QCOMPARE(receivedEventType, int(QEvent::Timer));
+    QCOMPARE(timerIdFromEvent, preciseTimerId);
+    // now unregister it and make sure it's gone
+    eventDispatcher->unregisterTimer(preciseTimerId);
+    registeredTimers = eventDispatcher->registeredTimers(this);
+    QCOMPARE(registeredTimers.count(), 2);
+    FIND_TIMERS();
+    QVERIFY(!foundPrecise && foundCoarse && foundVeryCoarse);
+
+    // do the same again for the coarse timer
+    receivedEventType = -1;
+    timerIdFromEvent = -1;
+    QVERIFY(eventDispatcher->processEvents(QEventLoop::WaitForMoreEvents));
+    QCOMPARE(receivedEventType, int(QEvent::Timer));
+    QCOMPARE(timerIdFromEvent, coarseTimerId);
+    // now unregister it and make sure it's gone
+    eventDispatcher->unregisterTimer(coarseTimerId);
+    registeredTimers = eventDispatcher->registeredTimers(this);
+    QCOMPARE(registeredTimers.count(), 1);
+    FIND_TIMERS();
+    QVERIFY(!foundPrecise && !foundCoarse && foundVeryCoarse);
+
+    // not going to wait for the VeryCoarseTimer, would take too long, just unregister it
+    eventDispatcher->unregisterTimers(this);
+    registeredTimers = eventDispatcher->registeredTimers(this);
+    QVERIFY(registeredTimers.isEmpty());
+
+#undef FIND_TIMERS
+}
+
+// test that the eventDispatcher sends posted events correctly
+void tst_QEventDispatcher::sendPostedEvents()
+{
+    QElapsedTimer elapsedTimer;
+    elapsedTimer.start();
+    while (!elapsedTimer.hasExpired(200)) {
+        receivedEventType = -1;
+        QCoreApplication::postEvent(this, new QEvent(QEvent::User));
+
+        // event shouldn't be delivered as a result of posting
+        QCOMPARE(receivedEventType, -1);
+
+        // since there is a pending posted event, this should not actually block, it should send the posted event and return
+        QVERIFY(eventDispatcher->processEvents(QEventLoop::WaitForMoreEvents));
+        // event shouldn't be delivered as a result of posting
+        QCOMPARE(receivedEventType, int(QEvent::User));
+    }
+}
+
+QTEST_MAIN(tst_QEventDispatcher)
+#include "tst_qeventdispatcher.moc"