qtestsupport_gui.cpp

Go to the documentation of this file.

// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include <private/qguiapplication_p.h>
#include <private/qeventpoint_p.h>
 
#include <qpa/qplatformintegration.h>
#include <qpa/qwindowsysteminterface.h>
 
#include "qtestsupport_gui.h"
#include "qwindow.h"
 
#include <QtCore/qtestsupport_core.h>
#include <QtCore/qthread.h>
#include <QtCore/QDebug>
 
#if QT_CONFIG(test_gui)
#include <QtCore/qloggingcategory.h>
#include <private/qinputdevicemanager_p.h>
#include <private/qeventpoint_p.h>
#include <private/qhighdpiscaling_p.h>
#endif // #if QT_CONFIG(test_gui)
 
QT_BEGIN_NAMESPACE
 
/*!
    \since 5.0
    \overload
 
    The \a timeout is in milliseconds.
*/
bool QTest::qWaitForWindowActive(QWindow *window, int timeout)
{
    return qWaitForWindowActive(window, QDeadlineTimer{timeout, Qt::TimerType::PreciseTimer});
}
 
/*!
    \since 6.10
 
    Returns \c true, if \a window is active within \a timeout. Otherwise returns \c false.
 
    The method is useful in tests that call QWindow::show() and rely on the window actually being
    active (i.e. being visible and having focus) before proceeding.
 
    \note  The method will time out and return \c false if another window prevents \a window from
    becoming active.
 
    \note Since focus is an exclusive property, \a window may loose its focus to another window at
    any time - even after the method has returned \c true.
 
    \sa qWaitForWindowExposed(), qWaitForWindowFocused(), QWindow::isActive()
*/
bool QTest::qWaitForWindowActive(QWindow *window, QDeadlineTimer timeout)
{
    using Internal::WaitForResult;
    if (Q_UNLIKELY(!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::WindowActivation))) {
        qWarning() << "qWaitForWindowActive was called on a platform that doesn't support window"
                   << "activation. This means there is an error in the test and it should either"
                   << "check for the WindowActivation platform capability before calling"
                   << "qWaitForWindowActivate, use qWaitForWindowExposed instead, or skip the test."
                   << "Falling back to qWaitForWindowExposed.";
        return qWaitForWindowExposed(window, timeout);
    }
    return QTest::qWaitFor([wp = QPointer(window)]() {
        if (QWindow *w = wp.data(); !w)
            return WaitForResult::Failed;
        else
            return w->isActive() ? WaitForResult::Done : WaitForResult::NotYet;
    }, timeout);
}
 
/*!
    \since 6.10
    \overload
 
    This function uses the default timeout of 5 seconds.
*/
bool QTest::qWaitForWindowActive(QWindow *window)
{
    return qWaitForWindowActive(window, defaultTryTimeout.load(std::memory_order_relaxed));
}
 
/*!
    \since 6.7
 
    Returns \c true, if \a window is the focus window within \a timeout. Otherwise returns \c false.
 
    The method is useful in tests that call QWindow::show() and rely on the window
    having focus (for receiving keyboard events e.g.) before proceeding.
 
    \note  The method will time out and return \c false if another window prevents \a window from
    becoming focused.
 
    \note Since focus is an exclusive property, \a window may loose its focus to another window at
    any time - even after the method has returned \c true.
 
    \sa qWaitForWindowExposed(), qWaitForWindowActive(), QGuiApplication::focusWindow()
*/
Q_GUI_EXPORT bool QTest::qWaitForWindowFocused(QWindow *window, QDeadlineTimer timeout)
{
    using Internal::WaitForResult;
    return QTest::qWaitFor([wp = QPointer(window)]() {
        if (QWindow *w = wp.data(); !w)
            return WaitForResult::Failed;
        else
            return qGuiApp->focusWindow() == w ? WaitForResult::Done : WaitForResult::NotYet;
    }, timeout);
}
 
/*!
    \since 6.10
    \overload
 
    This function uses the default timeout of 5 seconds.
*/
bool QTest::qWaitForWindowFocused(QWindow *window)
{
    return qWaitForWindowFocused(window, defaultTryTimeout.load(std::memory_order_relaxed));
}
 
/*!
    \since 5.0
    \overload
 
    The \a timeout is in milliseconds.
*/
bool QTest::qWaitForWindowExposed(QWindow *window, int timeout)
{
    return qWaitForWindowExposed(window, std::chrono::milliseconds(timeout));
}
 
/*!
    \since 6.10
 
    Returns \c true, if \a window is exposed within \a timeout. Otherwise returns \c false.
 
    The method is useful in tests that call QWindow::show() and rely on the window actually being
    being visible before proceeding.
 
    \note A window mapped to screen may still not be considered exposed, if the window client area is
    not visible, e.g. because it is completely covered by other windows.
    In such cases, the method will time out and return \c false.
 
    \sa qWaitForWindowActive(), QWindow::isExposed()
*/
bool QTest::qWaitForWindowExposed(QWindow *window, QDeadlineTimer timeout)
{
    using Internal::WaitForResult;
    return QTest::qWaitFor([wp = QPointer(window)]() {
        if (QWindow *w = wp.data(); !w)
            return WaitForResult::Failed;
        else
            return w->isExposed() ? WaitForResult::Done : WaitForResult::NotYet;
    }, timeout);
}
 
/*!
    \since 6.10
    \overload
 
    This function uses the default timeout of 5 seconds.
*/
bool QTest::qWaitForWindowExposed(QWindow *window)
{
    return qWaitForWindowExposed(window, defaultTryTimeout.load(std::memory_order_relaxed));
}
 
namespace QTest {
 
QTouchEventSequence::~QTouchEventSequence()
{
    if (commitWhenDestroyed)
        QTouchEventSequence::commit();
}
QTouchEventSequence& QTouchEventSequence::press(int touchId, const QPoint &pt, QWindow *window)
{
    auto &p = point(touchId);
    QMutableEventPoint::setGlobalPosition(p, mapToScreen(window, pt));
    QMutableEventPoint::setState(p, QEventPoint::State::Pressed);
    return *this;
}
QTouchEventSequence& QTouchEventSequence::move(int touchId, const QPoint &pt, QWindow *window)
{
    auto &p = point(touchId);
    QMutableEventPoint::setGlobalPosition(p, mapToScreen(window, pt));
    QMutableEventPoint::setState(p, QEventPoint::State::Updated);
    return *this;
}
QTouchEventSequence& QTouchEventSequence::release(int touchId, const QPoint &pt, QWindow *window)
{
    auto &p = point(touchId);
    QMutableEventPoint::setGlobalPosition(p, mapToScreen(window, pt));
    QMutableEventPoint::setState(p, QEventPoint::State::Released);
    return *this;
}
QTouchEventSequence& QTouchEventSequence::stationary(int touchId)
{
    auto &p = pointOrPreviousPoint(touchId);
    QMutableEventPoint::setState(p, QEventPoint::State::Stationary);
    return *this;
}
 
bool QTouchEventSequence::cancel(bool processEvents)
{
    bool ret = false;
    if (targetWindow) {
        QThread::sleep(std::chrono::milliseconds{1});
        ret = QWindowSystemInterface::handleTouchCancelEvent<
            QWindowSystemInterface::SynchronousDelivery>(targetWindow, device);
        if (processEvents)
            QCoreApplication::processEvents();
    }
    // A TouchCancel can only be followed by a TouchBegin, so start over.
    previousPoints.clear();
    points.clear();
    return ret;
}
 
bool QTouchEventSequence::commit(bool processEvents)
{
    if (points.isEmpty())
        return false;
    QThread::sleep(std::chrono::milliseconds{1});
    bool ret = false;
    if (targetWindow)
        ret = qt_handleTouchEventv2(targetWindow, device, points.values());
    if (processEvents)
        QCoreApplication::processEvents();
    previousPoints = points;
    points.clear();
    return ret;
}
 
QTouchEventSequence::QTouchEventSequence(QWindow *window, QPointingDevice *aDevice, bool autoCommit)
    : targetWindow(window), device(aDevice), commitWhenDestroyed(autoCommit)
{
}
 
QPointF QTouchEventSequence::mapToScreen(QWindow *window, const QPoint &pt)
{
    if (window)
        return window->mapToGlobal(QPointF(pt));
    return targetWindow ? targetWindow->mapToGlobal(QPointF(pt)) : QPointF(pt);
}
 
QEventPoint &QTouchEventSequence::point(int touchId)
{
    if (!points.contains(touchId))
        points[touchId] = QEventPoint(touchId);
    return points[touchId];
}
 
QEventPoint &QTouchEventSequence::pointOrPreviousPoint(int touchId)
{
    if (!points.contains(touchId)) {
        if (previousPoints.contains(touchId))
            points[touchId] = previousPoints.value(touchId);
        else
            points[touchId] = QEventPoint(touchId);
    }
    return points[touchId];
}
 
} // namespace QTest
 
//
//  W A R N I N G
//  -------------
//
// The QtGuiTest namespace is not part of the Qt API.  It exists purely as an
// implementation detail.  It may change from version to version without notice,
// or even be removed.
//
// We mean it.
//
#if QT_CONFIG(test_gui)
Q_STATIC_LOGGING_CATEGORY(lcQtGuiTest, "qt.gui.test");
#define deb qCDebug(lcQtGuiTest)
 
/*!
   \internal
   \return the application's input device manager.
   \return nullptr and log error, if the application hasn't been initialized.
 */
static QInputDeviceManager *inputDeviceManager()
{
    if (auto *idm = QGuiApplicationPrivate::inputDeviceManager())
        return idm;
 
    deb << "No input device manager present.";
    return nullptr;
}
 
/*!
   \internal
   Synthesize keyboard modifier action by passing \a modifiers
   to the application's input device manager.
 */
void QtGuiTest::setKeyboardModifiers(Qt::KeyboardModifiers modifiers)
{
    auto *idm = inputDeviceManager();
    if (Q_UNLIKELY(!idm))
        return;
 
    idm->setKeyboardModifiers(modifiers);
    deb << "Keyboard modifiers synthesized:" << modifiers;
}
 
/*!
   \internal
   Synthesize user-initiated mouse positioning by passing \a position
   to the application's input device manager.
 */
void QtGuiTest::setCursorPosition(const QPoint &position)
{
    auto *idm = inputDeviceManager();
    if (Q_UNLIKELY(!idm))
        return;
 
    idm->setCursorPos(position);
    deb << "Mouse curser set to" << position;
}
 
/*!
   \internal
   Synthesize an extended \a key event of \a type, with \a modifiers, \a nativeScanCode,
   \a nativeVirtualKey and \a text on application level.
   Log whether the synthesizing has been successful.
 
   \note
   The application is expected to propagate the extended key event to its focus window,
   if one exists.
 */
void QtGuiTest::synthesizeExtendedKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers,
                                                  quint32 nativeScanCode, quint32 nativeVirtualKey,
                                                  const QString &text)
{
    Q_ASSERT_X((type == QEvent::KeyPress
                || type == QEvent::KeyRelease),
               Q_FUNC_INFO,
               "called with invalid QEvent type");
 
    deb << "Synthesizing key event:" << type << Qt::Key(key) << modifiers << text;
 
    if (QWindowSystemInterface::handleExtendedKeyEvent(nullptr, type, key, modifiers,
                                                       nativeScanCode, nativeVirtualKey,
                                                       modifiers, text, /* autorep = */ false,
                                                       /* count = */ 0)) {
 
        // If the key event is a shortcut, it may cause other events to be posted.
        // => process those.
        QCoreApplication::sendPostedEvents();
        deb << "(success)";
    } else {
        deb << "(failure)";
    }
}
 
/*!
   \internal
   Synthesize a key event \a k of type \a t, with modifiers \a mods, \a text,
   \a autorep and \a count on application level.
   Log whether the synthesizing has been successful.
 
   \note
   The application is expected to propagate the key event to its focus window,
   if one exists.
 */
bool QtGuiTest::synthesizeKeyEvent(QWindow *window, QEvent::Type t, int k, Qt::KeyboardModifiers mods,
                                          const QString & text, bool autorep,
                                          ushort count)
{
    Q_ASSERT_X((t == QEvent::KeyPress
                || t == QEvent::KeyRelease),
               Q_FUNC_INFO,
               "called with invalid QEvent type");
 
    deb << "Synthesizing key event:" << t << Qt::Key(k) << mods << text;
 
    bool result = QWindowSystemInterface::handleKeyEvent(window, t, k, mods, text, autorep, count);
    if (result) {
        // If the key event is a shortcut, it may cause other events to be posted.
        // => process those.
        QCoreApplication::sendPostedEvents();
        deb << "(success)";
    } else {
        deb << "(failure)";
    }
 
    return result;
}
 
/*!
   \internal
   Synthesize a mouse event of \a type, with \a button at \a position at application level.
   Respect \a state and \a modifiers.
 
   The application is expected to
   \list
   \li propagate the mouse event to its focus window,
       if one exists.
   \li convert a click/release squence into a double click.
   \endlist
 
   \note
   QEvent::MouseButtonDoubleClick can't be explicitly synthesized.
 */
void QtGuiTest::synthesizeMouseEvent(const QPointF &position, Qt::MouseButtons state,
                                        Qt::MouseButton button, QEvent::Type type,
                                        Qt::KeyboardModifiers modifiers)
{
    Q_ASSERT_X((type == QEvent::MouseButtonPress
                || type == QEvent::MouseButtonRelease
                || type == QEvent::MouseMove),
               Q_FUNC_INFO,
               "called with invalid QEvent type");
 
    deb << "Synthesizing mouse event:" << type << position << button << modifiers;
 
    if (QWindowSystemInterface::handleMouseEvent(nullptr, position, position, state, button,
                                                 type, modifiers, Qt::MouseEventNotSynthesized)) {
        // If the mouse event reacts to a shortcut, it may cause other events to be posted.
        // => process those.
        QCoreApplication::processEvents();
        QCoreApplication::sendPostedEvents();
 
        deb << "(success)";
    } else {
        deb << "(failure)";
    }
}
 
/*!
   \internal
   Synthesize a wheel event with \a modifiers and \a rollCount representing the number of
   roll unit on application level.
 
   \note
   The application is expected to handle the wheel event, or propagate it
   to its focus window, if one exists.
 */
void QtGuiTest::synthesizeWheelEvent(int rollCount, Qt::KeyboardModifiers modifiers)
{
    deb << "Synthesizing wheel event:" << rollCount << modifiers;
 
    QPoint position = QCursor::pos();
    if (QWindowSystemInterface::handleWheelEvent(nullptr, position, position,
                                                 QPoint(), QPoint(0, -rollCount), modifiers)) {
 
        // It's unlikely that a shortcut relates to a subsequent wheel event.
        // But it's not harmful, to send posted events here.
        QCoreApplication::sendPostedEvents();
        deb << "(success)";
    } else {
        deb << "(failure)";
    }
}
 
/*!
   \internal
   \return the number of milliseconds since the QElapsedTimer
   eventTime was last started.
*/
qint64 QtGuiTest::eventTimeElapsed()
{
    return QWindowSystemInterfacePrivate::eventTime.elapsed();
}
 
/*!
   \internal
   Post fake window activation with \a window representing the
   fake window being activated.
*/
void QtGuiTest::postFakeWindowActivation(QWindow *window)
{
    Q_ASSERT_X(window,
               Q_FUNC_INFO,
               "called with nullptr");
 
    deb << "Posting fake window activation:" << window;
 
    QWindowSystemInterfacePrivate::FocusWindowEvent e(window, Qt::OtherFocusReason);
    QGuiApplicationPrivate::processWindowSystemEvent(&e);
    QWindowSystemInterface::handleFocusWindowChanged(window);
}
 
/*!
   \internal
   \return native \a window position from \a value.
*/
QPoint QtGuiTest::toNativePixels(const QPoint &value, const QWindow *window)
{
    Q_ASSERT_X(window,
               Q_FUNC_INFO,
               "called with nullptr");
 
    deb << "Calculating native pixels: " << value << window;
    return QHighDpi::toNativePixels<QPoint, QWindow>(value, window);
}
 
/*!
   \internal
   \return native \a window rectangle from \a value.
*/
QRect QtGuiTest::toNativePixels(const QRect &value, const QWindow *window)
{
    Q_ASSERT_X(window,
               Q_FUNC_INFO,
               "called with nullptr");
 
    deb << "Calculating native pixels: " << value << window;
    return QHighDpi::toNativePixels<QRect, QWindow>(value, window);
}
 
/*!
   \internal
   \return scaling factor of \a window relative to Qt.
*/
qreal QtGuiTest::scaleFactor(const QWindow *window)
{
    Q_ASSERT_X(window,
               Q_FUNC_INFO,
               "called with nullptr");
 
    deb << "Calculating scaling factor: " << window;
    return QHighDpiScaling::factor(window);
}
 
/*!
   \internal
   Set the id of \a p to \a arg.
*/
void QtGuiTest::setEventPointId(QEventPoint &p, int arg)
{
    QMutableEventPoint::setId(p, arg);
}
 
/*!
   \internal
   Set the pressure of \a p to \a arg.
*/
void QtGuiTest::setEventPointPressure(QEventPoint &p, qreal arg)
{
    QMutableEventPoint::setPressure(p, arg);
}
 
/*!
   \internal
   Set the state of \a p to \a arg.
*/
void QtGuiTest::setEventPointState(QEventPoint &p, QEventPoint::State arg)
{
    QMutableEventPoint::setState(p, arg);
}
 
/*!
   \internal
   Set the position of \a p to \a arg.
*/
void QtGuiTest::setEventPointPosition(QEventPoint &p, QPointF arg)
{
    QMutableEventPoint::setPosition(p, arg);
}
 
/*!
   \internal
   Set the global position of \a p to \a arg.
*/
void QtGuiTest::setEventPointGlobalPosition(QEventPoint &p, QPointF arg)
{
    QMutableEventPoint::setGlobalPosition(p, arg);
}
 
/*!
   \internal
   Set the scene position of \a p to \a arg.
*/
void QtGuiTest::setEventPointScenePosition(QEventPoint &p, QPointF arg)
{
    QMutableEventPoint::setScenePosition(p, arg);
}
 
/*!
   \internal
   Set the ellipse diameters of \a p to \a arg.
*/
void QtGuiTest::setEventPointEllipseDiameters(QEventPoint &p, QSizeF arg)
{
    QMutableEventPoint::setEllipseDiameters(p, arg);
}
 
/*!
   \internal
   Returns \c true, if the platform supports multiple windows,
   otherwise \c false;
*/
bool QtGuiTest::platformSupportsMultipleWindows()
{
    const auto *platformIntegration = QGuiApplicationPrivate::platformIntegration();
    return platformIntegration->hasCapability(QPlatformIntegration::Capability::MultipleWindows);
}
 
#undef deb
#endif // #if QT_CONFIG(test_gui)
QT_END_NAMESPACE