tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp · unity8

git.iko.soy/unity8

on f5e4a67 help sign in

unity8/tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp

464 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 <QtTest/QtTest>

18#include <QtCore/QObject>

19#include <qpa/qwindowsysteminterface.h>

20#include <QtQuick/QQuickView>

21#include <QtQml/QQmlEngine>

23#include <DirectionalDragArea.h>

25class FakeTimer : public UbuntuGestures::AbstractTimer

26{

27 Q_OBJECT

28public:

29 FakeTimer(QObject *parent = 0)

30 : UbuntuGestures::AbstractTimer(parent)

31 {}

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

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

36 void emitTimeout() {Q_EMIT timeout();}

37private:

38 int m_duration;

39};

41class FakeTimeSource : public AxisVelocityCalculator::TimeSource

42{

43public:

44 FakeTimeSource() { m_msecsSinceReference = 0; }

45 virtual qint64 msecsSinceReference() {return m_msecsSinceReference;}

46 qint64 m_msecsSinceReference;

47};

49class tst_DirectionalDragArea: public QObject

50{

51 Q_OBJECT

52public:

53 tst_DirectionalDragArea() : device(0) { }

54private Q_SLOTS:

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

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

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

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

61 void edgeDrag();

62 void edgeDrag_data();

63 void dragWithShortDirectionChange();

64 void minSpeed();

65 void minSpeed_data();

66 void recognitionTimerUsage();

67 void maxSilenceTime();

69private:

70 QQuickView *createView();

71 QQuickView *view;

72 QTouchDevice *device;

73 FakeTimer *fakeTimer;

74 FakeTimeSource *fakeTimeSource;

75 AxisVelocityCalculator *velCalcWithFakeTiming;

76};

78void tst_DirectionalDragArea::initTestCase()

79{

80 if (!device) {

81 device = new QTouchDevice;

82 device->setType(QTouchDevice::TouchScreen);

83 QWindowSystemInterface::registerTouchDevice(device);

84 }

86 view = 0;

87}

89void tst_DirectionalDragArea::cleanupTestCase()

90{

91}

93void tst_DirectionalDragArea::init()

94{

95 view = createView();

96 view->setSource(QUrl::fromLocalFile("edgeDragExample.qml"));

97 view->show();

98 QVERIFY(QTest::qWaitForWindowExposed(view));

99 QVERIFY(view->rootObject() != 0);

100 qApp->processEvents();

101

102 fakeTimer = new FakeTimer;

103 fakeTimeSource = new FakeTimeSource;

104 velCalcWithFakeTiming = new AxisVelocityCalculator(fakeTimeSource);

105}

106

107void tst_DirectionalDragArea::cleanup()

108{

109 delete view;

110 view = 0;

111

112 delete fakeTimer;

113 fakeTimer = 0;

114

115 // will bring fakeTimeSource down with it

116 delete velCalcWithFakeTiming;

117 fakeTimeSource = 0;

118 velCalcWithFakeTiming = 0;

119}

120

121QQuickView *tst_DirectionalDragArea::createView()

122{

123 QQuickView *window = new QQuickView(0);

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

125 window->resize(600, 600);

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

127

128 return window;

129}

130

131namespace {

132QPointF calculateInitialTouchPos(DirectionalDragArea *edgeDragArea, QQuickView *view)

133{

134 switch (edgeDragArea->direction()) {

135 case DirectionalDragArea::Upwards:

136 return QPointF(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));

137 case DirectionalDragArea::Downwards:

138 return QPointF(view->width()/2.0f, edgeDragArea->height()/2.0f);

139 case DirectionalDragArea::Leftwards:

140 return QPointF(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);

141 default: // DirectionalDragArea::Rightwards:

142 return QPointF(edgeDragArea->width()/2.0f, view->height()/2.0f);

143 }

144}

145

146QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea,

147 qreal wideningAngleMultiplier)

148{

149 qreal angleRadians = edgeDragArea->wideningAngle() * wideningAngleMultiplier

150 * M_PI / 180.0;

151

152 qreal angleCos = qCos(angleRadians);

153 qreal angleSin = qSin(angleRadians);

154

155 switch (edgeDragArea->direction()) {

156 case DirectionalDragArea::Upwards:

157 return QPointF(angleSin, -angleCos);

158 case DirectionalDragArea::Downwards:

159 return QPointF(angleSin, angleCos);

160 case DirectionalDragArea::Leftwards:

161 return QPointF(-angleCos, angleSin);

162 default: // DirectionalDragArea::Rightwards:

163 return QPointF(angleCos, angleSin);

164 }

165}

166

167QPointF createTouchDeviation(DirectionalDragArea *edgeDragArea)

168{

169 qreal deviation = edgeDragArea->maxDeviation() * 0.8;

170

171 if (edgeDragArea->direction() == DirectionalDragArea::Leftwards

172 || edgeDragArea->direction() == DirectionalDragArea::Rightwards) {

173 return QPointF(0, deviation);

174 } else {

175 return QPointF(deviation, 0);

176 }

177}

178}

179

180void tst_DirectionalDragArea::edgeDrag()

181{

182 QFETCH(QString, dragAreaObjectName);

183 QFETCH(qreal, wideningAngleMultiplier);

184 QFETCH(qreal, dragDistanceFactor);

185 QFETCH(int, expectedGestureRecognition);

186

187 DirectionalDragArea *edgeDragArea =

188 view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);

189 QVERIFY(edgeDragArea != 0);

190 edgeDragArea->setRecognitionTimer(fakeTimer);

191 edgeDragArea->setAxisVelocityCalculator(velCalcWithFakeTiming);

192

193 QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));

194

195 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

196 QPointF touchPoint = initialTouchPos;

197

198 qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;

199 QPointF dragDirectionVector = calculateDirectionVector(edgeDragArea,

200 wideningAngleMultiplier);

201 QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.1f);

202

203 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

204

205 QCOMPARE(draggingSpy.count(), 1);

206 QCOMPARE(edgeDragArea->dragging(), true);

207

208 if (wideningAngleMultiplier > 0) {

209 // go close to the border of the valid area for this touch point

210 // in order to make it easier to leave it by dragging at an angle

211 // slightly bigger than the widening angle

212 touchPoint += createTouchDeviation(edgeDragArea);

213 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

214 }

215

216 do {

217 touchPoint += touchMovement;

218 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

219 } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance);

220

221 if (expectedGestureRecognition)

222 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

223

224 if (edgeDragArea->status() == DirectionalDragArea::Rejected) {

225 QCOMPARE(edgeDragArea->dragging(), false);

226 QCOMPARE(draggingSpy.count(), 2);

227 }

228

229 QTest::touchEvent(view, device).release(0, touchPoint.toPoint());

230

231 QCOMPARE(draggingSpy.count(), 2);

232 QCOMPARE(edgeDragArea->dragging(), false);

233}

234

235void tst_DirectionalDragArea::edgeDrag_data()

236{

237 QTest::addColumn<QString>("dragAreaObjectName");

238 QTest::addColumn<qreal>("wideningAngleMultiplier");

239 QTest::addColumn<qreal>("dragDistanceFactor");

240 QTest::addColumn<int>("expectedGestureRecognition");

241

242 QTest::newRow("rightwards, tiny drag")

243 << "hpDragArea" << 0.0 << 0.2 << 0;

244

245 QTest::newRow("rightwards, straight drag")

246 << "hpDragArea" << 0.0 << 3.0 << 1;

247

248 QTest::newRow("rightwards, diagonal drag")

249 << "hpDragArea" << 0.9 << 3.0 << 1;

250

251 QTest::newRow("rightwards, overly diagonal drag")

252 << "hpDragArea" << 2.0 << 3.0 << 0;

253

254 QTest::newRow("leftwards, tiny drag")

255 << "hnDragArea" << 0.0 << 0.2 << 0;

256

257 QTest::newRow("leftwards, straight drag")

258 << "hnDragArea" << 0.0 << 3.0 << 1;

259

260 QTest::newRow("leftwards, diagonal drag")

261 << "hnDragArea" << 0.9 << 3.0 << 1;

262

263 QTest::newRow("downwards, tiny drag")

264 << "vpDragArea" << 0.0 << 0.2 << 0;

265

266 QTest::newRow("downwards, straight drag")

267 << "vpDragArea" << 0.0 << 3.0 << 1;

268

269 QTest::newRow("downwards, diagonal drag")

270 << "vpDragArea" << 0.9 << 3.0 << 1;

271

272 QTest::newRow("upwards, tiny drag")

273 << "vnDragArea" << 0.0 << 0.2 << 0;

274

275 QTest::newRow("upwards, straight drag")

276 << "vnDragArea" << 0.0 << 3.0 << 1;

277

278 QTest::newRow("upwards, diagonal drag")

279 << "vnDragArea" << 0.9 << 3.0 << 1;

280

281 QTest::newRow("upwards, overly diagonal drag")

282 << "vnDragArea" << 2.0 << 3.0 << 0;

283}

284

285/*

286 A directional drag should still be recognized if there is a momentaneous, small,

287 change in the direction of a drag. That should be accounted as input noise and

288 therefore ignored.

289 */

290void tst_DirectionalDragArea::dragWithShortDirectionChange()

291{

292 DirectionalDragArea *edgeDragArea =

293 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

294 QVERIFY(edgeDragArea != 0);

295 edgeDragArea->setRecognitionTimer(fakeTimer);

296 edgeDragArea->setAxisVelocityCalculator(velCalcWithFakeTiming);

297

298 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

299 QPointF touchPoint = initialTouchPos;

300

301 qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;

302 QPointF dragDirectionVector(1.0, 0.0);

303 QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.1f);

304

305 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

306

307 // Move a bit in the proper direction

308 for (int i=0; i < 3; ++i) {

309 touchPoint += touchMovement;

310 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

311 }

312

313 // Then a sudden and small movement to the opposite direction

314 touchPoint -= dragDirectionVector * (edgeDragArea->maxDeviation() * 0.7);

315 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

316

317 // And then resume movment in the correct direction until it crosses the distance threshold.

318 do {

319 touchPoint += touchMovement;

320 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

321 } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance);

322

323 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

324

325 QTest::touchEvent(view, device).release(0, touchPoint.toPoint());

326}

327

328/*

329 Checks that a gesture will be rejected if it's slower than minSpeed while

330 status is Undecided.

331 */

332void tst_DirectionalDragArea::minSpeed()

333{

334 QFETCH(int, minSpeedMsecsDeviation);

335 QFETCH(int, expectedStatusAfterSpeedCheck);

336

337 DirectionalDragArea *edgeDragArea =

338 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

339 QVERIFY(edgeDragArea != 0);

340 edgeDragArea->setRecognitionTimer(fakeTimer);

341 edgeDragArea->setAxisVelocityCalculator(velCalcWithFakeTiming);

342

343 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

344 QPointF touchPoint = initialTouchPos;

345

346 QPointF dragDirectionVector(1.0, 0.0);

347 qreal distanceStep = edgeDragArea->distanceThreshold() * 0.1f;

348 QPointF touchMovement = dragDirectionVector * distanceStep;

349 qreal minSpeedMsecs = edgeDragArea->minSpeed() / 1000.0;

350 qint64 timeStepMsecs = qFloor(distanceStep / minSpeedMsecs) + minSpeedMsecsDeviation;

351

352 // if it fails it means the params set in the QML file are not in harmony with the values

353 // used in this test

354 Q_ASSERT(timeStepMsecs > 0);

355

356 fakeTimeSource->m_msecsSinceReference = 0;

357 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

358

359 // Move a bit in the proper direction

360 for (int i=0; i < 4; ++i) {

361 touchPoint += touchMovement;

362 fakeTimeSource->m_msecsSinceReference += timeStepMsecs;

363 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

364 }

365

366 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

367

368 // Force the periodic speed check.

369 fakeTimer->emitTimeout();

370

371 QCOMPARE((int)edgeDragArea->status(), expectedStatusAfterSpeedCheck);

372}

373

374void tst_DirectionalDragArea::minSpeed_data()

375{

376 QTest::addColumn<int>("minSpeedMsecsDeviation");

377 QTest::addColumn<int>("expectedStatusAfterSpeedCheck");

378

379 QTest::newRow("slower than minSpeed") << 20 << (int)DirectionalDragArea::Rejected;

380 QTest::newRow("faster than minSpeed") << -20 << (int)DirectionalDragArea::Undecided;

381}

382

383/*

384 Checks that the recognition timer is started and stopped appropriately.

385 I.e., check that it's running only while gesture recognition is taking place

386 (status == Undecided)

387 */

388void tst_DirectionalDragArea::recognitionTimerUsage()

389{

390 DirectionalDragArea *edgeDragArea =

391 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

392 QVERIFY(edgeDragArea != 0);

393 edgeDragArea->setRecognitionTimer(fakeTimer);

394 edgeDragArea->setAxisVelocityCalculator(velCalcWithFakeTiming);

395

396 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

397 QPointF touchPoint = initialTouchPos;

398

399 QPointF dragDirectionVector(1.0, 0.0);

400 QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.2f);

401

402 QVERIFY(!fakeTimer->isRunning());

403

404 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

405

406 QVERIFY(fakeTimer->isRunning());

407

408 // Move a bit in the proper direction

409 for (int i=0; i < 3; ++i) {

410 touchPoint += touchMovement;

411 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

412 }

413

414 QVERIFY(fakeTimer->isRunning());

415

416 // Move beyond distance threshold

417 touchPoint += 3*touchMovement;

418 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

419

420 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

421

422 QVERIFY(!fakeTimer->isRunning());

423}

424

425/*

426 A gesture should be rejected if too much time has passed without any new input

427 events from it.

428 */

429void tst_DirectionalDragArea::maxSilenceTime()

430{

431 DirectionalDragArea *edgeDragArea =

432 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

433 QVERIFY(edgeDragArea != 0);

434 edgeDragArea->setRecognitionTimer(fakeTimer);

435 edgeDragArea->setAxisVelocityCalculator(velCalcWithFakeTiming);

436

437 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

438 QPointF touchPoint = initialTouchPos;

439

440 fakeTimeSource->m_msecsSinceReference = 0;

441 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

442

443 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

444

445 int neededTimeouts = qCeil((qreal)edgeDragArea->maxSilenceTime() / (qreal)fakeTimer->interval());

446 if ((edgeDragArea->maxSilenceTime() % fakeTimer->interval()) == 0) {

447 ++neededTimeouts;

448 }

449

450 // Force the periodic speed check.

451 for (int i = 0; i < neededTimeouts; ++i) {

452 fakeTimer->emitTimeout();

453

454 if (i < neededTimeouts - 1) {

455 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

456 }

457 }

458

459 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Rejected);

460}

461

462QTEST_MAIN(tst_DirectionalDragArea)

463

464#include "tst_DirectionalDragArea.moc"