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

git.iko.soy/unity8

on 8a93021 help sign in

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

407 lines 12 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 <qpa/qwindowsysteminterface.h>

18#include <QtTest>

19#include <QQmlEngine>

20#include <QQuickView>

21#include <QSharedPointer>

22#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))

23 #include <private/qquickwindow_p.h>

24#endif

26// C++ std lib

27#include <functional>

29#include <TouchGate.h>

30#include <TouchRegistry.h>

32class TestItem : public QQuickItem

33{

34 Q_OBJECT

36public:

37 QList<QSharedPointer<QTouchEvent>> touchEventsReceived;

39protected:

40 void touchEvent(QTouchEvent *event) override;

41};

43class CandidateItem : public QQuickItem

44{

45 Q_OBJECT

47public:

48 std::function<void(QTouchEvent*)> touchEventHandler;

50protected:

51 void touchEvent(QTouchEvent *event) override;

52};

54class tst_TouchGate : public QObject

55{

56 Q_OBJECT

57public:

58 tst_TouchGate(QObject *parent = nullptr);

59private Q_SLOTS:

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

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

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

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

66private:

67 void onlyCandidate_passThrough();

68 void holdsEventsUntilGainsOwnership();

69 void holdsEventsUntilGainsOwnership_data();

70 void holdsEventsUntilGainsOwnership_repeatingTouchId();

71 void dontDispacthToDisabledOrInvisibleTarget();

72 void dontDispacthToDisabledOrInvisibleTarget_data();

74private Q_SLOTS:

75 void disabledWhileHoldingTouch();

77private:

78 QQuickView *createView();

79 TouchRegistry *touchRegistry;

80 QQuickView *view;

81 QTouchDevice *device;

82};

84tst_TouchGate::tst_TouchGate(QObject *parent)

85 : QObject(parent)

86 , touchRegistry(nullptr)

87 , view(nullptr)

88 , device(nullptr)

89{

90}

92void tst_TouchGate::initTestCase()

93{

94 if (!device) {

95 device = new QTouchDevice;

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

97 QWindowSystemInterface::registerTouchDevice(device);

98 }

99}

100

101void tst_TouchGate::cleanupTestCase()

102{

103}

104

105void tst_TouchGate::init()

106{

107 touchRegistry = new TouchRegistry;

108

109 view = createView();

110 view->installEventFilter(touchRegistry);

111 view->setSource(QUrl::fromLocalFile("touchGateExample.qml"));

112 view->show();

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

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

115 qApp->processEvents();

116}

117

118void tst_TouchGate::cleanup()

119{

120 delete view;

121 view = 0;

122

123 delete touchRegistry;

124 touchRegistry = nullptr;

125}

126

127QQuickView *tst_TouchGate::createView()

128{

129 QQuickView *window = new QQuickView(0);

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

131 window->resize(720, 720);

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

133

134 return window;

135}

136

137/*

138 Simplest case. TouchGate is the only candidate for the touch point, thus it

139 will instantly gain ownership causing the event to pass through it directly to

140 its child.

141 */

142void tst_TouchGate::onlyCandidate_passThrough()

143{

144 TouchGate *touchGate = view->rootObject()->findChild<TouchGate*>("touchGate");

145 Q_ASSERT(touchGate);

146

147 TestItem *testItem = new TestItem;

148 testItem->setWidth(touchGate->width());

149 testItem->setHeight(touchGate->height());

150 testItem->setParentItem(view->rootObject());

151 testItem->setZ(0.0);

152

153 touchGate->setZ(1.0);

154 touchGate->setTargetItem(testItem);

155

156 QTest::touchEvent(view, device)

157 .press(0, QPoint(100,100));

158

159 QCOMPARE(testItem->touchEventsReceived.count(), 1);

160 QVERIFY(touchGate->m_storedEvents.isEmpty());

161}

162

163void tst_TouchGate::holdsEventsUntilGainsOwnership()

164{

165 TouchGate *touchGate = view->rootObject()->findChild<TouchGate*>("touchGate");

166 Q_ASSERT(touchGate);

167 QFETCH(bool, ownershipAfterTouchEnd);

168

169 TestItem *testItem = new TestItem;

170 testItem->setWidth(touchGate->width());

171 testItem->setHeight(touchGate->height());

172 testItem->setParentItem(view->rootObject());

173 testItem->setZ(0.0);

174

175 touchGate->setZ(1.0);

176 touchGate->setTargetItem(testItem);

177

178 // Put it in front of touchGate

179 CandidateItem *candidateItem = new CandidateItem;

180 candidateItem->setWidth(touchGate->width());

181 candidateItem->setHeight(touchGate->height());

182 candidateItem->setParentItem(view->rootObject());

183 candidateItem->setZ(2.0);

184

185 candidateItem->touchEventHandler = [&](QTouchEvent* event) {

186 touchRegistry->addCandidateOwnerForTouch(0, candidateItem);

187 event->ignore();

188 };

189

190 QTest::touchEvent(view, device)

191 .press(0, QPoint(100,100));

192

193 QCOMPARE(testItem->touchEventsReceived.count(), 0);

194

195 QTest::touchEvent(view, device)

196 .move(0, QPoint(101,101));

197

198 QCOMPARE(testItem->touchEventsReceived.count(), 0);

199

200 if (!ownershipAfterTouchEnd) {

201 touchRegistry->removeCandidateOwnerForTouch(0, candidateItem);

202#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))

203 QQuickWindowPrivate *wp = QQuickWindowPrivate::get(testItem->window());

204 wp->flushDelayedTouchEvent();

205#endif

206 // TouchGate should now open its flood gates and let testItem get all

207 // events from touch 0 produced so far

208 QCOMPARE(testItem->touchEventsReceived.count(), 2);

209 }

210

211 QTest::touchEvent(view, device)

212 .release(0, QPoint(101,101));

213

214 if (ownershipAfterTouchEnd) {

215 QCOMPARE(testItem->touchEventsReceived.count(), 0);

216 touchRegistry->removeCandidateOwnerForTouch(0, candidateItem);

217 // TouchGate should now open its flood gates and let testItem get all

218 // events from touch 0 produced so far

219 }

220

221 QCOMPARE(testItem->touchEventsReceived.count(), 3);

222

223 QVERIFY(touchGate->m_storedEvents.isEmpty());

224 QVERIFY(touchGate->m_touchInfoMap.isEmpty());

225}

226

227void tst_TouchGate::holdsEventsUntilGainsOwnership_data()

228{

229 QTest::addColumn<bool>("ownershipAfterTouchEnd");

230

231 QTest::newRow("touch end after touch ownership") << false;

232 QTest::newRow("touch ownership after touch end") << true;

233}

234

235/*

236 A touch point of id 0 starts and ends. Then the next touch point is also given

237 id 0. Check that TouchGate behaves correcly recognizing them as two distinct touch

238 points.

239

240 Note that this won't be a problem with Mir as it assigns unique ids for the touch

241 points it produces.

242 */

243void tst_TouchGate::holdsEventsUntilGainsOwnership_repeatingTouchId()

244{

245 TouchGate *touchGate = view->rootObject()->findChild<TouchGate*>("touchGate");

246 Q_ASSERT(touchGate);

247

248 TestItem *testItem = new TestItem;

249 testItem->setWidth(touchGate->width());

250 testItem->setHeight(touchGate->height());

251 testItem->setParentItem(view->rootObject());

252 testItem->setZ(0.0);

253

254 touchGate->setZ(1.0);

255 touchGate->setTargetItem(testItem);

256

257 QTest::touchEvent(view, device)

258 .press(0, QPoint(100,100));

259 QTest::touchEvent(view, device)

260 .move(0, QPoint(101,101));

261 QTest::touchEvent(view, device)

262 .release(0, QPoint(101,101));

263

264 QCOMPARE(testItem->touchEventsReceived.count(), 3);

265 testItem->touchEventsReceived.clear();

266

267 // Put it in front of touchGate

268 CandidateItem *candidateItem = new CandidateItem;

269 candidateItem->setWidth(touchGate->width());

270 candidateItem->setHeight(touchGate->height());

271 candidateItem->setParentItem(view->rootObject());

272 candidateItem->setZ(2.0);

273

274 candidateItem->touchEventHandler = [&](QTouchEvent* event) {

275 touchRegistry->addCandidateOwnerForTouch(0, candidateItem);

276 event->ignore();

277 };

278

279 // A brand new touch, but with the same id as the previous one

280 QTest::touchEvent(view, device)

281 .press(0, QPoint(200,200));

282 QTest::touchEvent(view, device)

283 .move(0, QPoint(201,201));

284 QTest::touchEvent(view, device)

285 .release(0, QPoint(201,201));

286

287 QCOMPARE(testItem->touchEventsReceived.count(), 0);

288

289 touchRegistry->requestTouchOwnership(0, candidateItem);

290

291 QCOMPARE(testItem->touchEventsReceived.count(), 0);

292

293 QVERIFY(touchGate->m_storedEvents.isEmpty());

294}

295

296void tst_TouchGate::dontDispacthToDisabledOrInvisibleTarget()

297{

298 TouchGate *touchGate = view->rootObject()->findChild<TouchGate*>("touchGate");

299 Q_ASSERT(touchGate);

300

301 TestItem *testItem = new TestItem;

302 testItem->setWidth(touchGate->width());

303 testItem->setHeight(touchGate->height());

304 testItem->setParentItem(view->rootObject());

305 testItem->setZ(0.0);

306

307 QFETCH(bool, isEnabled);

308 testItem->setEnabled(isEnabled);

309

310 QFETCH(bool, isVisible);

311 testItem->setVisible(isVisible);

312

313 touchGate->setZ(1.0);

314 touchGate->setTargetItem(testItem);

315

316 QTest::touchEvent(view, device)

317 .press(0, QPoint(100,100));

318

319 QCOMPARE(testItem->touchEventsReceived.count(), 0);

320 QVERIFY(touchGate->m_storedEvents.isEmpty());

321}

322

323void tst_TouchGate::dontDispacthToDisabledOrInvisibleTarget_data()

324{

325 QTest::addColumn<bool>("isEnabled");

326 QTest::addColumn<bool>("isVisible");

327

328 QTest::newRow("disabled visible") << false << true;

329 QTest::newRow("enabled invisible") << true << false;

330 QTest::newRow("disabled invisible") << false << false;

331}

332

333void tst_TouchGate::disabledWhileHoldingTouch()

334{

335 TouchGate *touchGate = view->rootObject()->findChild<TouchGate*>("touchGate");

336 Q_ASSERT(touchGate);

337

338 TestItem *testItem = new TestItem;

339 testItem->setWidth(touchGate->width());

340 testItem->setHeight(touchGate->height());

341 testItem->setParentItem(view->rootObject());

342 testItem->setZ(0.0);

343

344 touchGate->setZ(1.0);

345 touchGate->setTargetItem(testItem);

346

347 QTest::touchEvent(view, device)

348 .press(0, QPoint(100,100));

349

350 QCOMPARE(testItem->touchEventsReceived.count(), 1);

351 testItem->touchEventsReceived.clear();

352

353 touchGate->setEnabled(false);

354

355 QTest::touchEvent(view, device)

356 .move(0, QPoint(101,101));

357

358 // Nothing new came as TouchGate didn't even get it because it's disabled

359 QCOMPARE(testItem->touchEventsReceived.count(), 0);

360

361 touchGate->setEnabled(true);

362

363 QTest::touchEvent(view, device)

364 .move(0, QPoint(102,102));

365

366 QTest::touchEvent(view, device)

367 .release(0, QPoint(102,102));

368

369 // Nothing new came because TouchGate has already discarded touch 0

370 QCOMPARE(testItem->touchEventsReceived.count(), 0);

371

372 QTest::touchEvent(view, device)

373 .press(1, QPoint(200,200));

374

375 QCOMPARE(testItem->touchEventsReceived.count(), 1);

376 {

377 // it got only the new touch point.

378 QSharedPointer<QTouchEvent> touchEvent = testItem->touchEventsReceived[0];

379 QCOMPARE(touchEvent->touchPoints().count(), 1);

380 QCOMPARE(touchEvent->touchPoints()[0].id(), 1);

381 }

382}

383

384///////////// TestItem /////////////////////////////////////////////////////////////

385

386void TestItem::touchEvent(QTouchEvent *event)

387{

388 QTouchEvent *clonedEvent = new QTouchEvent(event->type(),

389 event->device(),

390 event->modifiers(),

391 event->touchPointStates(),

392 event->touchPoints());

393

394 touchEventsReceived.append(QSharedPointer<QTouchEvent>(clonedEvent));

395}

396

397///////////// CandidateItem /////////////////////////////////////////////////////////////

398

399void CandidateItem::touchEvent(QTouchEvent *event)

400{

401 touchEventHandler(event);

402}

403

404

405QTEST_MAIN(tst_TouchGate)

406

407#include "tst_TouchGate.moc"