tests/auto/qtquick1/qdeclarativeflickable/tst_qdeclarativeflickable.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the test suite of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41 #include <qtest.h>
  42 #include <QtTest/QSignalSpy>
  43 #include <QtDeclarative/qdeclarativeengine.h>
  44 #include <QtDeclarative/qdeclarativecomponent.h>
  45 #include <QtQuick1/qdeclarativeview.h>
  46 #include <private/qdeclarativeflickable_p.h>
  47 #include <private/qdeclarativevaluetype_p.h>
  48 #include <QtWidgets/qgraphicswidget.h>
  49 #include <math.h>
  50 #include "../../../shared/util.h"
  51
  52 #ifdef Q_OS_SYMBIAN
  53 // In Symbian OS test data is located in applications private dir
  54 #define SRCDIR "."
  55 #endif
  56
  57 class tst_qdeclarativeflickable : public QObject
  58 {
  59     Q_OBJECT
  60 public:
  61     tst_qdeclarativeflickable();
  62
  63 private slots:
  64     void create();
  65     void horizontalViewportSize();
  66     void verticalViewportSize();
  67     void properties();
  68     void boundsBehavior();
  69     void maximumFlickVelocity();
  70     void flickDeceleration();
  71     void pressDelay();
  72     void disabledContent();
  73     void nestedPressDelay();
  74     void flickableDirection();
  75     void qgraphicswidget();
  76     void resizeContent();
  77     void returnToBounds();
  78     void testQtQuick11Attributes();
  79     void testQtQuick11Attributes_data();
  80     void wheel();
  81     void disabled();
  82
  83 private:
  84     QDeclarativeEngine engine;
  85
  86     template<typename T>
  87     T *findItem(QGraphicsObject *parent, const QString &objectName);
  88 };
  89
  90 tst_qdeclarativeflickable::tst_qdeclarativeflickable()
  91 {
  92 }
  93
  94 void tst_qdeclarativeflickable::create()
  95 {
  96     QDeclarativeEngine engine;
  97     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/flickable01.qml"));
  98     QDeclarative1Flickable *obj = qobject_cast<QDeclarative1Flickable*>(c.create());
  99
 100     QVERIFY(obj != 0);
 101     QCOMPARE(obj->isAtXBeginning(), true);
 102     QCOMPARE(obj->isAtXEnd(), false);
 103     QCOMPARE(obj->isAtYBeginning(), true);
 104     QCOMPARE(obj->isAtYEnd(), false);
 105     QCOMPARE(obj->contentX(), 0.);
 106     QCOMPARE(obj->contentY(), 0.);
 107
 108     QCOMPARE(obj->horizontalVelocity(), 0.);
 109     QCOMPARE(obj->verticalVelocity(), 0.);
 110
 111     QCOMPARE(obj->isInteractive(), true);
 112     QCOMPARE(obj->boundsBehavior(), QDeclarative1Flickable::DragAndOvershootBounds);
 113     QCOMPARE(obj->pressDelay(), 0);
 114     QCOMPARE(obj->maximumFlickVelocity(), 2500.);
 115
 116     delete obj;
 117 }
 118
 119 void tst_qdeclarativeflickable::horizontalViewportSize()
 120 {
 121     QDeclarativeEngine engine;
 122     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/flickable02.qml"));
 123     QDeclarative1Flickable *obj = qobject_cast<QDeclarative1Flickable*>(c.create());
 124
 125     QVERIFY(obj != 0);
 126     QCOMPARE(obj->contentWidth(), 800.);
 127     QCOMPARE(obj->contentHeight(), 300.);
 128     QCOMPARE(obj->isAtXBeginning(), true);
 129     QCOMPARE(obj->isAtXEnd(), false);
 130     QCOMPARE(obj->isAtYBeginning(), true);
 131     QCOMPARE(obj->isAtYEnd(), false);
 132
 133     delete obj;
 134 }
 135
 136 void tst_qdeclarativeflickable::verticalViewportSize()
 137 {
 138     QDeclarativeEngine engine;
 139     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/flickable03.qml"));
 140     QDeclarative1Flickable *obj = qobject_cast<QDeclarative1Flickable*>(c.create());
 141
 142     QVERIFY(obj != 0);
 143     QCOMPARE(obj->contentWidth(), 200.);
 144     QCOMPARE(obj->contentHeight(), 1200.);
 145     QCOMPARE(obj->isAtXBeginning(), true);
 146     QCOMPARE(obj->isAtXEnd(), false);
 147     QCOMPARE(obj->isAtYBeginning(), true);
 148     QCOMPARE(obj->isAtYEnd(), false);
 149
 150     delete obj;
 151 }
 152
 153 void tst_qdeclarativeflickable::properties()
 154 {
 155     QDeclarativeEngine engine;
 156     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/flickable04.qml"));
 157     QDeclarative1Flickable *obj = qobject_cast<QDeclarative1Flickable*>(c.create());
 158
 159     QVERIFY(obj != 0);
 160     QCOMPARE(obj->isInteractive(), false);
 161     QCOMPARE(obj->boundsBehavior(), QDeclarative1Flickable::StopAtBounds);
 162     QCOMPARE(obj->pressDelay(), 200);
 163     QCOMPARE(obj->maximumFlickVelocity(), 2000.);
 164
 165     QVERIFY(obj->property("ok").toBool() == false);
 166     QMetaObject::invokeMethod(obj, "check");
 167     QVERIFY(obj->property("ok").toBool() == true);
 168
 169     delete obj;
 170 }
 171
 172 void tst_qdeclarativeflickable::boundsBehavior()
 173 {
 174     QDeclarativeComponent component(&engine);
 175     component.setData("import QtQuick 1.0; Flickable { boundsBehavior: Flickable.StopAtBounds }", QUrl::fromLocalFile(""));
 176     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(component.create());
 177     QSignalSpy spy(flickable, SIGNAL(boundsBehaviorChanged()));
 178
 179     QVERIFY(flickable);
 180     QVERIFY(flickable->boundsBehavior() == QDeclarative1Flickable::StopAtBounds);
 181
 182     flickable->setBoundsBehavior(QDeclarative1Flickable::DragAndOvershootBounds);
 183     QVERIFY(flickable->boundsBehavior() == QDeclarative1Flickable::DragAndOvershootBounds);
 184     QCOMPARE(spy.count(),1);
 185     flickable->setBoundsBehavior(QDeclarative1Flickable::DragAndOvershootBounds);
 186     QCOMPARE(spy.count(),1);
 187
 188     flickable->setBoundsBehavior(QDeclarative1Flickable::DragOverBounds);
 189     QVERIFY(flickable->boundsBehavior() == QDeclarative1Flickable::DragOverBounds);
 190     QCOMPARE(spy.count(),2);
 191     flickable->setBoundsBehavior(QDeclarative1Flickable::DragOverBounds);
 192     QCOMPARE(spy.count(),2);
 193
 194     flickable->setBoundsBehavior(QDeclarative1Flickable::StopAtBounds);
 195     QVERIFY(flickable->boundsBehavior() == QDeclarative1Flickable::StopAtBounds);
 196     QCOMPARE(spy.count(),3);
 197     flickable->setBoundsBehavior(QDeclarative1Flickable::StopAtBounds);
 198     QCOMPARE(spy.count(),3);
 199 }
 200
 201 void tst_qdeclarativeflickable::maximumFlickVelocity()
 202 {
 203     QDeclarativeComponent component(&engine);
 204     component.setData("import QtQuick 1.0; Flickable { maximumFlickVelocity: 1.0; }", QUrl::fromLocalFile(""));
 205     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(component.create());
 206     QSignalSpy spy(flickable, SIGNAL(maximumFlickVelocityChanged()));
 207
 208     QVERIFY(flickable);
 209     QCOMPARE(flickable->maximumFlickVelocity(), 1.0);
 210
 211     flickable->setMaximumFlickVelocity(2.0);
 212     QCOMPARE(flickable->maximumFlickVelocity(), 2.0);
 213     QCOMPARE(spy.count(),1);
 214     flickable->setMaximumFlickVelocity(2.0);
 215     QCOMPARE(spy.count(),1);
 216 }
 217
 218 void tst_qdeclarativeflickable::flickDeceleration()
 219 {
 220     QDeclarativeComponent component(&engine);
 221     component.setData("import QtQuick 1.0; Flickable { flickDeceleration: 1.0; }", QUrl::fromLocalFile(""));
 222     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(component.create());
 223     QSignalSpy spy(flickable, SIGNAL(flickDecelerationChanged()));
 224
 225     QVERIFY(flickable);
 226     QCOMPARE(flickable->flickDeceleration(), 1.0);
 227
 228     flickable->setFlickDeceleration(2.0);
 229     QCOMPARE(flickable->flickDeceleration(), 2.0);
 230     QCOMPARE(spy.count(),1);
 231     flickable->setFlickDeceleration(2.0);
 232     QCOMPARE(spy.count(),1);
 233 }
 234
 235 void tst_qdeclarativeflickable::pressDelay()
 236 {
 237     QDeclarativeComponent component(&engine);
 238     component.setData("import QtQuick 1.0; Flickable { pressDelay: 100; }", QUrl::fromLocalFile(""));
 239     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(component.create());
 240     QSignalSpy spy(flickable, SIGNAL(pressDelayChanged()));
 241
 242     QVERIFY(flickable);
 243     QCOMPARE(flickable->pressDelay(), 100);
 244
 245     flickable->setPressDelay(200);
 246     QCOMPARE(flickable->pressDelay(), 200);
 247     QCOMPARE(spy.count(),1);
 248     flickable->setPressDelay(200);
 249     QCOMPARE(spy.count(),1);
 250 }
 251
 252 // QT-4677
 253 void tst_qdeclarativeflickable::disabledContent()
 254 {
 255     QDeclarativeView *canvas = new QDeclarativeView;
 256     canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/disabledcontent.qml"));
 257     canvas->show();
 258     canvas->setFocus();
 259     QVERIFY(canvas->rootObject() != 0);
 260
 261     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(canvas->rootObject());
 262     QVERIFY(flickable != 0);
 263
 264     QVERIFY(flickable->contentX() == 0);
 265     QVERIFY(flickable->contentY() == 0);
 266
 267     QTest::mousePress(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(50, 50)));
 268     {
 269         QMouseEvent mv(QEvent::MouseMove, canvas->mapFromScene(QPoint(70,70)), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
 270         QApplication::sendEvent(canvas->viewport(), &mv);
 271     }
 272     {
 273         QMouseEvent mv(QEvent::MouseMove, canvas->mapFromScene(QPoint(90,90)), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
 274         QApplication::sendEvent(canvas->viewport(), &mv);
 275     }
 276     {
 277         QMouseEvent mv(QEvent::MouseMove, canvas->mapFromScene(QPoint(100,100)), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
 278         QApplication::sendEvent(canvas->viewport(), &mv);
 279     }
 280
 281     QVERIFY(flickable->contentX() < 0);
 282     QVERIFY(flickable->contentY() < 0);
 283
 284     QTest::mouseRelease(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(90, 90)));
 285
 286     delete canvas;
 287 }
 288
 289
 290 // QTBUG-17361
 291 void tst_qdeclarativeflickable::nestedPressDelay()
 292 {
 293     QDeclarativeView *canvas = new QDeclarativeView;
 294     canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/nestedPressDelay.qml"));
 295     canvas->show();
 296     canvas->setFocus();
 297     QVERIFY(canvas->rootObject() != 0);
 298
 299     QDeclarative1Flickable *outer = qobject_cast<QDeclarative1Flickable*>(canvas->rootObject());
 300     QVERIFY(outer != 0);
 301
 302     QDeclarative1Flickable *inner = canvas->rootObject()->findChild<QDeclarative1Flickable*>("innerFlickable");
 303     QVERIFY(inner != 0);
 304
 305     QTest::mousePress(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(150, 150)));
 306     // the MouseArea is not pressed immediately
 307     QVERIFY(outer->property("pressed").toBool() == false);
 308
 309     // The outer pressDelay will prevail (50ms, vs. 10sec)
 310     // QTRY_VERIFY() has 5sec timeout, so will timeout well within 10sec.
 311     QTRY_VERIFY(outer->property("pressed").toBool() == true);
 312
 313     QTest::mouseRelease(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(150, 150)));
 314
 315     delete canvas;
 316 }
 317
 318 void tst_qdeclarativeflickable::flickableDirection()
 319 {
 320     QDeclarativeComponent component(&engine);
 321     component.setData("import QtQuick 1.0; Flickable { flickableDirection: Flickable.VerticalFlick; }", QUrl::fromLocalFile(""));
 322     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(component.create());
 323     QSignalSpy spy(flickable, SIGNAL(flickableDirectionChanged()));
 324
 325     QVERIFY(flickable);
 326     QCOMPARE(flickable->flickableDirection(), QDeclarative1Flickable::VerticalFlick);
 327
 328     flickable->setFlickableDirection(QDeclarative1Flickable::HorizontalAndVerticalFlick);
 329     QCOMPARE(flickable->flickableDirection(), QDeclarative1Flickable::HorizontalAndVerticalFlick);
 330     QCOMPARE(spy.count(),1);
 331
 332     flickable->setFlickableDirection(QDeclarative1Flickable::AutoFlickDirection);
 333     QCOMPARE(flickable->flickableDirection(), QDeclarative1Flickable::AutoFlickDirection);
 334     QCOMPARE(spy.count(),2);
 335
 336     flickable->setFlickableDirection(QDeclarative1Flickable::HorizontalFlick);
 337     QCOMPARE(flickable->flickableDirection(), QDeclarative1Flickable::HorizontalFlick);
 338     QCOMPARE(spy.count(),3);
 339
 340     flickable->setFlickableDirection(QDeclarative1Flickable::HorizontalFlick);
 341     QCOMPARE(flickable->flickableDirection(), QDeclarative1Flickable::HorizontalFlick);
 342     QCOMPARE(spy.count(),3);
 343 }
 344
 345 void tst_qdeclarativeflickable::qgraphicswidget()
 346 {
 347     QDeclarativeEngine engine;
 348     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/flickableqgraphicswidget.qml"));
 349     QDeclarative1Flickable *flickable = qobject_cast<QDeclarative1Flickable*>(c.create());
 350
 351     QVERIFY(flickable != 0);
 352     QGraphicsWidget *widget = findItem<QGraphicsWidget>(flickable->contentItem(), "widget1");
 353     QVERIFY(widget);
 354 }
 355
 356 // QtQuick 1.1
 357 void tst_qdeclarativeflickable::resizeContent()
 358 {
 359     QDeclarativeEngine engine;
 360     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/resize.qml"));
 361     QDeclarativeItem *root = qobject_cast<QDeclarativeItem*>(c.create());
 362     QDeclarative1Flickable *obj = findItem<QDeclarative1Flickable>(root, "flick");
 363
 364     QVERIFY(obj != 0);
 365     QCOMPARE(obj->contentX(), 0.);
 366     QCOMPARE(obj->contentY(), 0.);
 367     QCOMPARE(obj->contentWidth(), 300.);
 368     QCOMPARE(obj->contentHeight(), 300.);
 369
 370     QMetaObject::invokeMethod(root, "resizeContent");
 371
 372     QCOMPARE(obj->contentX(), 100.);
 373     QCOMPARE(obj->contentY(), 100.);
 374     QCOMPARE(obj->contentWidth(), 600.);
 375     QCOMPARE(obj->contentHeight(), 600.);
 376
 377     delete root;
 378 }
 379
 380 // QtQuick 1.1
 381 void tst_qdeclarativeflickable::returnToBounds()
 382 {
 383     QDeclarativeEngine engine;
 384     QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/resize.qml"));
 385     QDeclarativeItem *root = qobject_cast<QDeclarativeItem*>(c.create());
 386     QDeclarative1Flickable *obj = findItem<QDeclarative1Flickable>(root, "flick");
 387
 388     QVERIFY(obj != 0);
 389     QCOMPARE(obj->contentX(), 0.);
 390     QCOMPARE(obj->contentY(), 0.);
 391     QCOMPARE(obj->contentWidth(), 300.);
 392     QCOMPARE(obj->contentHeight(), 300.);
 393
 394     obj->setContentX(100);
 395     obj->setContentY(400);
 396     QTRY_COMPARE(obj->contentX(), 100.);
 397     QTRY_COMPARE(obj->contentY(), 400.);
 398
 399     QMetaObject::invokeMethod(root, "returnToBounds");
 400
 401     QTRY_COMPARE(obj->contentX(), 0.);
 402     QTRY_COMPARE(obj->contentY(), 0.);
 403
 404     delete root;
 405 }
 406
 407 void tst_qdeclarativeflickable::testQtQuick11Attributes()
 408 {
 409     QFETCH(QString, code);
 410     QFETCH(QString, warning);
 411     QFETCH(QString, error);
 412
 413     QDeclarativeEngine engine;
 414     QObject *obj;
 415
 416     QDeclarativeComponent invalid(&engine);
 417     invalid.setData("import QtQuick 1.0; Flickable { " + code.toUtf8() + " }", QUrl(""));
 418     QTest::ignoreMessage(QtWarningMsg, warning.toUtf8());
 419     obj = invalid.create();
 420     QCOMPARE(invalid.errorString(), error);
 421     delete obj;
 422
 423     QDeclarativeComponent valid(&engine);
 424     valid.setData("import QtQuick 1.1; Flickable { " + code.toUtf8() + " }", QUrl(""));
 425     obj = valid.create();
 426     QVERIFY(obj);
 427     QVERIFY(valid.errorString().isEmpty());
 428     delete obj;
 429 }
 430
 431 void tst_qdeclarativeflickable::testQtQuick11Attributes_data()
 432 {
 433     QTest::addColumn<QString>("code");
 434     QTest::addColumn<QString>("warning");
 435     QTest::addColumn<QString>("error");
 436
 437     QTest::newRow("resizeContent") << "Component.onCompleted: resizeContent(100,100,Qt.point(50,50))"
 438             << "<Unknown File>:1: ReferenceError: Can't find variable: resizeContent"
 439             << "";
 440
 441     QTest::newRow("returnToBounds") << "Component.onCompleted: returnToBounds()"
 442             << "<Unknown File>:1: ReferenceError: Can't find variable: returnToBounds"
 443             << "";
 444
 445 }
 446
 447 void tst_qdeclarativeflickable::wheel()
 448 {
 449     QDeclarativeView *canvas = new QDeclarativeView;
 450     canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/wheel.qml"));
 451     canvas->show();
 452     canvas->setFocus();
 453     QVERIFY(canvas->rootObject() != 0);
 454
 455     QDeclarative1Flickable *flick = canvas->rootObject()->findChild<QDeclarative1Flickable*>("flick");
 456     QVERIFY(flick != 0);
 457
 458     QGraphicsScene *scene = canvas->scene();
 459     QGraphicsSceneWheelEvent event(QEvent::GraphicsSceneWheel);
 460     event.setScenePos(QPointF(200, 200));
 461     event.setDelta(-120);
 462     event.setOrientation(Qt::Vertical);
 463     event.setAccepted(false);
 464     QApplication::sendEvent(scene, &event);
 465
 466     QTRY_VERIFY(flick->contentY() > 0);
 467     QVERIFY(flick->contentX() == 0);
 468
 469     flick->setContentY(0);
 470     QVERIFY(flick->contentY() == 0);
 471
 472     event.setScenePos(QPointF(200, 200));
 473     event.setDelta(-120);
 474     event.setOrientation(Qt::Horizontal);
 475     event.setAccepted(false);
 476     QApplication::sendEvent(scene, &event);
 477
 478     QTRY_VERIFY(flick->contentX() > 0);
 479     QVERIFY(flick->contentY() == 0);
 480
 481     delete canvas;
 482 }
 483
 484 void tst_qdeclarativeflickable::disabled()
 485 {
 486     QDeclarativeView *canvas = new QDeclarativeView;
 487     canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/disabled.qml"));
 488     canvas->show();
 489     canvas->setFocus();
 490     QVERIFY(canvas->rootObject() != 0);
 491
 492     QDeclarative1Flickable *flick = canvas->rootObject()->findChild<QDeclarative1Flickable*>("flickable");
 493     QVERIFY(flick != 0);
 494
 495     QTest::mousePress(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(50,90)));
 496
 497     QMouseEvent moveEvent(QEvent::MouseMove, canvas->mapFromScene(QPoint(50, 80)), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
 498     QApplication::sendEvent(canvas, &moveEvent);
 499
 500     moveEvent = QMouseEvent(QEvent::MouseMove, canvas->mapFromScene(QPoint(50, 70)), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
 501     QApplication::sendEvent(canvas, &moveEvent);
 502
 503     moveEvent = QMouseEvent(QEvent::MouseMove, canvas->mapFromScene(QPoint(50, 60)), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
 504     QApplication::sendEvent(canvas, &moveEvent);
 505
 506     QVERIFY(flick->isMoving() == false);
 507
 508     QTest::mouseRelease(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(50, 60)));
 509
 510     // verify that mouse clicks on other elements still work (QTBUG-20584)
 511     QTest::mousePress(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(50, 10)));
 512     QTest::mouseRelease(canvas->viewport(), Qt::LeftButton, 0, canvas->mapFromScene(QPoint(50, 10)));
 513
 514     QVERIFY(canvas->rootObject()->property("clicked").toBool() == true);
 515 }
 516
 517 template<typename T>
 518 T *tst_qdeclarativeflickable::findItem(QGraphicsObject *parent, const QString &objectName)
 519 {
 520     const QMetaObject &mo = T::staticMetaObject;
 521     //qDebug() << parent->childItems().count() << "children";
 522     for (int i = 0; i < parent->childItems().count(); ++i) {
 523         QGraphicsObject *item = qobject_cast<QGraphicsObject*>(parent->childItems().at(i));
 524         if(!item)
 525             continue;
 526         //qDebug() << "try" << item;
 527         if (mo.cast(item) && (objectName.isEmpty() || item->objectName() == objectName)) {
 528             return static_cast<T*>(item);
 529         }
 530         item = findItem<T>(item, objectName);
 531         if (item)
 532             return static_cast<T*>(item);
 533     }
 534
 535     return 0;
 536 }
 537
 538 QTEST_MAIN(tst_qdeclarativeflickable)
 539
 540 #include "tst_qdeclarativeflickable.moc"