tests/qmltests/Components/tst_DragHandle.cpp · unity8

git.iko.soy/unity8

on bbce293 help sign in

unity8/tests/qmltests/Components/tst_DragHandle.cpp

481 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>

25#include <AxisVelocityCalculator.h>

26#include <DirectionalDragArea.h>

27#include <DirectionalDragArea_p.h>

28#include <Timer.h>

30using namespace UbuntuGestures;

32class tst_DragHandle: public QObject

33{

34 Q_OBJECT

35public:

36 tst_DragHandle() : m_device(0) { }

37private Q_SLOTS:

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

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

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

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

44 void dragThreshold_horizontal();

45 void dragThreshold_horizontal_data();

46 void dragThreshold_vertical();

47 void dragThreshold_vertical_data();

48 void stretch_horizontal();

49 void stretch_vertical();

50 void hintingAnimation();

51 void hintingAnimation_dontRestartAfterFinishedAndStillPressed();

53private:

54 void flickAndHold(DirectionalDragArea *dragHandle, qreal distance);

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

56 int numSteps, qint64 timeMs = 500);

57 DirectionalDragArea *fetchAndSetupDragHandle(const char *objectName);

58 qreal fetchDragThreshold(DirectionalDragArea *dragHandle);

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

61 QQuickView *createView();

62 QQuickView *m_view;

63 QTouchDevice *m_device;

64 FakeTimer *m_fakeTimer;

65 QSharedPointer<FakeTimeSource> m_fakeTimeSource;

66};

69void tst_DragHandle::initTestCase()

70{

71 if (!m_device) {

72 m_device = new QTouchDevice;

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

74 QWindowSystemInterface::registerTouchDevice(m_device);

75 }

77 m_view = 0;

78}

80void tst_DragHandle::cleanupTestCase()

81{

82}

84void tst_DragHandle::init()

85{

86 m_view = createView();

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

88 m_view->show();

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

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

91 qApp->processEvents();

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

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

95 controls->setVisible(false);

97 m_fakeTimeSource.reset(new FakeTimeSource);

98 m_fakeTimer = new FakeTimer(m_fakeTimeSource);

99}

100

101void tst_DragHandle::cleanup()

102{

103 delete m_view;

104 m_view = 0;

105

106 delete m_fakeTimer;

107 m_fakeTimer = 0;

108

109 m_fakeTimeSource.reset();

110}

111

112QQuickView *tst_DragHandle::createView()

113{

114 QQuickView *window = new QQuickView(0);

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

116 window->engine()->addImportPath(QLatin1String(TEST_DIR));

117

118 return window;

119}

120

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

122 qreal expectedValue)

123{

124 int waitCount = 0;

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

126 QTest::qWait(50);

127 ++waitCount;

128 }

129 QCOMPARE(actualFunc(), expectedValue);

130}

131

132namespace {

133QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea)

134{

135 QPointF localOrigin(0., 0.);

136 QPointF localDirection;

137 switch (edgeDragArea->direction()) {

138 case Direction::Upwards:

139 localDirection.rx() = 0.;

140 localDirection.ry() = -1.;

141 break;

142 case Direction::Downwards:

143 localDirection.rx() = 0.;

144 localDirection.ry() = 1;

145 break;

146 case Direction::Leftwards:

147 localDirection.rx() = -1.;

148 localDirection.ry() = 0.;

149 break;

150 default: // Direction::Rightwards:

151 localDirection.rx() = 1.;

152 localDirection.ry() = 0.;

153 break;

154 }

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

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

157 return sceneDirection - sceneOrigin;

158}

159}

160

161void tst_DragHandle::flickAndHold(DirectionalDragArea *dragHandle,

162 qreal distance)

163{

164 QPointF initialTouchPos = dragHandle->mapToScene(

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

166 QPointF touchPoint = initialTouchPos;

167

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

169

170 int numSteps = 10;

171 QPointF dragDirectionVector = calculateDirectionVector(dragHandle);

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

173

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

175 // speed.

176 m_fakeTimeSource->m_msecsSinceReference += 5000;

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

178

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

180 windowPrivate->flushDelayedTouchEvent();

181}

182

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

184 int numSteps, qint64 timeMs)

185{

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

187

188 qint64 timeStep = timeMs / numSteps;

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

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

191 touchPoint += touchMovement;

192 m_fakeTimeSource->m_msecsSinceReference += timeStep;

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

194

195 windowPrivate->flushDelayedTouchEvent();

196 }

197}

198

199DirectionalDragArea *tst_DragHandle::fetchAndSetupDragHandle(const char *objectName)

200{

201 DirectionalDragArea *dragHandle =

202 m_view->rootObject()->findChild<DirectionalDragArea*>(objectName);

203 Q_ASSERT(dragHandle != 0);

204 dragHandle->d->setRecognitionTimer(m_fakeTimer);

205 dragHandle->d->setTimeSource(m_fakeTimeSource);

206

207 AxisVelocityCalculator *edgeDragEvaluator =

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

209 Q_ASSERT(edgeDragEvaluator != 0);

210 edgeDragEvaluator->setTimeSource(m_fakeTimeSource);

211

212 return dragHandle;

213}

214

215qreal tst_DragHandle::fetchDragThreshold(DirectionalDragArea *dragHandle)

216{

217 AxisVelocityCalculator *edgeDragEvaluator =

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

219 Q_ASSERT(edgeDragEvaluator != 0);

220

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

222}

223

224/*

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

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

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

228 */

229void tst_DragHandle::dragThreshold_horizontal()

230{

231 QFETCH(qreal, rotation);

232

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

234 baseItem->setRotation(rotation);

235

236 DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");

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

238

239 qreal dragThreshold = fetchDragThreshold(dragHandle);

240

241 // end before the threshold

242 flickAndHold(dragHandle, dragThreshold * 0.7);

243

244 // should rollback

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

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

247

248 // end after the threshold

249 flickAndHold(dragHandle, dragThreshold * 1.2);

250

251 // should keep going until completion

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

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

254

255 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

256

257 dragThreshold = fetchDragThreshold(dragHandle);

258

259 // end before the threshold

260 flickAndHold(dragHandle, dragThreshold * 0.7);

261

262 // should rollback

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

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

265

266 // end after the threshold

267 flickAndHold(dragHandle, dragThreshold * 1.2);

268

269 // should keep going until completion

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

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

272}

273

274void tst_DragHandle::dragThreshold_horizontal_data()

275{

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

277

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

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

280}

281

282void tst_DragHandle::dragThreshold_vertical()

283{

284 QFETCH(qreal, rotation);

285

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

287 baseItem->setRotation(rotation);

288

289 DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");

290

291 qreal dragThreshold = fetchDragThreshold(dragHandle);

292

293 // end before the threshold

294 flickAndHold(dragHandle, dragThreshold * 0.7);

295

296 // should rollback

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

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

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

300

301 // end after the threshold

302 flickAndHold(dragHandle, dragThreshold * 1.2);

303

304 // should keep going until completion

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

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

307

308 dragHandle = fetchAndSetupDragHandle("upwardsDragHandle");

309

310 dragThreshold = fetchDragThreshold(dragHandle);

311

312 // end before the threshold

313 flickAndHold(dragHandle, dragThreshold * 0.7);

314

315 // should rollback

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

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

318

319 // end after the threshold

320 flickAndHold(dragHandle, dragThreshold * 1.2);

321

322 // should keep going until completion

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

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

325}

326

327void tst_DragHandle::dragThreshold_vertical_data()

328{

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

330

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

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

333}

334

335/*

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

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

338 */

339void tst_DragHandle::stretch_horizontal()

340{

341 DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");

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

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

344

345 // enable strech mode

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

347

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

349

350 // flick all the way

351 flickAndHold(dragHandle, totalDragDistance);

352

353 // should keep going until completion

354 // Parent item should now have its full height

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

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

357

358 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

359

360 // flick all the way

361 flickAndHold(dragHandle, totalDragDistance);

362

363 // should keep going until completion

364 // Parent item should now have its full height

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

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

367}

368

369void tst_DragHandle::stretch_vertical()

370{

371 DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");

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

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

374

375 // enable strech mode

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

377

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

379

380 // flick all the way

381 flickAndHold(dragHandle, totalDragDistance);

382

383 // should keep going until completion

384 // Parent item should now have its full height

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

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

387

388 dragHandle = fetchAndSetupDragHandle("upwardsDragHandle");

389

390 // flick all the way

391 flickAndHold(dragHandle, totalDragDistance);

392

393 // should keep going until completion

394 // Parent item should now have its full height

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

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

397}

398

399/*

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

401 Then lay a finger on the DragHandle.

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

403 by hintDisplacement pixels.

404 */

405void tst_DragHandle::hintingAnimation()

406{

407 DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");

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

409 qreal hintDisplacement = 100.0;

410

411 // enable hinting animations and stretch mode

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

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

414

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

416

417 QPointF initialTouchPos = dragHandle->mapToScene(

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

419 QPointF touchPoint = initialTouchPos;

420

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

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

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

424

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

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

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

428

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

430}

431

432/*

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

434

435 1) Click on handle.

436 2) wait for hint portion to appear

437 3) slowly drag handle, only a few pixels

438

439 Expected outcome:

440 Nothing happens

441

442 Actual outcome:

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

444 hint displacement location.

445 */

446void tst_DragHandle::hintingAnimation_dontRestartAfterFinishedAndStillPressed()

447{

448 DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");

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

450 qreal hintDisplacement = 100.0;

451

452 // enable hinting animations

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

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

455

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

457

458 QPointF initialTouchPos = dragHandle->mapToScene(

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

460 QPointF touchPoint = initialTouchPos;

461

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

463 const int touchId = 0;

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

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

466

467

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

469

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

471

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

473 QTest::qWait(300);

474

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

476 QVERIFY(parentHeightChangedSpy.isEmpty());

477}

478

479QTEST_MAIN(tst_DragHandle)

480

481#include "tst_DragHandle.moc"