tests/qmltests/Components/tst_DragHandle.cpp · unity8

git.iko.soy/unity8

on d067964 help sign in

unity8/tests/qmltests/Components/tst_DragHandle.cpp

487 lines 16 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/qquickwindow_p.h>

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

26#include <AxisVelocityCalculator.h>

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

28#include "Direction.h"

30#include <paths.h>

32UG_USE_NAMESPACE

34class tst_DragHandle: public QObject

35{

36 Q_OBJECT

37public:

38 tst_DragHandle() : m_device(0) { }

39private Q_SLOTS:

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

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

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

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

46 void dragThreshold_horizontal();

47 void dragThreshold_horizontal_data();

48 void dragThreshold_vertical();

49 void dragThreshold_vertical_data();

50 void stretch_horizontal();

51 void stretch_vertical();

52 void hintingAnimation();

53 void hintingAnimation_dontRestartAfterFinishedAndStillPressed();

55private:

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

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

58 int numSteps, qint64 timeMs = 500);

59 QQuickItem *fetchAndSetupDragHandle(const char *objectName);

60 qreal fetchDragThreshold(QQuickItem *dragHandle);

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

63 QQuickView *createView();

64 QQuickView *m_view;

65 QTouchDevice *m_device;

66 FakeTimer *m_fakeTimer;

67 QSharedPointer<FakeTimeSource> m_fakeTimeSource;

68};

71void tst_DragHandle::initTestCase()

72{

73 if (!m_device) {

74 m_device = new QTouchDevice;

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

76 QWindowSystemInterface::registerTouchDevice(m_device);

77 }

79 m_view = 0;

80}

82void tst_DragHandle::cleanupTestCase()

83{

84}

86void tst_DragHandle::init()

87{

88 m_view = createView();

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

90 m_view->show();

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

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

93 qApp->processEvents();

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

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

97 controls->setVisible(false);

99 m_fakeTimeSource.reset(new FakeTimeSource);

100 m_fakeTimer = new FakeTimer(m_fakeTimeSource);

101}

102

103void tst_DragHandle::cleanup()

104{

105 delete m_view;

106 m_view = 0;

107

108 delete m_fakeTimer;

109 m_fakeTimer = 0;

110

111 m_fakeTimeSource.reset();

112}

113

114QQuickView *tst_DragHandle::createView()

115{

116 QQuickView *window = new QQuickView(0);

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

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

119

120 return window;

121}

122

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

124 qreal expectedValue)

125{

126 int waitCount = 0;

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

128 QTest::qWait(50);

129 ++waitCount;

130 }

131 QCOMPARE(actualFunc(), expectedValue);

132}

133

134namespace {

135QPointF calculateDirectionVector(QQuickItem *edgeDragArea)

136{

137 QPointF localOrigin(0., 0.);

138 QPointF localDirection;

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

140 case Direction::Upwards:

141 localDirection.rx() = 0.;

142 localDirection.ry() = -1.;

143 break;

144 case Direction::Downwards:

145 localDirection.rx() = 0.;

146 localDirection.ry() = 1;

147 break;

148 case Direction::Leftwards:

149 localDirection.rx() = -1.;

150 localDirection.ry() = 0.;

151 break;

152 default: // Direction::Rightwards:

153 localDirection.rx() = 1.;

154 localDirection.ry() = 0.;

155 break;

156 }

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

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

159 return sceneDirection - sceneOrigin;

160}

161}

162

163void tst_DragHandle::flickAndHold(QQuickItem *dragHandle,

164 qreal distance)

165{

166 QPointF initialTouchPos = dragHandle->mapToScene(

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

168 QPointF touchPoint = initialTouchPos;

169

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

171

172 int numSteps = 10;

173 QPointF dragDirectionVector = calculateDirectionVector(dragHandle);

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

175

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

177 // speed.

178 m_fakeTimeSource->m_msecsSinceReference += 5000;

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

180

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

182 windowPrivate->flushDelayedTouchEvent();

183}

184

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

186 int numSteps, qint64 timeMs)

187{

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

189

190 qint64 timeStep = timeMs / numSteps;

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

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

193 touchPoint += touchMovement;

194 m_fakeTimeSource->m_msecsSinceReference += timeStep;

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

196

197 windowPrivate->flushDelayedTouchEvent();

198 }

199}

200

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

202{

203 QQuickItem *dragHandle =

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

205 Q_ASSERT(dragHandle != 0);

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

207 if (swipeArea) {

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

209 swipeAreaPrivate->setRecognitionTimer(m_fakeTimer);

210 swipeAreaPrivate->setTimeSource(m_fakeTimeSource);

211 }

212

213 AxisVelocityCalculator *edgeDragEvaluator =

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

215 Q_ASSERT(edgeDragEvaluator != 0);

216 edgeDragEvaluator->setTimeSource(m_fakeTimeSource);

217

218 return dragHandle;

219}

220

221qreal tst_DragHandle::fetchDragThreshold(QQuickItem *dragHandle)

222{

223 AxisVelocityCalculator *edgeDragEvaluator =

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

225 Q_ASSERT(edgeDragEvaluator != 0);

226

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

228}

229

230/*

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

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

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

234 */

235void tst_DragHandle::dragThreshold_horizontal()

236{

237 QFETCH(qreal, rotation);

238

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

240 baseItem->setRotation(rotation);

241

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

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

244

245 qreal dragThreshold = fetchDragThreshold(dragHandle);

246

247 // end before the threshold

248 flickAndHold(dragHandle, dragThreshold * 0.7);

249

250 // should rollback

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

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

253

254 // end after the threshold

255 flickAndHold(dragHandle, dragThreshold * 1.2);

256

257 // should keep going until completion

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

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

260

261 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

262

263 dragThreshold = fetchDragThreshold(dragHandle);

264

265 // end before the threshold

266 flickAndHold(dragHandle, dragThreshold * 0.7);

267

268 // should rollback

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

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

271

272 // end after the threshold

273 flickAndHold(dragHandle, dragThreshold * 1.2);

274

275 // should keep going until completion

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

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

278}

279

280void tst_DragHandle::dragThreshold_horizontal_data()

281{

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

283

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

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

286}

287

288void tst_DragHandle::dragThreshold_vertical()

289{

290 QFETCH(qreal, rotation);

291

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

293 baseItem->setRotation(rotation);

294

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

296

297 qreal dragThreshold = fetchDragThreshold(dragHandle);

298

299 // end before the threshold

300 flickAndHold(dragHandle, dragThreshold * 0.7);

301

302 // should rollback

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

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

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

306

307 // end after the threshold

308 flickAndHold(dragHandle, dragThreshold * 1.2);

309

310 // should keep going until completion

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

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

313

314 dragHandle = fetchAndSetupDragHandle("topEdgeHideDragHandle");

315

316 dragThreshold = fetchDragThreshold(dragHandle);

317

318 // end before the threshold

319 flickAndHold(dragHandle, dragThreshold * 0.7);

320

321 // should rollback

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

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

324

325 // end after the threshold

326 flickAndHold(dragHandle, dragThreshold * 1.2);

327

328 // should keep going until completion

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

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

331}

332

333void tst_DragHandle::dragThreshold_vertical_data()

334{

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

336

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

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

339}

340

341/*

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

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

344 */

345void tst_DragHandle::stretch_horizontal()

346{

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

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

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

350

351 // enable strech mode

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

353

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

355

356 // flick all the way

357 flickAndHold(dragHandle, totalDragDistance);

358

359 // should keep going until completion

360 // Parent item should now have its full height

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

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

363

364 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

365

366 // flick all the way

367 flickAndHold(dragHandle, totalDragDistance);

368

369 // should keep going until completion

370 // Parent item should now have its full height

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

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

373}

374

375void tst_DragHandle::stretch_vertical()

376{

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

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

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

380

381 // enable strech mode

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

383

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

385

386 // flick all the way

387 flickAndHold(dragHandle, totalDragDistance);

388

389 // should keep going until completion

390 // Parent item should now have its full height

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

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

393

394 dragHandle = fetchAndSetupDragHandle("topEdgeHideDragHandle");

395

396 // flick all the way

397 flickAndHold(dragHandle, totalDragDistance);

398

399 // should keep going until completion

400 // Parent item should now have its full height

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

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

403}

404

405/*

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

407 Then lay a finger on the DragHandle.

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

409 by hintDisplacement pixels.

410 */

411void tst_DragHandle::hintingAnimation()

412{

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

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

415 qreal hintDisplacement = 100.0;

416

417 // enable hinting animations and stretch mode

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

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

420

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

422

423 QPointF initialTouchPos = dragHandle->mapToScene(

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

425 QPointF touchPoint = initialTouchPos;

426

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

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

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

430

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

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

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

434

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

436}

437

438/*

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

440

441 1) Click on handle.

442 2) wait for hint portion to appear

443 3) slowly drag handle, only a few pixels

444

445 Expected outcome:

446 Nothing happens

447

448 Actual outcome:

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

450 hint displacement location.

451 */

452void tst_DragHandle::hintingAnimation_dontRestartAfterFinishedAndStillPressed()

453{

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

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

456 qreal hintDisplacement = 100.0;

457

458 // enable hinting animations

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

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

461

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

463

464 QPointF initialTouchPos = dragHandle->mapToScene(

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

466 QPointF touchPoint = initialTouchPos;

467

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

469 const int touchId = 0;

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

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

472

473

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

475

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

477

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

479 QTest::qWait(300);

480

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

482 QVERIFY(parentHeightChangedSpy.isEmpty());

483}

484

485QTEST_MAIN(tst_DragHandle)

486

487#include "tst_DragHandle.moc"