Add autotest for QInputPanel

Change-Id: I8ac28d93f610cd3eb69087d2c961a5aab6c47e1e
Reviewed-on: http://codereview.qt-project.org/5394
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>

src/gui/kernel/qinputpanel.cpp

@@ -41,8 +41,6 @@
 
 #include <qinputpanel.h>
 #include <private/qinputpanel_p.h>
-#include <qplatforminputcontext_qpa.h>
-#include <private/qguiapplication_p.h>
 
 QInputPanel::QInputPanel()
     : QObject(*new QInputPanelPrivate)
@@ -109,7 +107,8 @@ QRectF QInputPanel::cursorRectangle() const
 
 QRectF QInputPanel::keyboardRectangle()
 {
-    QPlatformInputContext *ic = QGuiApplicationPrivate::platformIntegration()->inputContext();
+    Q_D(QInputPanel);
+    QPlatformInputContext *ic = d->platformInputContext();
     if (ic)
         return ic->keyboardRect();
     return QRectF();
@@ -144,7 +143,8 @@ void QInputPanel::setVisible(bool visible)
 
 bool QInputPanel::isAnimating() const
 {
-    QPlatformInputContext *ic = QGuiApplicationPrivate::platformIntegration()->inputContext();
+    Q_D(const QInputPanel);
+    QPlatformInputContext *ic = d->platformInputContext();
     if (ic)
         return ic->isAnimating();
     return false;
@@ -158,7 +158,7 @@ void QInputPanel::update(Qt::InputMethodQueries queries)
     if (!d->inputItem)
         return;
 
-    QPlatformInputContext *ic = QGuiApplicationPrivate::platformIntegration()->inputContext();
+    QPlatformInputContext *ic = d->platformInputContext();
     if (ic)
         ic->update(queries);
 
@@ -168,21 +168,24 @@ void QInputPanel::update(Qt::InputMethodQueries queries)
 
 void QInputPanel::reset()
 {
-    QPlatformInputContext *ic = QGuiApplicationPrivate::platformIntegration()->inputContext();
+    Q_D(QInputPanel);
+    QPlatformInputContext *ic = d->platformInputContext();
     if (ic)
         ic->reset();
 }
 
 void QInputPanel::commit()
 {
-    QPlatformInputContext *ic = QGuiApplicationPrivate::platformIntegration()->inputContext();
+    Q_D(QInputPanel);
+    QPlatformInputContext *ic = d->platformInputContext();
     if (ic)
         ic->commit();
 }
 
 void QInputPanel::invokeAction(Action a, int cursorPosition)
 {
-    QPlatformInputContext *ic = QGuiApplicationPrivate::platformIntegration()->inputContext();
+    Q_D(QInputPanel);
+    QPlatformInputContext *ic = d->platformInputContext();
     if (ic)
         ic->invokeAction(a, cursorPosition);
 }

src/gui/kernel/qinputpanel_p.h

@@ -46,6 +46,8 @@
 #include <private/qobject_p.h>
 #include <QtCore/QWeakPointer>
 #include <QTransform>
+#include <qplatforminputcontext_qpa.h>
+#include <private/qguiapplication_p.h>
 
 QT_BEGIN_HEADER
 
@@ -55,11 +57,21 @@ class QInputPanelPrivate : public QObjectPrivate
 {
 public:
     inline QInputPanelPrivate()
-        : visible(false)
+        : visible(false), testContext(0)
     {}
+    QPlatformInputContext *platformInputContext() const
+    {
+        return testContext ? testContext : QGuiApplicationPrivate::platformIntegration()->inputContext();
+    }
+    static inline QInputPanelPrivate *get(QInputPanel *inputPanel)
+    {
+        return inputPanel->d_func();
+    }
+
     QTransform inputItemTransform;
     QWeakPointer<QObject> inputItem;
     bool visible;
+    QPlatformInputContext *testContext;
 };
 
 QT_END_NAMESPACE

tests/auto/gui/kernel/kernel.pro

@@ -4,6 +4,7 @@ SUBDIRS=\
    qdrag \
    qevent \
    qfileopenevent \
+   qinputpanel \
    qguivariant \
    qkeysequence \
    qmouseevent \

tests/auto/gui/kernel/qinputpanel/qinputpanel.pro

@@ -0,0 +1,3 @@
+load(qttest_p4)
+SOURCES  += tst_qinputpanel.cpp
+QT += core-private gui-private

tests/auto/gui/kernel/qinputpanel/tst_qinputpanel.cpp

@@ -0,0 +1,301 @@
+/****************************************************************************
+**
+** 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 <QtTest/QtTest>
+
+#include <private/qguiapplication_p.h>
+#include <private/qinputpanel_p.h>
+#include <qplatforminputcontext_qpa.h>
+
+class PlatformInputContext : public QPlatformInputContext
+{
+public:
+    PlatformInputContext() :
+        m_animating(false),
+        m_updateCallCount(0),
+        m_resetCallCount(0),
+        m_commitCallCount(0),
+        m_lastQueries(Qt::ImhNone),
+        m_action(QInputPanel::Click),
+        m_cursorPosition(0),
+        m_lastEventType(QEvent::None)
+    {}
+
+    virtual QRectF keyboardRect() const { return m_keyboardRect; }
+    virtual bool isAnimating() { return m_animating; }
+    virtual void reset() { m_resetCallCount++; }
+    virtual void commit() { m_commitCallCount++; }
+
+    virtual void update(Qt::InputMethodQueries queries)
+    {
+        m_updateCallCount++;
+        m_lastQueries = queries;
+    }
+    virtual void invokeAction(QInputPanel::Action action, int cursorPosition)
+    {
+        m_action = action;
+        m_cursorPosition = cursorPosition;
+    }
+    virtual bool filterEvent(const QEvent *event)
+    {
+        m_lastEventType = event->type(); return false;
+    }
+
+    bool m_animating;
+    int m_updateCallCount;
+    int m_resetCallCount;
+    int m_commitCallCount;
+    Qt::InputMethodQueries m_lastQueries;
+    QInputPanel::Action m_action;
+    int m_cursorPosition;
+    int m_lastEventType;
+    QRectF m_keyboardRect;
+};
+
+class InputItem : public QObject
+{
+    Q_OBJECT
+public:
+    bool event(QEvent *event)
+    {
+        if (event->type() == QEvent::InputMethodQuery) {
+            QInputMethodQueryEvent *query = static_cast<QInputMethodQueryEvent *>(event);
+            if (query->queries() & Qt::ImCursorRectangle)
+                query->setValue(Qt::ImCursorRectangle, QRectF(1, 2, 3, 4));
+            if (query->queries() & Qt::ImPreferredLanguage)
+                query->setValue(Qt::ImPreferredLanguage, QString("English"));
+            m_lastQueries = query->queries();
+            query->accept();
+            return true;
+        }
+        return false;
+    }
+    Qt::InputMethodQueries m_lastQueries;
+};
+
+class tst_qinputpanel : public QObject
+{
+    Q_OBJECT
+public:
+    tst_qinputpanel() {}
+    virtual ~tst_qinputpanel() {}
+private slots:
+    void initTestCase();
+    void visible();
+    void animating();
+    void keyboarRectangle();
+    void inputItem();
+    void inputItemTransform();
+    void cursorRectangle();
+    void invokeAction();
+    void reset();
+    void commit();
+    void update();
+    void query();
+private:
+    InputItem m_inputItem;
+    PlatformInputContext m_platformInputContext;
+};
+
+void tst_qinputpanel::initTestCase()
+{
+    QInputPanelPrivate *inputPanelPrivate = QInputPanelPrivate::get(qApp->inputPanel());
+    inputPanelPrivate->testContext = &m_platformInputContext;
+}
+
+void tst_qinputpanel::visible()
+{
+    qApp->inputPanel()->show();
+    QCOMPARE(qApp->inputPanel()->visible(), true);
+
+    qApp->inputPanel()->hide();
+    QCOMPARE(qApp->inputPanel()->visible(), false);
+
+    qApp->inputPanel()->setVisible(true);
+    QCOMPARE(qApp->inputPanel()->visible(), true);
+
+    qApp->inputPanel()->setVisible(false);
+    QCOMPARE(qApp->inputPanel()->visible(), false);
+}
+
+void tst_qinputpanel::animating()
+{
+    QCOMPARE(qApp->inputPanel()->isAnimating(), false);
+
+    m_platformInputContext.m_animating = true;
+    QCOMPARE(qApp->inputPanel()->isAnimating(), true);
+
+    m_platformInputContext.m_animating = false;
+    QCOMPARE(qApp->inputPanel()->isAnimating(), false);
+
+    QSignalSpy spy(qApp->inputPanel(), SIGNAL(animatingChanged()));
+    m_platformInputContext.emitAnimatingChanged();
+    QCOMPARE(spy.count(), 1);
+}
+
+void tst_qinputpanel::keyboarRectangle()
+{
+    QCOMPARE(qApp->inputPanel()->keyboardRectangle(), QRectF());
+
+    m_platformInputContext.m_keyboardRect = QRectF(10, 20, 30, 40);
+    QCOMPARE(qApp->inputPanel()->keyboardRectangle(), QRectF(10, 20, 30, 40));
+
+    QSignalSpy spy(qApp->inputPanel(), SIGNAL(keyboardRectangleChanged()));
+    m_platformInputContext.emitKeyboardRectChanged();
+    QCOMPARE(spy.count(), 1);
+}
+
+void tst_qinputpanel::inputItem()
+{
+    QVERIFY(!qApp->inputPanel()->inputItem());
+    QSignalSpy spy(qApp->inputPanel(), SIGNAL(inputItemChanged()));
+
+    qApp->inputPanel()->setInputItem(&m_inputItem);
+
+    QCOMPARE(qApp->inputPanel()->inputItem(), &m_inputItem);
+    QCOMPARE(spy.count(), 1);
+
+    // reset
+    qApp->inputPanel()->setInputItem(0);
+}
+
+void tst_qinputpanel::inputItemTransform()
+{
+    QCOMPARE(qApp->inputPanel()->inputItemTransform(), QTransform());
+    QSignalSpy spy(qApp->inputPanel(), SIGNAL(cursorRectangleChanged()));
+
+    QTransform transform;
+    transform.translate(10, 10);
+    transform.scale(2, 2);
+    transform.shear(2, 2);
+    qApp->inputPanel()->setInputItemTransform(transform);
+
+    QCOMPARE(qApp->inputPanel()->inputItemTransform(), transform);
+    QCOMPARE(spy.count(), 1);
+
+    // reset
+    qApp->inputPanel()->setInputItemTransform(QTransform());
+}
+
+void tst_qinputpanel::cursorRectangle()
+{
+    QCOMPARE(qApp->inputPanel()->cursorRectangle(), QRectF());
+
+    QTransform transform;
+    transform.translate(10, 10);
+    transform.scale(2, 2);
+    transform.shear(2, 2);
+    qApp->inputPanel()->setInputItemTransform(transform);
+    qApp->inputPanel()->setInputItem(&m_inputItem);
+
+    QCOMPARE(qApp->inputPanel()->cursorRectangle(), transform.mapRect(QRectF(1, 2, 3, 4)));
+
+    // reset
+    qApp->inputPanel()->setInputItem(0);
+    qApp->inputPanel()->setInputItemTransform(QTransform());
+}
+
+void tst_qinputpanel::invokeAction()
+{
+    QCOMPARE(m_platformInputContext.m_action, QInputPanel::Click);
+    QCOMPARE(m_platformInputContext.m_cursorPosition, 0);
+
+    qApp->inputPanel()->invokeAction(QInputPanel::ContextMenu, 5);
+    QCOMPARE(m_platformInputContext.m_action, QInputPanel::ContextMenu);
+    QCOMPARE(m_platformInputContext.m_cursorPosition, 5);
+}
+
+void tst_qinputpanel::reset()
+{
+    QCOMPARE(m_platformInputContext.m_resetCallCount, 0);
+
+    qApp->inputPanel()->reset();
+    QCOMPARE(m_platformInputContext.m_resetCallCount, 1);
+
+    qApp->inputPanel()->reset();
+    QCOMPARE(m_platformInputContext.m_resetCallCount, 2);
+}
+
+void tst_qinputpanel::commit()
+{
+    QCOMPARE(m_platformInputContext.m_commitCallCount, 0);
+
+    qApp->inputPanel()->commit();
+    QCOMPARE(m_platformInputContext.m_commitCallCount, 1);
+
+    qApp->inputPanel()->commit();
+    QCOMPARE(m_platformInputContext.m_commitCallCount, 2);
+}
+
+void tst_qinputpanel::update()
+{
+    qApp->inputPanel()->setInputItem(&m_inputItem);
+    QCOMPARE(m_platformInputContext.m_updateCallCount, 0);
+    QCOMPARE(int(m_platformInputContext.m_lastQueries), int(Qt::ImhNone));
+
+    qApp->inputPanel()->update(Qt::ImQueryInput);
+    QCOMPARE(m_platformInputContext.m_updateCallCount, 1);
+    QCOMPARE(int(m_platformInputContext.m_lastQueries), int(Qt::ImQueryInput));
+
+    qApp->inputPanel()->update(Qt::ImQueryAll);
+    QCOMPARE(m_platformInputContext.m_updateCallCount, 2);
+    QCOMPARE(int(m_platformInputContext.m_lastQueries), int(Qt::ImQueryAll));
+
+    QCOMPARE(qApp->inputPanel()->keyboardRectangle(), QRectF(10, 20, 30, 40));
+
+    // reset
+    qApp->inputPanel()->setInputItem(0);
+}
+
+void tst_qinputpanel::query()
+{
+    QInputMethodQueryEvent query(Qt::InputMethodQueries(Qt::ImPreferredLanguage | Qt::ImCursorRectangle));
+    QGuiApplication::sendEvent(&m_inputItem, &query);
+
+    QString language = query.value(Qt::ImPreferredLanguage).toString();
+    QCOMPARE(language, QString("English"));
+
+    QRect cursorRectangle = query.value(Qt::ImCursorRectangle).toRect();
+    QCOMPARE(cursorRectangle, QRect(1,2,3,4));
+}
+
+QTEST_MAIN(tst_qinputpanel)
+#include "tst_qinputpanel.moc"