tests/qmltests/Components/tst_DragHandle.cpp · unity8

git.iko.soy/unity8

on 551c708 help sign in

unity8/tests/qmltests/Components/tst_DragHandle.cpp

449 lines 15 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>

24#include <DirectionalDragArea.h>

26class FakeTimer : public UbuntuGestures::AbstractTimer

27{

28 Q_OBJECT

29public:

30 FakeTimer(QObject *parent = 0)

31 : UbuntuGestures::AbstractTimer(parent)

32 {}

34 virtual int interval() const { return m_duration; }

35 virtual void setInterval(int msecs) { m_duration = msecs; }

36private:

37 int m_duration;

38};

40class FakeTimeSource : public UbuntuGestures::TimeSource

41{

42public:

43 FakeTimeSource() { m_msecsSinceReference = 0; }

44 qint64 msecsSinceReference() override {return m_msecsSinceReference;}

45 qint64 m_msecsSinceReference;

46};

48class tst_DragHandle: public QObject

49{

50 Q_OBJECT

51public:

52 tst_DragHandle() : m_device(0) { }

53private Q_SLOTS:

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

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

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

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

60 void dragThreshold_horizontal();

61 void dragThreshold_vertical();

62 void stretch_horizontal();

63 void stretch_vertical();

64 void hintingAnimation();

65 void hintingAnimation_dontRestartAfterFinishedAndStillPressed();

68private:

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

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

71 int numSteps, qint64 timeMs = 500);

72 DirectionalDragArea *fetchAndSetupDragHandle(const char *objectName);

73 qreal fetchDragThreshold(DirectionalDragArea *dragHandle);

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

76 QQuickView *createView();

77 QQuickView *m_view;

78 QTouchDevice *m_device;

79 FakeTimer *m_fakeTimer;

80 QSharedPointer<FakeTimeSource> m_fakeTimeSource;

81};

84void tst_DragHandle::initTestCase()

85{

86 if (!m_device) {

87 m_device = new QTouchDevice;

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

89 QWindowSystemInterface::registerTouchDevice(m_device);

90 }

92 m_view = 0;

93}

95void tst_DragHandle::cleanupTestCase()

96{

97}

99void tst_DragHandle::init()

100{

101 m_view = createView();

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

103 m_view->show();

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

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

106 qApp->processEvents();

107

108 m_fakeTimer = new FakeTimer;

109 m_fakeTimeSource.reset(new FakeTimeSource);

110}

111

112void tst_DragHandle::cleanup()

113{

114 delete m_view;

115 m_view = 0;

116

117 delete m_fakeTimer;

118 m_fakeTimer = 0;

119

120 m_fakeTimeSource.reset();

121}

122

123QQuickView *tst_DragHandle::createView()

124{

125 QQuickView *window = new QQuickView(0);

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

127 window->resize(600, 600);

128 window->engine()->addImportPath(QLatin1String(UBUNTU_GESTURES_PLUGIN_DIR));

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

130

131 return window;

132}

133

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

135 qreal expectedValue)

136{

137 int waitCount = 0;

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

139 QTest::qWait(50);

140 ++waitCount;

141 }

142 QCOMPARE(actualFunc(), expectedValue);

143}

144

145namespace {

146QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea)

147{

148

149 switch (edgeDragArea->direction()) {

150 case Direction::Upwards:

151 return QPointF(0, -1);

152 case Direction::Downwards:

153 return QPointF(0, 1);

154 case Direction::Leftwards:

155 return QPointF(-1, 0);

156 default: // Direction::Rightwards:

157 return QPointF(1, 0);

158 }

159}

160}

161

162void tst_DragHandle::flickAndHold(DirectionalDragArea *dragHandle,

163 qreal distance)

164{

165 QPointF initialTouchPos = dragHandle->mapToScene(

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

167 QPointF touchPoint = initialTouchPos;

168

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

170

171 int numSteps = 10;

172 QPointF dragDirectionVector = calculateDirectionVector(dragHandle);

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

174

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

176 // speed.

177 m_fakeTimeSource->m_msecsSinceReference += 5000;

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

179}

180

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

182 int numSteps, qint64 timeMs)

183{

184 qint64 timeStep = timeMs / numSteps;

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

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

187 touchPoint += touchMovement;

188 m_fakeTimeSource->m_msecsSinceReference += timeStep;

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

190 }

191}

192

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

194{

195 DirectionalDragArea *dragHandle =

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

197 Q_ASSERT(dragHandle != 0);

198 dragHandle->setRecognitionTimer(m_fakeTimer);

199 dragHandle->setTimeSource(m_fakeTimeSource);

200

201 AxisVelocityCalculator *edgeDragEvaluator =

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

203 Q_ASSERT(edgeDragEvaluator != 0);

204 edgeDragEvaluator->setTimeSource(m_fakeTimeSource);

205

206 return dragHandle;

207}

208

209qreal tst_DragHandle::fetchDragThreshold(DirectionalDragArea *dragHandle)

210{

211 AxisVelocityCalculator *edgeDragEvaluator =

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

213 Q_ASSERT(edgeDragEvaluator != 0);

214

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

216}

217

218/*

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

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

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

222 */

223void tst_DragHandle::dragThreshold_horizontal()

224{

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

226

227 qreal dragThreshold = fetchDragThreshold(dragHandle);

228

229 // end before the threshold

230 flickAndHold(dragHandle, dragThreshold * 0.7);

231

232 // should rollback

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

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

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

236

237 // end after the threshold

238 flickAndHold(dragHandle, dragThreshold * 1.2);

239

240 // should keep going until completion

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

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

243

244 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

245

246 dragThreshold = fetchDragThreshold(dragHandle);

247

248 // end before the threshold

249 flickAndHold(dragHandle, dragThreshold * 0.7);

250

251 // should rollback

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

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

254

255 // end after the threshold

256 flickAndHold(dragHandle, dragThreshold * 1.2);

257

258 // should keep going until completion

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

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

261}

262

263void tst_DragHandle::dragThreshold_vertical()

264{

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

266

267 qreal dragThreshold = fetchDragThreshold(dragHandle);

268

269 // end before the threshold

270 flickAndHold(dragHandle, dragThreshold * 0.7);

271

272 // should rollback

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

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

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

276

277 // end after the threshold

278 flickAndHold(dragHandle, dragThreshold * 1.2);

279

280 // should keep going until completion

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

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

283

284 dragHandle = fetchAndSetupDragHandle("upwardsDragHandle");

285

286 dragThreshold = fetchDragThreshold(dragHandle);

287

288 // end before the threshold

289 flickAndHold(dragHandle, dragThreshold * 0.7);

290

291 // should rollback

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

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

294

295 // end after the threshold

296 flickAndHold(dragHandle, dragThreshold * 1.2);

297

298 // should keep going until completion

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

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

301}

302

303/*

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

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

306 */

307void tst_DragHandle::stretch_horizontal()

308{

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

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

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

312

313 // enable strech mode

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

315

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

317

318 // flick all the way

319 flickAndHold(dragHandle, totalDragDistance);

320

321 // should keep going until completion

322 // Parent item should now have its full height

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

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

325

326 dragHandle = fetchAndSetupDragHandle("leftwardsDragHandle");

327

328 // flick all the way

329 flickAndHold(dragHandle, totalDragDistance);

330

331 // should keep going until completion

332 // Parent item should now have its full height

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

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

335}

336

337void tst_DragHandle::stretch_vertical()

338{

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

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

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

342

343 // enable strech mode

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

345

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

347

348 // flick all the way

349 flickAndHold(dragHandle, totalDragDistance);

350

351 // should keep going until completion

352 // Parent item should now have its full height

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

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

355

356 dragHandle = fetchAndSetupDragHandle("upwardsDragHandle");

357

358 // flick all the way

359 flickAndHold(dragHandle, totalDragDistance);

360

361 // should keep going until completion

362 // Parent item should now have its full height

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

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

365}

366

367/*

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

369 Then lay a finger on the DragHandle.

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

371 by hintDisplacement pixels.

372 */

373void tst_DragHandle::hintingAnimation()

374{

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

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

377 qreal hintDisplacement = 100.0;

378

379 // enable hinting animations and stretch mode

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

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

382

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

384

385 QPointF initialTouchPos = dragHandle->mapToScene(

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

387 QPointF touchPoint = initialTouchPos;

388

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

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

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

392

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

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

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

396

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

398}

399

400/*

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

402

403 1) Click on handle.

404 2) wait for hint portion to appear

405 3) slowly drag handle, only a few pixels

406

407 Expected outcome:

408 Nothing happens

409

410 Actual outcome:

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

412 hint displacement location.

413 */

414void tst_DragHandle::hintingAnimation_dontRestartAfterFinishedAndStillPressed()

415{

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

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

418 qreal hintDisplacement = 100.0;

419

420 // enable hinting animations

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

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

423

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

425

426 QPointF initialTouchPos = dragHandle->mapToScene(

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

428 QPointF touchPoint = initialTouchPos;

429

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

431 const int touchId = 0;

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

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

434

435

436 QSignalSpy parentHeightChangedSpy(parentItem, SIGNAL(heightChanged()));

437

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

439

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

441 QTest::qWait(300);

442

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

444 QVERIFY(parentHeightChangedSpy.isEmpty());

445}

446

447QTEST_MAIN(tst_DragHandle)

448

449#include "tst_DragHandle.moc"