tests/qmltests/Components/tst_DragHandle.cpp · unity8

git.iko.soy/unity8

on cda847a help sign in

unity8/tests/qmltests/Components/tst_DragHandle.cpp

504 lines 17 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

17#include <functional>

18#include <QtTest/QtTest>

19#include <QtCore/QObject>

20#include <qpa/qwindowsysteminterface.h>

21#include <QtQuick/QQuickView>

22#include <QtQml/QQmlEngine>

23#include <private/qquickanimatorcontroller_p.h>

24#include <private/qquickwindow_p.h>

25#include <UbuntuGestures/private/ucswipearea_p_p.h>

27#include <AxisVelocityCalculator.h>

28#include <UbuntuGestures/private/timer_p.h>

29#include "Direction.h"

31#include <paths.h>

33UG_USE_NAMESPACE

35class tst_DragHandle: public QObject

36{

37 Q_OBJECT

38public:

39 tst_DragHandle() : m_device(0) { }

40private Q_SLOTS:

41 void initTestCase(); // will be called before the first test function is executed

42 void cleanupTestCase(); // will be called after the last test function was executed.

44 void init(); // called right before each and every test function is executed

45 void cleanup(); // called right after each and every test function is executed

47 void dragThreshold_horizontal();

48 void dragThreshold_horizontal_data();

49 void dragThreshold_vertical();

50 void dragThreshold_vertical_data();

51 void stretch_horizontal();

52 void stretch_vertical();

53 void hintingAnimation();

54 void hintingAnimation_dontRestartAfterFinishedAndStillPressed();

56private:

57 void flickAndHold(QQuickItem *dragHandle, qreal distance);

58 void drag(QPointF &touchPoint, const QPointF& direction, qreal distance,

59 int numSteps, qint64 timeMs = 500);

60 QQuickItem *fetchAndSetupDragHandle(const char *objectName);

61 qreal fetchDragThreshold(QQuickItem *dragHandle);

62 void tryCompare(std::function<qreal ()> actualFunc, qreal expectedValue);

64 QQuickView *createView();

65 QQuickView *m_view;

66 QTouchDevice *m_device;

67 FakeTimer *m_fakeTimer;

68 QSharedPointer<FakeTimeSource> m_fakeTimeSource;

69};

72void tst_DragHandle::initTestCase()

73{

74 if (!m_device) {

75 m_device = new QTouchDevice;

76 m_device->setType(QTouchDevice::TouchScreen);

77 QWindowSystemInterface::registerTouchDevice(m_device);

78 }

80 m_view = 0;

81}

83void tst_DragHandle::cleanupTestCase()

84{

85}

87void tst_DragHandle::init()

88{

89 m_view = createView();

90 m_view->setSource(QUrl::fromLocalFile(testDataDir() + "/" TEST_DIR "/tst_DragHandle.qml"));

91 m_view->show();

92 QVERIFY(QTest::qWaitForWindowExposed(m_view));

93 QVERIFY(m_view->rootObject() != 0);

94 qApp->processEvents();

96 // Hide the controls to ensure we don't hit them accidentally

97 QQuickItem *controls = m_view->rootObject()->findChild<QQuickItem*>("controls");

98 controls->setVisible(false);

100 m_fakeTimeSource.reset(new FakeTimeSource);

101 m_fakeTimer = new FakeTimer(m_fakeTimeSource);

102}

103

104void tst_DragHandle::cleanup()

105{

106 delete m_view;

107 m_view = 0;

108

109 delete m_fakeTimer;

110 m_fakeTimer = 0;

111

112 m_fakeTimeSource.reset();

113}

114

115QQuickView *tst_DragHandle::createView()

116{

117 QQuickView *window = new QQuickView(0);

118 window->setResizeMode(QQuickView::SizeRootObjectToView);

119 window->engine()->addImportPath(testDataDir() + "/" TEST_DIR);

120

121 return window;

122}

123

124void tst_DragHandle::tryCompare(std::function<qreal ()> actualFunc,

125 qreal expectedValue)

126{

127 int waitCount = 0;

128 while (actualFunc() != expectedValue && waitCount < 100) {

129 QTest::qWait(50);

130 ++waitCount;

131 }

132 QCOMPARE(actualFunc(), expectedValue);

133}

134

135namespace {

136QPointF calculateDirectionVector(QQuickItem *edgeDragArea)

137{

138 QPointF localOrigin(0., 0.);

139 QPointF localDirection;

140 switch (edgeDragArea->property("direction").toInt()) {

141 case Direction::Upwards:

142 localDirection.rx() = 0.;

143 localDirection.ry() = -1.;

144 break;

145 case Direction::Downwards:

146 localDirection.rx() = 0.;

147 localDirection.ry() = 1;

148 break;

149 case Direction::Leftwards:

150 localDirection.rx() = -1.;

151 localDirection.ry() = 0.;

152 break;

153 default: // Direction::Rightwards:

154 localDirection.rx() = 1.;

155 localDirection.ry() = 0.;

156 break;

157 }

158 QPointF sceneOrigin = edgeDragArea->mapToScene(localOrigin);

159 QPointF sceneDirection = edgeDragArea->mapToScene(localDirection);

160 return sceneDirection - sceneOrigin;

161}

162}

163

164void tst_DragHandle::flickAndHold(QQuickItem *dragHandle,

165 qreal distance)

166{

167 QPointF initialTouchPos = dragHandle->mapToScene(

168 QPointF(dragHandle->width() / 2.0, dragHandle->height() / 2.0));

169 QPointF touchPoint = initialTouchPos;

170

171 QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());

172

173 int numSteps = 10;

174 QPointF dragDirectionVector = calculateDirectionVector(dragHandle);

175 drag(touchPoint, dragDirectionVector, distance, numSteps);

176

177 // Wait for quite a bit before finally releasing to make a very low flick/release

178 // speed.

179 m_fakeTimeSource->m_msecsSinceReference += 5000;

180 QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());

181

182 QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(m_view);

183 if (windowPrivate->delayedTouch) {

184 windowPrivate->deliverDelayedTouchEvent();

185

186 // Touch events which constantly start animations (such as a behavior tracking

187 // the mouse point) need animations to start.

188 QQmlAnimationTimer *ut = QQmlAnimationTimer::instance();

189 if (ut && ut->hasStartAnimationPending())

190 ut->startAnimations();

191 }

192}

193

194void tst_DragHandle::drag(QPointF &touchPoint, const QPointF& direction, qreal distance,

195 int numSteps, qint64 timeMs)

196{

197 QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(m_view);

198

199 qint64 timeStep = timeMs / numSteps;

200 QPointF touchMovement = direction * (distance / (qreal)numSteps);

201 for (int i = 0; i < numSteps; ++i) {

202 touchPoint += touchMovement;

203 m_fakeTimeSource->m_msecsSinceReference += timeStep;

204 QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());

205

206 if (windowPrivate->delayedTouch) {

207 windowPrivate->deliverDelayedTouchEvent();

208

209 // Touch events which constantly start animations (such as a behavior tracking

210 // the mouse point) need animations to start.

211 QQmlAnimationTimer *ut = QQmlAnimationTimer::instance();

212 if (ut && ut->hasStartAnimationPending())

213 ut->startAnimations();

214 }

215 }

216}

217

218QQuickItem *tst_DragHandle::fetchAndSetupDragHandle(const char *objectName)

219{

220 QQuickItem *dragHandle =

221 m_view->rootObject()->findChild<QQuickItem*>(objectName);

222 Q_ASSERT(dragHandle != 0);

223 UCSwipeArea *swipeArea = dynamic_cast<UCSwipeArea*>(dragHandle);

224 if (swipeArea) {

225 UCSwipeAreaPrivate *swipeAreaPrivate = dynamic_cast<UCSwipeAreaPrivate *>(QQuickItemPrivate::get(swipeArea));

226 swipeAreaPrivate->setRecognitionTimer(m_fakeTimer);

227 swipeAreaPrivate->setTimeSource(m_fakeTimeSource);

228 }

229

230 AxisVelocityCalculator *edgeDragEvaluator =

231 dragHandle->findChild<AxisVelocityCalculator*>("edgeDragEvaluator");

232 Q_ASSERT(edgeDragEvaluator != 0);

233 edgeDragEvaluator->setTimeSource(m_fakeTimeSource);

234

235 return dragHandle;

236}

237

238qreal tst_DragHandle::fetchDragThreshold(QQuickItem *dragHandle)

239{

240 AxisVelocityCalculator *edgeDragEvaluator =

241 dragHandle->findChild<AxisVelocityCalculator*>("edgeDragEvaluator");

242 Q_ASSERT(edgeDragEvaluator != 0);

243

244 return edgeDragEvaluator->property("dragThreshold").toReal();

245}

246

247/*

248 Checks that ending a low-speed drag before dragThreshold results in the

249 Showable getting back to its original position, whereas ending after dragThreshold

250 results in Showable continuing until reaching its new states (shown or hidden)

251 */

252void tst_DragHandle::dragThreshold_horizontal()

253{

254 QFETCH(qreal, rotation);

255

256 QQuickItem *baseItem = m_view->rootObject()->findChild<QQuickItem*>("baseItem");

257 baseItem->setRotation(rotation);

258

259 QQuickItem *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");

260 QQuickItem *parentItem = dragHandle->parentItem();

261

262 qreal dragThreshold = fetchDragThreshold(dragHandle);

263

264 // end before the threshold

265 flickAndHold(dragHandle, dragThreshold * 0.7);

266

267 // should rollback

268 tryCompare([&](){ return parentItem->x(); }, -parentItem->width());

269 QCOMPARE(parentItem->property("shown").toBool(), false);

270

271 // end after the threshold

272 flickAndHold(dragHandle, dragThreshold * 1.2);

273

274 // should keep going until completion

275 tryCompare([&](){ return parentItem->x(); }, 0);

276 QCOMPARE(parentItem->property("shown").toBool(), true);

277

278 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

279

280 dragThreshold = fetchDragThreshold(dragHandle);

281

282 // end before the threshold

283 flickAndHold(dragHandle, dragThreshold * 0.7);

284

285 // should rollback

286 tryCompare([&](){ return parentItem->x(); }, 0);

287 QCOMPARE(parentItem->property("shown").toBool(), true);

288

289 // end after the threshold

290 flickAndHold(dragHandle, dragThreshold * 1.2);

291

292 // should keep going until completion

293 tryCompare([&](){ return parentItem->x(); }, -parentItem->width());

294 QCOMPARE(parentItem->property("shown").toBool(), false);

295}

296

297void tst_DragHandle::dragThreshold_horizontal_data()

298{

299 QTest::addColumn<qreal>("rotation");

300

301 QTest::newRow("not rotated") << 0.;

302 QTest::newRow("rotated 90") << 90.;

303}

304

305void tst_DragHandle::dragThreshold_vertical()

306{

307 QFETCH(qreal, rotation);

308

309 QQuickItem *baseItem = m_view->rootObject()->findChild<QQuickItem*>("baseItem");

310 baseItem->setRotation(rotation);

311

312 QQuickItem *dragHandle = fetchAndSetupDragHandle("topEdgeShowDragHandle");

313

314 qreal dragThreshold = fetchDragThreshold(dragHandle);

315

316 // end before the threshold

317 flickAndHold(dragHandle, dragThreshold * 0.7);

318

319 // should rollback

320 QQuickItem *parentItem = dragHandle->parentItem();

321 tryCompare([&](){ return parentItem->y(); }, -parentItem->height());

322 QCOMPARE(parentItem->property("shown").toBool(), false);

323

324 // end after the threshold

325 flickAndHold(dragHandle, dragThreshold * 1.2);

326

327 // should keep going until completion

328 tryCompare([&](){ return parentItem->y(); }, 0);

329 QCOMPARE(parentItem->property("shown").toBool(), true);

330

331 dragHandle = fetchAndSetupDragHandle("topEdgeHideDragHandle");

332

333 dragThreshold = fetchDragThreshold(dragHandle);

334

335 // end before the threshold

336 flickAndHold(dragHandle, dragThreshold * 0.7);

337

338 // should rollback

339 tryCompare([&](){ return parentItem->y(); }, 0);

340 QCOMPARE(parentItem->property("shown").toBool(), true);

341

342 // end after the threshold

343 flickAndHold(dragHandle, dragThreshold * 1.2);

344

345 // should keep going until completion

346 tryCompare([&](){ return parentItem->y(); }, -parentItem->height());

347 QCOMPARE(parentItem->property("shown").toBool(), false);

348}

349

350void tst_DragHandle::dragThreshold_vertical_data()

351{

352 QTest::addColumn<qreal>("rotation");

353

354 QTest::newRow("not rotated") << 0.;

355 QTest::newRow("rotated 90") << 90.;

356}

357

358/*

359 Checks that when the stretch property is true, dragging the DragHandle increases

360 the width or height (depending on its direction) of its parent Showable

361 */

362void tst_DragHandle::stretch_horizontal()

363{

364 QQuickItem *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");

365 qreal totalDragDistance = dragHandle->property("maxTotalDragDistance").toReal();

366 QQuickItem *parentItem = dragHandle->parentItem();

367

368 // enable strech mode

369 m_view->rootObject()->setProperty("stretch", QVariant(true));

370

371 QCOMPARE(parentItem->width(), 0.0);

372

373 // flick all the way

374 flickAndHold(dragHandle, totalDragDistance);

375

376 // should keep going until completion

377 // Parent item should now have its full height

378 tryCompare([&](){ return parentItem->width(); }, totalDragDistance);

379 QCOMPARE(parentItem->property("shown").toBool(), true);

380

381 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

382

383 // flick all the way

384 flickAndHold(dragHandle, totalDragDistance);

385

386 // should keep going until completion

387 // Parent item should now have its full height

388 tryCompare([&](){ return parentItem->width(); }, 0.0);

389 QCOMPARE(parentItem->property("shown").toBool(), false);

390}

391

392void tst_DragHandle::stretch_vertical()

393{

394 QQuickItem *dragHandle = fetchAndSetupDragHandle("topEdgeShowDragHandle");

395 qreal totalDragDistance = dragHandle->property("maxTotalDragDistance").toReal();

396 QQuickItem *parentItem = dragHandle->parentItem();

397

398 // enable strech mode

399 m_view->rootObject()->setProperty("stretch", QVariant(true));

400

401 QCOMPARE(parentItem->height(), 0.0);

402

403 // flick all the way

404 flickAndHold(dragHandle, totalDragDistance);

405

406 // should keep going until completion

407 // Parent item should now have its full height

408 tryCompare([&](){ return parentItem->height(); }, totalDragDistance);

409 QCOMPARE(parentItem->property("shown").toBool(), true);

410

411 dragHandle = fetchAndSetupDragHandle("topEdgeHideDragHandle");

412

413 // flick all the way

414 flickAndHold(dragHandle, totalDragDistance);

415

416 // should keep going until completion

417 // Parent item should now have its full height

418 tryCompare([&](){ return parentItem->height(); }, 0.0);

419 QCOMPARE(parentItem->property("shown").toBool(), false);

420}

421

422/*

423 Set DragHandle.hintDisplacement to a value bigger than zero.

424 Then lay a finger on the DragHandle.

425 The expected behavior is that it will move or strech its parent Showable

426 by hintDisplacement pixels.

427 */

428void tst_DragHandle::hintingAnimation()

429{

430 QQuickItem *dragHandle = fetchAndSetupDragHandle("topEdgeShowDragHandle");

431 QQuickItem *parentItem = dragHandle->parentItem();

432 qreal hintDisplacement = 100.0;

433

434 // enable hinting animations and stretch mode

435 m_view->rootObject()->setProperty("hintDisplacement", QVariant(hintDisplacement));

436 m_view->rootObject()->setProperty("stretch", QVariant(true));

437

438 QCOMPARE(parentItem->height(), 0.0);

439

440 QPointF initialTouchPos = dragHandle->mapToScene(

441 QPointF(dragHandle->width() / 2.0, dragHandle->height() / 2.0));

442 QPointF touchPoint = initialTouchPos;

443

444 // Pressing causes the Showable to be stretched by hintDisplacement pixels

445 QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());

446 tryCompare([&](){ return parentItem->height(); }, hintDisplacement);

447

448 // Releasing causes the Showable to shrink back to 0 pixels.

449 QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());

450 tryCompare([&](){ return parentItem->height(); }, 0.0);

451

452 QCOMPARE(parentItem->property("shown").toBool(), false);

453}

454

455/*

456 Regression test for LP#1269022: https://bugs.launchpad.net/unity8/+bug/1269022

457

458 1) Click on handle.

459 2) wait for hint portion to appear

460 3) slowly drag handle, only a few pixels

461

462 Expected outcome:

463 Nothing happens

464

465 Actual outcome:

466 Handle will momentarily move back to zero position, then back down to the

467 hint displacement location.

468 */

469void tst_DragHandle::hintingAnimation_dontRestartAfterFinishedAndStillPressed()

470{

471 QQuickItem *dragHandle = fetchAndSetupDragHandle("topEdgeShowDragHandle");

472 QQuickItem *parentItem = dragHandle->parentItem();

473 qreal hintDisplacement = 100.0;

474

475 // enable hinting animations

476 m_view->rootObject()->setProperty("hintDisplacement", QVariant(hintDisplacement));

477 m_view->rootObject()->setProperty("stretch", QVariant(true));

478

479 QCOMPARE(parentItem->height(), 0.0);

480

481 QPointF initialTouchPos = dragHandle->mapToScene(

482 QPointF(dragHandle->width() / 2.0, dragHandle->height() / 2.0));

483 QPointF touchPoint = initialTouchPos;

484

485 // Pressing causes the Showable to be stretched by hintDisplacement pixels

486 const int touchId = 0;

487 QTest::touchEvent(m_view, m_device).press(touchId, touchPoint.toPoint());

488 tryCompare([&](){ return parentItem->height(); }, hintDisplacement);

489

490

491 QSignalSpy parentHeightChangedSpy(parentItem, &QQuickItem::heightChanged);

492

493 drag(touchPoint, QPointF(0.0, -1.0) /*dragDirectionVector*/, 15 /*distance*/, 3 /*numSteps*/);

494

495 // Give some time for animations to run, if any

496 QTest::qWait(300);

497

498 // parentItem height shouldn't have changed at all

499 QVERIFY(parentHeightChangedSpy.isEmpty());

500}

501

502QTEST_MAIN(tst_DragHandle)

503

504#include "tst_DragHandle.moc"