qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make QtQuickTest::mouseEvent use QTest::mouseX 

Fixes QQuickItem::isUnderMouse returning wrong information when
moving the mouse cursor with QtQuickTest::mouseX

Also changes TestCase.mouseDrag to actually resemble more what
real life does, i.e. send mouse moves with the same localPos
if the item has already moved and update tst_drag.qml accordingly

Change-Id: I80e4ab097da90d21ba987466c1b82467755a6b56
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
This commit is contained in:
Albert Astals Cid 2017-06-28 14:39:19 +02:00 committed by Shawn Rutledge
parent 457c5bcb14
commit 4c46dce8fd
7 changed files with 181 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/imports/testlib/TestCase.qml
View File

@ -1321,15 +1321,27 @@ Item {
if (ddy < (util.dragThreshold + 1))
ddy = 0
var originalX = item.x;
var originalY = item.y;
mousePress(item, x, y, button, modifiers, delay)
//trigger dragging
mouseMove(item, x + util.dragThreshold + 1, y + util.dragThreshold + 1, moveDelay, button)
// trigger dragging, this doesn't actually move the item yet
var triggerDragXPos = x + Math.min(util.dragThreshold + 1, dx);
var triggerDragYPos = y + Math.min(util.dragThreshold + 1, dy);
mouseMove(item, triggerDragXPos, triggerDragYPos, moveDelay, button)
if (ddx > 0 || ddy > 0) {
mouseMove(item, x + ddx, y + ddy, moveDelay, button)
mouseMove(item, x + 2*ddx, y + 2*ddy, moveDelay, button)
// move the item by ddx, ddy
mouseMove(item, triggerDragXPos + ddx, triggerDragYPos + ddy, moveDelay, button)
// move the item by ddx, ddy again
// need to account for whether the previous move actually moved the item or not
mouseMove(item, triggerDragXPos + 2*ddx - (item.x - originalX), triggerDragYPos + 2*ddy - (item.y - originalY), moveDelay, button)
}
mouseMove(item, x + dx, y + dy, moveDelay, button)
mouseRelease(item, x + dx, y + dy, button, modifiers, delay)
// Release, causes a final move
// need to account for whether the previous moves actually moved the item or not
mouseRelease(item, x + dx - (item.x - originalX), y + dy - (item.y - originalY), button, modifiers, delay)
}
/*!

40
src/qmltest/quicktestevent.cpp
View File

@ -39,6 +39,7 @@
#include "quicktestevent_p.h"
#include <QtTest/qtestkeyboard.h>
#include <QtTest/qtestmouse.h>
#include <QtQml/qqml.h>
#include <QtQuick/qquickitem.h>
#include <QtQuick/qquickwindow.h>
@ -125,8 +126,6 @@ namespace QtQuickTest
{
enum MouseAction { MousePress, MouseRelease, MouseClick, MouseDoubleClick, MouseMove, MouseDoubleClickSequence };
int lastMouseTimestamp = 0;
static void mouseEvent(MouseAction action, QWindow *window,
QObject *item, Qt::MouseButton button,
Qt::KeyboardModifiers stateKey, const QPointF &_pos, int delay=-1)
@ -138,7 +137,7 @@ namespace QtQuickTest
delay = QTest::defaultMouseDelay();
if (delay > 0) {
QTest::qWait(delay);
lastMouseTimestamp += delay;
QTest::lastMouseTimestamp += delay;
}
if (action == MouseClick) {
@ -165,37 +164,32 @@ namespace QtQuickTest
stateKey &= static_cast<unsigned int>(Qt::KeyboardModifierMask);
QMouseEvent me(QEvent::User, QPoint(), Qt::LeftButton, button, stateKey);
if (action == MouseDoubleClick) {
// the QWindow variant of QTest::mouseEvent doesn't have MouseDoubleClick as event
// its MouseDClick is actually like the MouseDoubleClickSequence here
QMouseEvent me(QEvent::MouseButtonDblClick, pos, window->mapToGlobal(pos), button, button, stateKey);
me.setTimestamp(++QTest::lastMouseTimestamp);
QSpontaneKeyEvent::setSpontaneous(&me);
if (!qApp->notify(window, &me)) {
QWARN("Mouse event \"MouseDoubleClick\" not accepted by receiving window");
}
return;
}
switch (action)
{
case MousePress:
me = QMouseEvent(QEvent::MouseButtonPress, pos, window->mapToGlobal(pos), button, button, stateKey);
me.setTimestamp(++lastMouseTimestamp);
QTest::mousePress(window, button, stateKey, pos, /*delay*/ 0);
break;
case MouseRelease:
me = QMouseEvent(QEvent::MouseButtonRelease, pos, window->mapToGlobal(pos), button, 0, stateKey);
me.setTimestamp(++lastMouseTimestamp);
lastMouseTimestamp += 500; // avoid double clicks being generated
break;
case MouseDoubleClick:
me = QMouseEvent(QEvent::MouseButtonDblClick, pos, window->mapToGlobal(pos), button, button, stateKey);
me.setTimestamp(++lastMouseTimestamp);
QTest::mouseRelease(window, button, stateKey, pos, /*delay*/ 0);
break;
case MouseMove:
// with move event the button is NoButton, but 'buttons' holds the currently pressed buttons
me = QMouseEvent(QEvent::MouseMove, pos, window->mapToGlobal(pos), Qt::NoButton, button, stateKey);
me.setTimestamp(++lastMouseTimestamp);
QTest::mouseMove(window, pos, /*delay*/ 0);
break;
default:
QTEST_ASSERT(false);
}
QSpontaneKeyEvent::setSpontaneous(&me);
if (!qApp->notify(window, &me)) {
static const char *mouseActionNames[] =
{ "MousePress", "MouseRelease", "MouseClick", "MouseDoubleClick", "MouseMove", "MouseDoubleClickSequence" };
QString warning = QString::fromLatin1("Mouse event \"%1\" not accepted by receiving window");
QWARN(warning.arg(QString::fromLatin1(mouseActionNames[static_cast<int>(action)])).toLatin1().data());
}
}
#if QT_CONFIG(wheelevent)

96
tests/auto/qmltest/events/tst_drag.qml
View File

@ -72,12 +72,14 @@ Rectangle{
height:100
color: "red"
property bool updatePositionWhileDragging: false
property var posX: 0
property var posY: 0
property double posX: 0
property double posY: 0
function reset() {
fakeHandle.x = 0
fakeHandle.y = 0
function reset(mouseX, mouseY) {
posX = mouseX;
posY = mouseY;
fakeHandle.x = mouseX;
fakeHandle.y = mouseY;
spyX.clear()
spyY.clear()
}
@ -116,52 +118,56 @@ Rectangle{
TestCase {
name:"mouserelease"
when:windowShown
function test_mouseDrag() {
mouseDrag(container, 10, 10, util.dragThreshold * 2, util.dragThreshold * 3);
compare(container.x, util.dragThreshold - 1);
compare(container.y, util.dragThreshold * 2 - 1);
function test_mouseDrag_data() {
return [
{ tag: "short", dx: 20, dy: 30 },
{ tag: "long", dx: 70, dy: 60 },
{ tag: "longshort", dx: 70, dy: 20 },
{ tag: "shortlong", dx: 20, dy: 70 }
];
}
function test_doSomethingWhileDragging() {
container2.updatePositionWhileDragging = false
// dx and dy are superior to 3 times util.dragThreshold.
// but here the dragging does not update posX and posY
// posX and posY are only updated on mouseRelease
container2.reset()
mouseDrag(container2, container2.x + 10, container2.y + 10, 10*util.dragThreshold, 10*util.dragThreshold);
compare(spyX.count, 1)
compare(spyY.count, 1)
function test_mouseDrag(data) {
container.x = 0;
container.y = 0;
mouseDrag(container, 10, 10, data.dx, data.dy);
compare(container.x, data.dx - util.dragThreshold - 1);
compare(container.y, data.dy - util.dragThreshold - 1);
}
container2.updatePositionWhileDragging = true
// dx and dy are superior to 3 times util.dragThreshold.
// 3 intermediate mouseMove when dragging
container2.reset()
mouseDrag(container2, container2.x + 10, container2.y + 10, 10*util.dragThreshold, 10*util.dragThreshold);
compare(spyX.count, 3)
compare(spyY.count, 3)
function test_doSomethingInsteadOfDragging_data() {
return [
{ tag: "short", updatePositionWhileDragging: false, dx: 2*util.dragThreshold, dy: 2*util.dragThreshold },
{ tag: "long", updatePositionWhileDragging: false, dx: 10*util.dragThreshold, dy: 10*util.dragThreshold },
{ tag: "nothing_short", updatePositionWhileDragging: false, dx: 0, dy: 2*util.dragThreshold },
{ tag: "long_nothing", updatePositionWhileDragging: false, dx: 10*util.dragThreshold, dy: 0 },
{ tag: "short_update", updatePositionWhileDragging: true, dx: 2*util.dragThreshold, dy: 2*util.dragThreshold },
{ tag: "long_update", updatePositionWhileDragging: true, dx: 10*util.dragThreshold, dy: 10*util.dragThreshold },
{ tag: "nothing_short_up", updatePositionWhileDragging: true, dx: 0, dy: 2*util.dragThreshold },
{ tag: "long_nothing_up", updatePositionWhileDragging: true, dx: 10*util.dragThreshold, dy: 0 },
];
}
// dx and dy are inferior to 3 times util.dragThreshold.
// No intermediate mouseMove when dragging, only one mouseMove
container2.reset()
mouseDrag(container2, container2.x + 10, container2.y + 10, 2*util.dragThreshold, 2*util.dragThreshold);
compare(spyX.count, 1)
compare(spyY.count, 1)
function test_doSomethingInsteadOfDragging(data) {
var expectedSpyCountX;
var expectedSpyCountY;
// dx is superior to 3 times util.dragThreshold.
// 3 intermediate mouseMove when dragging on x axis
// no move on the y axis
container2.reset()
mouseDrag(container2, container2.x + 10, container2.y + 10, 10*util.dragThreshold, 0);
compare(spyX.count, 3)
compare(spyY.count, 0)
if (!data.updatePositionWhileDragging) {
expectedSpyCountX = data.dx > util.dragThreshold ? 1 : 0;
expectedSpyCountY = data.dy > util.dragThreshold ? 1 : 0;
} else {
expectedSpyCountX = data.dx > util.dragThreshold * 3 ? 3 :
(data.dx > util.dragThreshold ? 1 : 0);
expectedSpyCountY = data.dy > util.dragThreshold * 3 ? 3 :
(data.dy > util.dragThreshold ? 1 : 0);
}
// dy is inferior to 3 times util.dragThreshold.
// No intermediate mouseMove when dragging, only one mouseMove on y axis
// no move on the x axis
container2.reset()
mouseDrag(container2, container2.x + 10, container2.y + 10, 0, 2*util.dragThreshold);
compare(spyX.count, 0)
compare(spyY.count, 1)
container2.updatePositionWhileDragging = data.updatePositionWhileDragging;
container2.reset(container2.x + 10, container2.y + 10);
mouseDrag(container2, container2.x + 10, container2.y + 10, data.dx, data.dy);
compare(spyX.count, expectedSpyCountX)
compare(spyY.count, expectedSpyCountY)
}
}
}

5
tests/auto/qmltest/events/tst_events.qml
View File

@ -59,9 +59,10 @@ Rectangle {
Window {
id: sub
visible: true
visible: false
property bool clicked: false
MouseArea {
id: subMouseArea
anchors.fill: parent
onClicked: sub.clicked = true
}
@ -101,6 +102,8 @@ Rectangle {
}
function test_mouse_click_subwindow() {
sub.visible = true;
waitForRendering(subMouseArea); // Since we don't have a waitForWindowShown
mouseClick(sub)
tryCompare(sub, "clicked", true, 10000)
}

3
tests/auto/quicktest/quicktest.pro
View File

@ -1,3 +1,4 @@
TEMPLATE = subdirs
SUBDIRS = \
signalspy
signalspy \
testevent

8
tests/auto/quicktest/testevent/testevent.pro Normal file
View File

@ -0,0 +1,8 @@
CONFIG += testcase
TARGET = tst_testevent
macos:CONFIG -= app_bundle
SOURCES += tst_testevent.cpp
QT += quick testlib qmltest-private
include (../../shared/util.pri)

81
tests/auto/quicktest/testevent/tst_testevent.cpp Normal file
View File

@ -0,0 +1,81 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qtest.h>
#include <QtQuick/qquickitem.h>
#include <QtQuick/qquickwindow.h>
#include "QtQuickTest/private/quicktestevent_p.h"
class tst_testevent : public QObject
{
Q_OBJECT
public:
private slots:
void moveSetsQuickItemIsUnderMouse();
};
void tst_testevent::moveSetsQuickItemIsUnderMouse()
{
QQuickWindow w;
w.resize(400, 400);
w.show();
w.requestActivate();
QTest::qWaitForWindowActive(&w);
QTRY_COMPARE(QGuiApplication::focusWindow(), &w);
QQuickItem *item = new QQuickItem(w.contentItem());
item->setX(0);
item->setY(0);
item->setWidth(100);
item->setHeight(100);
QQuickItem *item2 = new QQuickItem(w.contentItem());
item2->setX(100);
item2->setY(100);
item2->setWidth(100);
item2->setHeight(100);
QuickTestEvent te;
te.mouseMove(w.contentItem(), 10, 10, /*delay*/ -1, Qt::NoButton);
QVERIFY(item->isUnderMouse());
QVERIFY(!item2->isUnderMouse());
te.mouseMove(w.contentItem(), 110, 110, /*delay*/ -1, Qt::NoButton);
QVERIFY(!item->isUnderMouse());
QVERIFY(item2->isUnderMouse());
}
QTEST_MAIN(tst_testevent)
#include "tst_testevent.moc"