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

git.iko.soy/unity8

on 436b607 help sign in

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

352 lines 10 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

66 void onlyCandidate_passThrough();

67 void holdsEventsUntilGainsOwnership();

68 void holdsEventsUntilGainsOwnership_data();

69 void holdsEventsUntilGainsOwnership_repeatingTouchId();

70 void dontDispacthToDisabledOrInvisibleTarget();

71 void dontDispacthToDisabledOrInvisibleTarget_data();

73private:

74 QQuickView *createView();

75 TouchRegistry *touchRegistry;

76 QQuickView *view;

77 QTouchDevice *device;

78};

80tst_TouchGate::tst_TouchGate(QObject *parent)

81 : QObject(parent)

82 , touchRegistry(nullptr)

83 , view(nullptr)

84 , device(nullptr)

85{

86}

88void tst_TouchGate::initTestCase()

89{

90 if (!device) {

91 device = new QTouchDevice;

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

93 QWindowSystemInterface::registerTouchDevice(device);

94 }

95}

97void tst_TouchGate::cleanupTestCase()

98{

99}

100

101void tst_TouchGate::init()

102{

103 touchRegistry = new TouchRegistry;

104

105 view = createView();

106 view->installEventFilter(touchRegistry);

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

108 view->show();

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

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

111 qApp->processEvents();

112}

113

114void tst_TouchGate::cleanup()

115{

116 delete view;

117 view = 0;

118

119 delete touchRegistry;

120 touchRegistry = nullptr;

121}

122

123QQuickView *tst_TouchGate::createView()

124{

125 QQuickView *window = new QQuickView(0);

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

127 window->resize(720, 720);

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

129

130 return window;

131}

132

133/*

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

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

136 its child.

137 */

138void tst_TouchGate::onlyCandidate_passThrough()

139{

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

141 Q_ASSERT(touchGate);

142

143 TestItem *testItem = new TestItem;

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

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

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

147 testItem->setZ(0.0);

148

149 touchGate->setZ(1.0);

150 touchGate->setTargetItem(testItem);

151

152 QTest::touchEvent(view, device)

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

154

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

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

157}

158

159void tst_TouchGate::holdsEventsUntilGainsOwnership()

160{

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

162 Q_ASSERT(touchGate);

163 QFETCH(bool, ownershipAfterTouchEnd);

164

165 TestItem *testItem = new TestItem;

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

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

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

169 testItem->setZ(0.0);

170

171 touchGate->setZ(1.0);

172 touchGate->setTargetItem(testItem);

173

174 // Put it in front of touchGate

175 CandidateItem *candidateItem = new CandidateItem;

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

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

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

179 candidateItem->setZ(2.0);

180

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

182 touchRegistry->addCandidateOwnerForTouch(0, candidateItem);

183 event->ignore();

184 };

185

186 QTest::touchEvent(view, device)

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

188

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

190

191 QTest::touchEvent(view, device)

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

193

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

195

196 if (!ownershipAfterTouchEnd) {

197 touchRegistry->removeCandidateOwnerForTouch(0, candidateItem);

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

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

200 wp->flushDelayedTouchEvent();

201#endif

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

203 // events from touch 0 produced so far

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

205 }

206

207 QTest::touchEvent(view, device)

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

209

210 if (ownershipAfterTouchEnd) {

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

212 touchRegistry->removeCandidateOwnerForTouch(0, candidateItem);

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

214 // events from touch 0 produced so far

215 }

216

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

218

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

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

221}

222

223void tst_TouchGate::holdsEventsUntilGainsOwnership_data()

224{

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

226

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

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

229}

230

231/*

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

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

234 points.

235

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

237 points it produces.

238 */

239void tst_TouchGate::holdsEventsUntilGainsOwnership_repeatingTouchId()

240{

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

242 Q_ASSERT(touchGate);

243

244 TestItem *testItem = new TestItem;

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

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

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

248 testItem->setZ(0.0);

249

250 touchGate->setZ(1.0);

251 touchGate->setTargetItem(testItem);

252

253 QTest::touchEvent(view, device)

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

255 QTest::touchEvent(view, device)

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

257 QTest::touchEvent(view, device)

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

259

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

261 testItem->touchEventsReceived.clear();

262

263 // Put it in front of touchGate

264 CandidateItem *candidateItem = new CandidateItem;

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

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

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

268 candidateItem->setZ(2.0);

269

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

271 touchRegistry->addCandidateOwnerForTouch(0, candidateItem);

272 event->ignore();

273 };

274

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

276 QTest::touchEvent(view, device)

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

278 QTest::touchEvent(view, device)

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

280 QTest::touchEvent(view, device)

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

282

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

284

285 touchRegistry->requestTouchOwnership(0, candidateItem);

286

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

288

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

290}

291

292void tst_TouchGate::dontDispacthToDisabledOrInvisibleTarget()

293{

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

295 Q_ASSERT(touchGate);

296

297 TestItem *testItem = new TestItem;

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

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

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

301 testItem->setZ(0.0);

302

303 QFETCH(bool, isEnabled);

304 testItem->setEnabled(isEnabled);

305

306 QFETCH(bool, isVisible);

307 testItem->setVisible(isVisible);

308

309 touchGate->setZ(1.0);

310 touchGate->setTargetItem(testItem);

311

312 QTest::touchEvent(view, device)

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

314

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

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

317}

318

319void tst_TouchGate::dontDispacthToDisabledOrInvisibleTarget_data()

320{

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

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

323

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

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

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

327}

328

329///////////// TestItem /////////////////////////////////////////////////////////////

330

331void TestItem::touchEvent(QTouchEvent *event)

332{

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

334 event->device(),

335 event->modifiers(),

336 event->touchPointStates(),

337 event->touchPoints());

338

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

340}

341

342///////////// CandidateItem /////////////////////////////////////////////////////////////

343

344void CandidateItem::touchEvent(QTouchEvent *event)

345{

346 touchEventHandler(event);

347}

348

349

350QTEST_MAIN(tst_TouchGate)

351

352#include "tst_TouchGate.moc"