tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 740e437 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp

1394 lines 54 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 "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QtTestGui>

23#pragma GCC diagnostic push

24#pragma GCC diagnostic ignored "-pedantic"

25#include <private/qquicklistmodel_p.h>

26#include <private/qquickanimation_p.h>

27#include <private/qquickitem_p.h>

28#pragma GCC diagnostic pop

30class ListViewWithPageHeaderTest : public QObject

31{

32 Q_OBJECT

34private:

35 void verifyItem(int visibleIndex, qreal pos, qreal height, bool culled)

36 {

37 ListViewWithPageHeader::ListItem *item = lvwph->m_visibleItems[visibleIndex];

38 QTRY_COMPARE(item->y(), pos);

39 QTRY_COMPARE(item->height(), height);

40 QCOMPARE(QQuickItemPrivate::get(item->m_item)->culled, culled);

41 }

43 void changeContentY(qreal change)

44 {

45 const qreal dest = lvwph->contentY() + change;

46 if (dest > lvwph->contentY()) {

47 const qreal jump = 25;

48 while (lvwph->contentY() + jump < dest) {

49 lvwph->setContentY(lvwph->contentY() + jump);

50 QTest::qWait(1);

51 }

52 } else {

53 const qreal jump = -25;

54 while (lvwph->contentY() + jump > dest) {

55 lvwph->setContentY(lvwph->contentY() + jump);

56 QTest::qWait(1);

57 }

58 }

59 lvwph->setContentY(dest);

60 QTest::qWait(1);

61 }

63 void scrollToTop()

64 {

65 const qreal jump = -25;

66 while (!lvwph->isAtYBeginning()) {

67 if (lvwph->contentY() + jump > -lvwph->minYExtent()) {

68 lvwph->setContentY(lvwph->contentY() + jump);

69 } else {

70 lvwph->setContentY(lvwph->contentY() - 1);

71 }

72 QTest::qWait(1);

73 }

74 }

76 void scrollToBottom()

77 {

78 const qreal jump = 25;

79 while (!lvwph->isAtYEnd()) {

80 if (lvwph->contentY() + lvwph->height() + jump < lvwph->contentHeight()) {

81 lvwph->setContentY(lvwph->contentY() + jump);

82 } else {

83 lvwph->setContentY(lvwph->contentY() + 1);

84 }

85 QTest::qWait(1);

86 }

87 }

89 void verifyInitialTopPosition()

90 {

91 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

92 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

93 verifyItem(0, 50., 150., false);

94 verifyItem(1, 200., 200., false);

95 verifyItem(2, 400., 350., false);

96 verifyItem(3, 750., 350., true);

97 QCOMPARE(lvwph->m_minYExtent, 0.);

98 QCOMPARE(lvwph->m_clipItem->y(), 0.);

99 QCOMPARE(lvwph->m_clipItem->clip(), false);

100 QCOMPARE(lvwph->m_headerItem->y(), 0.);

101 QCOMPARE(lvwph->m_headerItem->height(), 50.);

102 QCOMPARE(lvwph->contentY(), 0.);

103 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

104 }

105

106private Q_SLOTS:

107

108 void initTestCase()

109 {

110 }

111

112 void init()

113 {

114 view = new QQuickView();

115 view->engine()->addImportPath(BUILT_PLUGINS_DIR);

116 view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test.qml"));

117 lvwph = dynamic_cast<ListViewWithPageHeader*>(view->rootObject()->findChild<QQuickFlickable*>());

118 model = view->rootObject()->findChild<QQuickListModel*>();

119 otherDelegate = view->rootObject()->findChild<QQmlComponent*>();

120 QVERIFY(lvwph);

121 QVERIFY(model);

122 QVERIFY(otherDelegate);

123 view->show();

124 QTest::qWaitForWindowExposed(view);

125

126 verifyInitialTopPosition();

127 }

128

129 void cleanup()

130 {

131 delete view;

132 }

133

134 void testCreationDeletion()

135 {

136 // Nothing, init/cleanup already tests this

137 }

138

139 void testDrag1PixelUp()

140 {

141 lvwph->setContentY(lvwph->contentY() + 1);

142 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

143 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

144 verifyItem(0, 49., 150., false);

145 verifyItem(1, 199., 200., false);

146 verifyItem(2, 399., 350., false);

147 verifyItem(3, 749., 350., true);

148 QCOMPARE(lvwph->m_minYExtent, 0.);

149 QCOMPARE(lvwph->m_clipItem->y(), 1.);

150 QCOMPARE(lvwph->m_clipItem->clip(), false);

151 QCOMPARE(lvwph->m_headerItem->y(), 0.);

152 QCOMPARE(lvwph->m_headerItem->height(), 50.);

153 QCOMPARE(lvwph->contentY(), 1.);

154 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

155 }

156

157 void testHeaderDetachDragDown()

158 {

159 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

160 QTest::qWait(100);

161 QTest::mouseMove(view, QPoint(0, 5));

162 QTest::qWait(100);

163 QTest::mouseMove(view, QPoint(0, 10));

164 QTest::qWait(100);

165 QTest::mouseMove(view, QPoint(0, 15));

166 QTest::qWait(100);

167 QTest::mouseMove(view, QPoint(0, 20));

168 QTest::qWait(100);

169 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

170 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

171 verifyItem(0, 55., 150., false);

172 verifyItem(1, 205., 200., false);

173 verifyItem(2, 405., 350., false);

174 verifyItem(3, 755., 350., true);

175 QCOMPARE(lvwph->m_minYExtent, 0.);

176 QCOMPARE(lvwph->m_clipItem->y(), -5.);

177 QCOMPARE(lvwph->m_clipItem->clip(), false);

178 QCOMPARE(lvwph->m_headerItem->y(), -5.);

179 QCOMPARE(lvwph->m_headerItem->height(), 55.);

180 QCOMPARE(lvwph->contentY(), -5.);

181 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

182

183 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

184

185 verifyInitialTopPosition();

186 }

187

188 void testDrag375PixelUp()

189 {

190 changeContentY(375);

191 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

192 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

193 verifyItem(0, -325., 150., true);

194 verifyItem(1, -175, 200., false);

195 verifyItem(2, 25, 350., false);

196 verifyItem(3, 375, 350., false);

197 verifyItem(4, 725, 350., true);

198 QCOMPARE(lvwph->m_minYExtent, 0.);

199 QCOMPARE(lvwph->m_clipItem->y(), 375.);

200 QCOMPARE(lvwph->m_clipItem->clip(), false);

201 QCOMPARE(lvwph->m_headerItem->y(), 0.);

202 QCOMPARE(lvwph->m_headerItem->height(), 50.);

203 QCOMPARE(lvwph->contentY(), 375.);

204 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

205 }

206

207 void testDrag520PixelUp()

208 {

209 changeContentY(520);

210 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

211 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

212 verifyItem(0, -320., 200., true);

213 verifyItem(1, -120, 350., false);

214 verifyItem(2, 230, 350., false);

215 verifyItem(3, 580, 350., true);

216 // Just here as first check against m_minYExtent when m_firstVisibleIndex is not 0

217 // We as humans know that m_minYExtent will be 0 but since the first delegate is not there anymore

218 // we have to estimate its size, the average item height is 312.5 which is 162.5 more than the

219 // "real" size of 150 and that's why the m_minYExtent has that "peculiar" value

220 // It's fine since what it means is that we could scroll more up than the original position

221 // but we will recalculate m_minYExtent when the item 0 is created and set it correctly

222 QCOMPARE(lvwph->m_minYExtent, 162.5);

223 QCOMPARE(lvwph->m_clipItem->y(), 520.);

224 QCOMPARE(lvwph->m_clipItem->clip(), false);

225 QCOMPARE(lvwph->m_headerItem->y(), 0.);

226 QCOMPARE(lvwph->m_headerItem->height(), 50.);

227 QCOMPARE(lvwph->contentY(), 520.);

228 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

229 }

230

231 void testDragHeaderUpThenShow()

232 {

233 changeContentY(120);

234 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

235 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

236 verifyItem(0, -70., 150., false);

237 verifyItem(1, 80., 200., false);

238 verifyItem(2, 280., 350., false);

239 verifyItem(3, 630., 350., true);

240 QCOMPARE(lvwph->m_minYExtent, 0.);

241 QCOMPARE(lvwph->m_clipItem->y(), 120.);

242 QCOMPARE(lvwph->m_clipItem->clip(), false);

243 QCOMPARE(lvwph->m_headerItem->y(), 0.);

244 QCOMPARE(lvwph->m_headerItem->height(), 50.);

245 QCOMPARE(lvwph->contentY(), 120.);

246 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

247

248 changeContentY(-30);

249 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

250 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

251 verifyItem(0, -70., 150., false);

252 verifyItem(1, 80., 200., false);

253 verifyItem(2, 280., 350., false);

254 verifyItem(3, 630., 350., true);

255 QCOMPARE(lvwph->m_minYExtent, 0.);

256 QCOMPARE(lvwph->m_clipItem->y(), 120.);

257 QCOMPARE(lvwph->m_clipItem->clip(), true);

258 QTRY_COMPARE(lvwph->m_headerItem->y(), 70.);

259 QCOMPARE(lvwph->m_headerItem->height(), 50.);

260 QCOMPARE(lvwph->contentY(), 90.);

261 QCOMPARE(lvwph->m_headerItemShownHeight, 30.);

262 }

263

264 void testDragHeaderUpThenShowWithoutHidingTotally()

265 {

266 changeContentY(10);

267 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

268 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

269 verifyItem(0, 40., 150., false);

270 verifyItem(1, 190., 200., false);

271 verifyItem(2, 390., 350., false);

272 verifyItem(3, 740., 350., true);

273 QCOMPARE(lvwph->m_minYExtent, 0.);

274 QCOMPARE(lvwph->m_clipItem->y(), 10.);

275 QCOMPARE(lvwph->m_clipItem->clip(), false);

276 QCOMPARE(lvwph->m_headerItem->y(), 0.);

277 QCOMPARE(lvwph->m_headerItem->height(), 50.);

278 QCOMPARE(lvwph->contentY(), 10.);

279 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

280

281 changeContentY(-1);

282

283 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

284 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

285 verifyItem(0, 41., 150., false);

286 verifyItem(1, 191., 200., false);

287 verifyItem(2, 391., 350., false);

288 verifyItem(3, 741., 350., true);

289 QCOMPARE(lvwph->m_minYExtent, 0.);

290 QCOMPARE(lvwph->m_clipItem->y(), 9.);

291 QCOMPARE(lvwph->m_clipItem->clip(), false);

292 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

293 QCOMPARE(lvwph->m_headerItem->height(), 50.);

294 QCOMPARE(lvwph->contentY(), 9.);

295 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

296 }

297

298 void testPositionAtBeginningIndex0Visible()

299 {

300 changeContentY(375);

301 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

302 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

303 verifyItem(0, -325., 150., true);

304 verifyItem(1, -175, 200., false);

305 verifyItem(2, 25, 350., false);

306 verifyItem(3, 375, 350., false);

307 verifyItem(4, 725, 350., true);

308 QCOMPARE(lvwph->m_minYExtent, 0.);

309 QCOMPARE(lvwph->m_clipItem->y(), 375.);

310 QCOMPARE(lvwph->m_clipItem->clip(), false);

311 QCOMPARE(lvwph->m_headerItem->y(), 0.);

312 QCOMPARE(lvwph->m_headerItem->height(), 50.);

313 QCOMPARE(lvwph->contentY(), 375.);

314 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

315

316 lvwph->positionAtBeginning();

317

318 verifyInitialTopPosition();

319 }

320

321 void testPositionAtBeginningIndex0NotVisible()

322 {

323 changeContentY(520);

324 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

325 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

326 verifyItem(0, -320., 200., true);

327 verifyItem(1, -120, 350., false);

328 verifyItem(2, 230, 350., false);

329 verifyItem(3, 580, 350., true);

330 QCOMPARE(lvwph->m_minYExtent, 162.5);

331 QCOMPARE(lvwph->m_clipItem->y(), 520.);

332 QCOMPARE(lvwph->m_clipItem->clip(), false);

333 QCOMPARE(lvwph->m_headerItem->y(), 0.);

334 QCOMPARE(lvwph->m_headerItem->height(), 50.);

335 QCOMPARE(lvwph->contentY(), 520.);

336 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

337

338 lvwph->positionAtBeginning();

339

340 verifyInitialTopPosition();

341 }

342

343 void testIndex0GrowOnScreen()

344 {

345 model->setProperty(0, "size", 400);

346

347 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

348 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

349 verifyItem(0, 50., 400., false);

350 verifyItem(1, 450., 200., false);

351 verifyItem(2, 650., 350., true);

352 QCOMPARE(lvwph->m_minYExtent, 0.);

353 QCOMPARE(lvwph->m_clipItem->y(), 0.);

354 QCOMPARE(lvwph->m_clipItem->clip(), false);

355 QCOMPARE(lvwph->m_headerItem->y(), 0.);

356 QCOMPARE(lvwph->m_headerItem->height(), 50.);

357 QCOMPARE(lvwph->contentY(), 0.);

358 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

359 }

360

361 void testIndex0GrowOffScreen()

362 {

363 changeContentY(375);

364 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

365 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

366 verifyItem(0, -325., 150., true);

367 verifyItem(1, -175, 200., false);

368 verifyItem(2, 25, 350., false);

369 verifyItem(3, 375, 350., false);

370 verifyItem(4, 725, 350., true);

371 QCOMPARE(lvwph->m_minYExtent, 0.);

372 QCOMPARE(lvwph->m_clipItem->y(), 375.);

373 QCOMPARE(lvwph->m_clipItem->clip(), false);

374 QCOMPARE(lvwph->m_headerItem->y(), 0.);

375 QCOMPARE(lvwph->m_headerItem->height(), 50.);

376 QCOMPARE(lvwph->contentY(), 375.);

377 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

378

379 model->setProperty(0, "size", 400);

380

381 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

382 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

383 verifyItem(0, -575., 400., true);

384 verifyItem(1, -175, 200., false);

385 verifyItem(2, 25, 350., false);

386 verifyItem(3, 375, 350., false);

387 verifyItem(4, 725, 350., true);

388 QCOMPARE(lvwph->m_minYExtent, 250.);

389 QCOMPARE(lvwph->m_clipItem->y(), 375.);

390 QCOMPARE(lvwph->m_clipItem->clip(), false);

391 QCOMPARE(lvwph->m_headerItem->y(), 0.);

392 QCOMPARE(lvwph->m_headerItem->height(), 50.);

393 QCOMPARE(lvwph->contentY(), 375.);

394 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

395

396 scrollToTop();

397

398 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

399 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

400 verifyItem(0, 50., 400., false);

401 verifyItem(1, 450, 200., false);

402 verifyItem(2, 650, 350., true);

403 QCOMPARE(lvwph->m_minYExtent, 250.);

404 QCOMPARE(lvwph->m_clipItem->y(), -250.);

405 QCOMPARE(lvwph->m_clipItem->clip(), false);

406 QCOMPARE(lvwph->m_headerItem->y(), -250.);

407 QCOMPARE(lvwph->m_headerItem->height(), 50.);

408 QCOMPARE(lvwph->contentY(), -250.);

409 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

410

411 changeContentY(30);

412

413 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

414 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

415 verifyItem(0, 20., 400., false);

416 verifyItem(1, 420, 200., false);

417 verifyItem(2, 620, 350., true);

418 QCOMPARE(lvwph->m_minYExtent, 250.);

419 QCOMPARE(lvwph->m_clipItem->y(), -220.);

420 QCOMPARE(lvwph->m_clipItem->clip(), false);

421 QCOMPARE(lvwph->m_headerItem->y(), -250.);

422 QCOMPARE(lvwph->m_headerItem->height(), 50.);

423 QCOMPARE(lvwph->contentY(), -220.);

424 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

425 }

426

427 void testIndex0GrowNotCreated()

428 {

429 changeContentY(520);

430 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

431 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

432 verifyItem(0, -320., 200., true);

433 verifyItem(1, -120, 350., false);

434 verifyItem(2, 230, 350., false);

435 verifyItem(3, 580, 350., true);

436 QCOMPARE(lvwph->m_minYExtent, 162.5);

437 QCOMPARE(lvwph->m_clipItem->y(), 520.);

438 QCOMPARE(lvwph->m_clipItem->clip(), false);

439 QCOMPARE(lvwph->m_headerItem->y(), 0.);

440 QCOMPARE(lvwph->m_headerItem->height(), 50.);

441 QCOMPARE(lvwph->contentY(), 520.);

442 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

443

444 model->setProperty(0, "size", 400);

445

446 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

447 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

448 verifyItem(0, -320., 200., true);

449 verifyItem(1, -120, 350., false);

450 verifyItem(2, 230, 350., false);

451 verifyItem(3, 580, 350., true);

452 QCOMPARE(lvwph->m_minYExtent, 162.5);

453 QCOMPARE(lvwph->m_clipItem->y(), 520.);

454 QCOMPARE(lvwph->m_clipItem->clip(), false);

455 QCOMPARE(lvwph->m_headerItem->y(), 0.);

456 QCOMPARE(lvwph->m_headerItem->height(), 50.);

457 QCOMPARE(lvwph->contentY(), 520.);

458 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

459

460 scrollToTop();

461

462 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

463 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

464 verifyItem(0, 50., 400., false);

465 verifyItem(1, 450, 200., false);

466 verifyItem(2, 650, 350., true);

467 QCOMPARE(lvwph->m_minYExtent, 250.);

468 QCOMPARE(lvwph->m_clipItem->y(), -250.);

469 QCOMPARE(lvwph->m_clipItem->clip(), false);

470 QCOMPARE(lvwph->m_headerItem->y(), -250.);

471 QCOMPARE(lvwph->m_headerItem->height(), 50.);

472 QCOMPARE(lvwph->contentY(), -250.);

473 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

474 }

475

476 void testShowHideShowHeaderAtBottom()

477 {

478 scrollToBottom();

479 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

480 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

481 verifyItem(0, -508., 350., true);

482 verifyItem(1, -158, 350., false);

483 verifyItem(2, 192, 350., false);

484 QCOMPARE(lvwph->m_minYExtent, 350.);

485 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

486 QCOMPARE(lvwph->m_clipItem->clip(), false);

487 QCOMPARE(lvwph->m_headerItem->y(), 0.);

488 QCOMPARE(lvwph->m_headerItem->height(), 50.);

489 QCOMPARE(lvwph->contentY(), 1258.);

490 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

491

492 changeContentY(-30);

493 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

494 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

495 verifyItem(0, -508., 350., true);

496 verifyItem(1, -158, 350., false);

497 verifyItem(2, 192, 350., false);

498 QCOMPARE(lvwph->m_minYExtent, 350.);

499 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

500 QCOMPARE(lvwph->m_clipItem->clip(), true);

501 QCOMPARE(lvwph->m_headerItem->y(), 1208.);

502 QCOMPARE(lvwph->m_headerItem->height(), 50.);

503 QCOMPARE(lvwph->contentY(), 1228.);

504 QCOMPARE(lvwph->m_headerItemShownHeight, 30.);

505

506 changeContentY(30);

507 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

508 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

509 verifyItem(0, -508., 350., true);

510 verifyItem(1, -158, 350., false);

511 verifyItem(2, 192, 350., false);

512 QCOMPARE(lvwph->m_minYExtent, 350.);

513 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

514 QCOMPARE(lvwph->m_clipItem->clip(), false);

515 QCOMPARE(lvwph->m_headerItem->y(), -350.);

516 QCOMPARE(lvwph->m_headerItem->height(), 50.);

517 QCOMPARE(lvwph->contentY(), 1258.);

518 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

519

520 changeContentY(-30);

521 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

522 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

523 verifyItem(0, -508., 350., true);

524 verifyItem(1, -158, 350., false);

525 verifyItem(2, 192, 350., false);

526 QCOMPARE(lvwph->m_minYExtent, 350.);

527 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

528 QCOMPARE(lvwph->m_clipItem->clip(), true);

529 QCOMPARE(lvwph->m_headerItem->y(), 1208.);

530 QCOMPARE(lvwph->m_headerItem->height(), 50.);

531 QCOMPARE(lvwph->contentY(), 1228.);

532 QCOMPARE(lvwph->m_headerItemShownHeight, 30.);

533 }

534

535 void testChangeDelegateAtBottom()

536 {

537 scrollToBottom();

538 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

539 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

540 verifyItem(0, -508., 350., true);

541 verifyItem(1, -158, 350., false);

542 verifyItem(2, 192, 350., false);

543 QCOMPARE(lvwph->m_minYExtent, 350.);

544 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

545 QCOMPARE(lvwph->m_clipItem->clip(), false);

546 QCOMPARE(lvwph->m_headerItem->y(), 0.);

547 QCOMPARE(lvwph->m_headerItem->height(), 50.);

548 QCOMPARE(lvwph->contentY(), 1258.);

549 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

550

551 lvwph->setDelegate(otherDelegate);

552

553 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

554 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

555 verifyItem(0, 50., 35., false);

556 verifyItem(1, 85, 35., false);

557 verifyItem(2, 120, 35., false);

558 verifyItem(3, 155, 35., false);

559 verifyItem(4, 190, 35., false);

560 verifyItem(5, 225, 35., false);

561 QCOMPARE(lvwph->m_minYExtent, 0.);

562 QCOMPARE(lvwph->m_clipItem->y(), 0.);

563 QCOMPARE(lvwph->m_clipItem->clip(), false);

564 QCOMPARE(lvwph->m_headerItem->y(), 0.);

565 QCOMPARE(lvwph->m_headerItem->height(), 50.);

566 QCOMPARE(lvwph->contentY(), 0.);

567 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

568 }

569

570 void testSetEmptyHeaderAtTop()

571 {

572 lvwph->setHeader(nullptr);

573

574 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

575 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

576 verifyItem(0, 0., 150., false);

577 verifyItem(1, 150., 200., false);

578 verifyItem(2, 350., 350., false);

579 verifyItem(3, 700., 350., true);

580 QCOMPARE(lvwph->m_minYExtent, 0.);

581 QCOMPARE(lvwph->m_clipItem->y(), 0.);

582 QCOMPARE(lvwph->m_clipItem->clip(), false);

583 QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);

584 QCOMPARE(lvwph->contentY(), 0.);

585 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

586 }

587

588 void testSetEmptyHeaderAtBottom()

589 {

590 scrollToBottom();

591 lvwph->setHeader(nullptr);

592

593 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

594 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

595 verifyItem(0, -508., 350., true);

596 verifyItem(1, -158, 350., false);

597 verifyItem(2, 192, 350., false);

598 QCOMPARE(lvwph->m_minYExtent, 300.);

599 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

600 QCOMPARE(lvwph->m_clipItem->clip(), false);

601 QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);

602 QCOMPARE(lvwph->contentY(), 1258.);

603 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

604

605 scrollToTop();

606

607 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

608 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

609 verifyItem(0, 0., 150., false);

610 verifyItem(1, 150., 200., false);

611 verifyItem(2, 350., 350., false);

612 verifyItem(3, 700., 350., true);

613 QCOMPARE(lvwph->m_minYExtent, -50.);

614 QCOMPARE(lvwph->m_clipItem->y(), 50.);

615 QCOMPARE(lvwph->m_clipItem->clip(), false);

616 QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);

617 QCOMPARE(lvwph->contentY(), 50.);

618 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

619 }

620

621 void testSetEmptyHeaderWhenPartlyShownClipped()

622 {

623 scrollToBottom();

624 changeContentY(-30);

625 lvwph->setHeader(nullptr);

626

627 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

628 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

629 verifyItem(0, -508., 350., true);

630 verifyItem(1, -158, 350., false);

631 verifyItem(2, 192, 350., false);

632 QCOMPARE(lvwph->m_minYExtent, 330.);

633 QCOMPARE(lvwph->m_clipItem->y(), 1228.);

634 QCOMPARE(lvwph->m_clipItem->clip(), false);

635 QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);

636 QCOMPARE(lvwph->contentY(), 1228.);

637 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

638 QTRY_VERIFY(lvwph->isAtYEnd());

639

640 scrollToTop();

641

642 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

643 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

644 verifyItem(0, 0., 150., false);

645 verifyItem(1, 150., 200., false);

646 verifyItem(2, 350., 350., false);

647 verifyItem(3, 700., 350., true);

648 QCOMPARE(lvwph->m_minYExtent, -20.);

649 QCOMPARE(lvwph->m_clipItem->y(), 20.);

650 QCOMPARE(lvwph->m_clipItem->clip(), false);

651 QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);

652 QCOMPARE(lvwph->contentY(), 20.);

653 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

654 }

655

656 void testSetEmptyHeaderWhenPartlyShownNotClipped()

657 {

658 changeContentY(30);

659 lvwph->setHeader(nullptr);

660

661 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

662 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

663 verifyItem(0, -30., 150., false);

664 verifyItem(1, 120., 200., false);

665 verifyItem(2, 320., 350., false);

666 verifyItem(3, 670., 350., true);

667 QCOMPARE(lvwph->m_minYExtent, 0.);

668 QCOMPARE(lvwph->m_clipItem->y(), 30.);

669 QCOMPARE(lvwph->m_clipItem->clip(), false);

670 QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);

671 QCOMPARE(lvwph->contentY(), 30.);

672 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

673 }

674

675 void testSetNullDelegate()

676 {

677 lvwph->setDelegate(nullptr);

678

679 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

680 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

681 QCOMPARE(lvwph->m_minYExtent, 0.);

682 QCOMPARE(lvwph->m_clipItem->y(), 0.);

683 QCOMPARE(lvwph->m_clipItem->clip(), false);

684 QCOMPARE(lvwph->m_headerItem->y(), 0.);

685 QCOMPARE(lvwph->m_headerItem->height(), 50.);

686 QCOMPARE(lvwph->contentY(), 0.);

687 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

688 QTRY_COMPARE(lvwph->contentHeight(), 50.);

689 QVERIFY(lvwph->isAtYBeginning());

690 QVERIFY(lvwph->isAtYEnd());

691 }

692

693 void testInsertItems()

694 {

695 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));

696 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));

697

698 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

699 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

700 verifyItem(0, 50., 150., false);

701 verifyItem(1, 200., 125., false);

702 verifyItem(2, 325., 100., false);

703 verifyItem(3, 425., 200., false);

704 verifyItem(4, 625., 350., true);

705 QCOMPARE(lvwph->m_minYExtent, 0.);

706 QCOMPARE(lvwph->m_clipItem->y(), 0.);

707 QCOMPARE(lvwph->m_clipItem->clip(), false);

708 QCOMPARE(lvwph->m_headerItem->y(), 0.);

709 QCOMPARE(lvwph->m_headerItem->height(), 50.);

710 QCOMPARE(lvwph->contentY(), 0.);

711 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

712 }

713

714 void testInsertItemsOnNotShownPosition()

715 {

716 changeContentY(700);

717

718 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

719 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

720 verifyItem(0, -300., 350., false);

721 verifyItem(1, 50, 350., false);

722 verifyItem(2, 400, 350., false);

723 verifyItem(3, 750, 350., true);

724 QCOMPARE(lvwph->m_minYExtent, 350.);

725 QCOMPARE(lvwph->m_clipItem->y(), 700.);

726 QCOMPARE(lvwph->m_clipItem->clip(), false);

727 QCOMPARE(lvwph->m_headerItem->y(), 0.);

728 QCOMPARE(lvwph->m_headerItem->height(), 50.);

729 QCOMPARE(lvwph->contentY(), 700.);

730 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

731

732 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));

733 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));

734

735 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

736 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

737 verifyItem(0, -300., 350., false);

738 verifyItem(1, 50, 350., false);

739 verifyItem(2, 400, 350., false);

740 verifyItem(3, 750, 350., true);

741 QCOMPARE(lvwph->m_minYExtent, 1050.);

742 QCOMPARE(lvwph->m_clipItem->y(), 700.);

743 QCOMPARE(lvwph->m_clipItem->clip(), false);

744 QCOMPARE(lvwph->m_headerItem->y(), 0.);

745 QCOMPARE(lvwph->m_headerItem->height(), 50.);

746 QCOMPARE(lvwph->contentY(), 700.);

747 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

748

749 scrollToTop();

750

751 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

752 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

753 verifyItem(0, 50., 150., false);

754 verifyItem(1, 200., 125., false);

755 verifyItem(2, 325., 100., false);

756 verifyItem(3, 425., 200., false);

757 verifyItem(4, 625., 350., true);

758 QCOMPARE(lvwph->m_minYExtent, 225.);

759 QCOMPARE(lvwph->m_clipItem->y(), -225.);

760 QCOMPARE(lvwph->m_clipItem->clip(), false);

761 QCOMPARE(lvwph->m_headerItem->y(), -225.);

762 QCOMPARE(lvwph->m_headerItem->height(), 50.);

763 QCOMPARE(lvwph->contentY(), -225.);

764 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

765 }

766

767 void testInsertItemsAtEndOfViewport()

768 {

769 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 3), Q_ARG(QVariant, 100));

770 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 3), Q_ARG(QVariant, 125));

771

772 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

773 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

774 verifyItem(0, 50., 150., false);

775 verifyItem(1, 200., 200., false);

776 verifyItem(2, 400., 350., false);

777 verifyItem(3, 750., 125., true);

778 QCOMPARE(lvwph->m_minYExtent, 0.);

779 QCOMPARE(lvwph->m_clipItem->y(), 0.);

780 QCOMPARE(lvwph->m_clipItem->clip(), false);

781 QCOMPARE(lvwph->m_headerItem->y(), 0.);

782 QCOMPARE(lvwph->m_headerItem->height(), 50.);

783 QCOMPARE(lvwph->contentY(), 0.);

784 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

785 }

786

787 void testInsertItemsBeforeValidIndex()

788 {

789 changeContentY(520);

790

791 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

792 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

793 verifyItem(0, -320., 200., true);

794 verifyItem(1, -120, 350., false);

795 verifyItem(2, 230, 350., false);

796 verifyItem(3, 580, 350., true);

797 QCOMPARE(lvwph->m_minYExtent, 162.5);

798 QCOMPARE(lvwph->m_clipItem->y(), 520.);

799 QCOMPARE(lvwph->m_clipItem->clip(), false);

800 QCOMPARE(lvwph->m_headerItem->y(), 0.);

801 QCOMPARE(lvwph->m_headerItem->height(), 50.);

802 QCOMPARE(lvwph->contentY(), 520.);

803 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

804

805 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));

806 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));

807

808 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

809 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

810 verifyItem(0, -320., 200., true);

811 verifyItem(1, -120, 350., false);

812 verifyItem(2, 230, 350., false);

813 verifyItem(3, 580, 350., true);

814 QCOMPARE(lvwph->m_minYExtent, 787.5);

815 QCOMPARE(lvwph->m_clipItem->y(), 520.);

816 QCOMPARE(lvwph->m_clipItem->clip(), false);

817 QCOMPARE(lvwph->m_headerItem->y(), 0.);

818 QCOMPARE(lvwph->m_headerItem->height(), 50.);

819 QCOMPARE(lvwph->contentY(), 520.);

820 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

821 }

822

823 void testInsertItemsBeforeViewport()

824 {

825 changeContentY(375);

826

827 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

828 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

829 verifyItem(0, -325., 150., true);

830 verifyItem(1, -175, 200., false);

831 verifyItem(2, 25, 350., false);

832 verifyItem(3, 375, 350., false);

833 verifyItem(4, 725, 350., true);

834 QCOMPARE(lvwph->m_minYExtent, 0.);

835 QCOMPARE(lvwph->m_clipItem->y(), 375.);

836 QCOMPARE(lvwph->m_clipItem->clip(), false);

837 QCOMPARE(lvwph->m_headerItem->y(), 0.);

838 QCOMPARE(lvwph->m_headerItem->height(), 50.);

839 QCOMPARE(lvwph->contentY(), 375.);

840 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

841

842 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));

843 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));

844

845 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

846 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

847 verifyItem(0, -275., 100., true);

848 verifyItem(1, -175, 200., false);

849 verifyItem(2, 25, 350., false);

850 verifyItem(3, 375, 350., false);

851 verifyItem(4, 725, 350., true);

852 QCOMPARE(lvwph->m_minYExtent, 490.);

853 QCOMPARE(lvwph->m_clipItem->y(), 375.);

854 QCOMPARE(lvwph->m_clipItem->clip(), false);

855 QCOMPARE(lvwph->m_headerItem->y(), 0.);

856 QCOMPARE(lvwph->m_headerItem->height(), 50.);

857 QCOMPARE(lvwph->contentY(), 375.);

858 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

859

860 scrollToTop();

861

862 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

863 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

864 verifyItem(0, 50., 150., false);

865 verifyItem(1, 200., 125., false);

866 verifyItem(2, 325., 100., false);

867 verifyItem(3, 425., 200., false);

868 verifyItem(4, 625., 350., true);

869 QCOMPARE(lvwph->m_minYExtent, 225.);

870 QCOMPARE(lvwph->m_clipItem->y(), -225.);

871 QCOMPARE(lvwph->m_clipItem->clip(), false);

872 QCOMPARE(lvwph->m_headerItem->y(), -225.);

873 QCOMPARE(lvwph->m_headerItem->height(), 50.);

874 QCOMPARE(lvwph->contentY(), -225.);

875 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

876 }

877

878 void testInsertItemsAtBottom()

879 {

880 scrollToBottom();

881

882 QVERIFY(lvwph->isAtYEnd());

883

884 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 100));

885 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 125));

886

887 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

888 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

889 verifyItem(0, -508., 350., true);

890 verifyItem(1, -158, 350., false);

891 verifyItem(2, 192, 350., false);

892 verifyItem(3, 542, 125., true);

893 verifyItem(4, 667, 100., true);

894 QCOMPARE(lvwph->m_minYExtent, 65.);

895 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

896 QCOMPARE(lvwph->m_clipItem->clip(), false);

897 QCOMPARE(lvwph->m_headerItem->y(), 0.);

898 QCOMPARE(lvwph->m_headerItem->height(), 50.);

899 QCOMPARE(lvwph->contentY(), 1258.);

900 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

901 QVERIFY(!lvwph->isAtYEnd());

902

903 scrollToBottom();

904

905 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

906 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

907 verifyItem(0, -383., 350., true);

908 verifyItem(1, -33, 350., false);

909 verifyItem(2, 317, 125., false);

910 verifyItem(3, 442, 100., false);

911 QCOMPARE(lvwph->m_minYExtent, -125.);

912 QCOMPARE(lvwph->m_clipItem->y(), 1483.);

913 QCOMPARE(lvwph->m_clipItem->clip(), false);

914 QCOMPARE(lvwph->m_headerItem->y(), 0.);

915 QCOMPARE(lvwph->m_headerItem->height(), 50.);

916 QCOMPARE(lvwph->contentY(), 1483.);

917 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

918 QVERIFY(lvwph->isAtYEnd());

919 }

920

921 void testInsertItemAtTop()

922 {

923 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

924

925 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

926 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

927 verifyItem(0, 50., 75., false);

928 verifyItem(1, 125., 150., false);

929 verifyItem(2, 275., 200., false);

930 verifyItem(3, 475., 350., false);

931 QCOMPARE(lvwph->m_minYExtent, 0.);

932 QCOMPARE(lvwph->m_clipItem->y(), 0.);

933 QCOMPARE(lvwph->m_clipItem->clip(), false);

934 QCOMPARE(lvwph->m_headerItem->y(), 0.);

935 QCOMPARE(lvwph->m_headerItem->height(), 50.);

936 QCOMPARE(lvwph->contentY(), 0.);

937 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

938 QVERIFY(lvwph->isAtYBeginning());

939 }

940

941 void testInsertItem10SmallItemsAtTopWhenAtBottom()

942 {

943 scrollToBottom();

944

945 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

946 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

947 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

948 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

949 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

950 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

951 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

952 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

953 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

954 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

955

956 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

957 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

958 verifyItem(0, -508., 350., true);

959 verifyItem(1, -158, 350., false);

960 verifyItem(2, 192, 350., false);

961 QCOMPARE(lvwph->m_minYExtent, 3850.);

962 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

963 QCOMPARE(lvwph->m_clipItem->clip(), false);

964 QCOMPARE(lvwph->m_headerItem->y(), 0.);

965 QCOMPARE(lvwph->m_headerItem->height(), 50.);

966 QCOMPARE(lvwph->contentY(), 1258.);

967 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

968

969 changeContentY(-1700);

970

971 QTRY_COMPARE(lvwph->m_visibleItems.count(), 12);

972 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

973 verifyItem(0, -308., 75., true);

974 verifyItem(1, -233., 75., true);

975 verifyItem(2, -158., 75., true);

976 verifyItem(3, -83., 75., true);

977 verifyItem(4, -8., 75., false);

978 verifyItem(5, 67., 75., false);

979 verifyItem(6, 142., 75., false);

980 verifyItem(7, 217., 75., false);

981 verifyItem(8, 292., 75., false);

982 verifyItem(9, 367., 75., false);

983 verifyItem(10, 442., 150., false);

984 verifyItem(11, 592., 200., true);

985 QCOMPARE(lvwph->m_minYExtent, 750.);

986 QCOMPARE(lvwph->m_clipItem->y(), -392.);

987 QCOMPARE(lvwph->m_clipItem->clip(), true);

988 QCOMPARE(lvwph->m_headerItem->y(), -442.);

989 QCOMPARE(lvwph->m_headerItem->height(), 50.);

990 QCOMPARE(lvwph->contentY(), -442.);

991 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

992 }

993

994 void testInsertToEmpty()

995 {

996 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

997 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

998 QCOMPARE(lvwph->m_minYExtent, 0.);

999 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1000 QCOMPARE(lvwph->m_clipItem->clip(), false);

1001 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1002 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1003 QCOMPARE(lvwph->contentY(), 0.);

1004

1005 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1006 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1007 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1008 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1009 verifyItem(0, 50., 125., false);

1010 verifyItem(1, 175., 100., false);

1011 }

1012

1013 void testRemoveItemsAtTop()

1014 {

1015 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1016

1017 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1018 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1019 verifyItem(0, 50., 350., false);

1020 verifyItem(1, 400., 350., false);

1021 verifyItem(2, 750., 350., true);

1022 QCOMPARE(lvwph->m_minYExtent, 0.);

1023 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1024 QCOMPARE(lvwph->m_clipItem->clip(), false);

1025 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1026 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1027 QCOMPARE(lvwph->contentY(), 0.);

1028 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1029 QVERIFY(lvwph->isAtYBeginning());

1030 }

1031

1032 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1033 {

1034 scrollToBottom();

1035

1036 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1037

1038 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1039 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1040 verifyItem(0, -508., 350., true);

1041 verifyItem(1, -158, 350., false);

1042 verifyItem(2, 192, 350., false);

1043 QCOMPARE(lvwph->m_minYExtent, -350.);

1044 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

1045 QCOMPARE(lvwph->m_clipItem->clip(), false);

1046 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1047 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1048 QCOMPARE(lvwph->contentY(), 1258.);

1049 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1050 }

1051

1052 void testRemoveLastItemsAtBottom()

1053 {

1054 scrollToBottom();

1055

1056 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));

1057

1058 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1059 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1060 verifyItem(0, -358., 200., true);

1061 verifyItem(1, -158, 350., false);

1062 verifyItem(2, 192, 350., false);

1063 QCOMPARE(lvwph->m_minYExtent, 150.);

1064 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1065 QCOMPARE(lvwph->m_clipItem->clip(), false);

1066 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1067 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1068 QCOMPARE(lvwph->contentY(), 558.);

1069 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1070 }

1071

1072 void testRemoveItemOutOfViewport()

1073 {

1074 changeContentY(520);

1075

1076 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1077 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1078 verifyItem(0, -320., 200., true);

1079 verifyItem(1, -120, 350., false);

1080 verifyItem(2, 230, 350., false);

1081 verifyItem(3, 580, 350., true);

1082 QCOMPARE(lvwph->m_minYExtent, 162.5);

1083 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1084 QCOMPARE(lvwph->m_clipItem->clip(), false);

1085 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1086 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1087 QCOMPARE(lvwph->contentY(), 520.);

1088 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1089

1090

1091 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1092

1093 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1094 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1095 verifyItem(0, -270., 150., true);

1096 verifyItem(1, -120., 350., false);

1097 verifyItem(2, 230, 350., false);

1098 verifyItem(3, 580, 350., true);

1099 QCOMPARE(lvwph->m_minYExtent, -200.);

1100 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1101 QCOMPARE(lvwph->m_clipItem->clip(), false);

1102 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1103 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1104 QCOMPARE(lvwph->contentY(), 520.);

1105 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1106 }

1107

1108 void testMoveFirstItems()

1109 {

1110 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1111

1112 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1113 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1114 verifyItem(0, 50., 200., false);

1115 verifyItem(1, 250., 150., false);

1116 verifyItem(2, 400., 350., false);

1117 verifyItem(3, 750., 350., true);

1118 QCOMPARE(lvwph->m_minYExtent, 0.);

1119 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1120 QCOMPARE(lvwph->m_clipItem->clip(), false);

1121 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1122 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1123 QCOMPARE(lvwph->contentY(), 0.);

1124 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1125

1126 }

1127

1128 void testMoveFirstOutOfVisibleItems()

1129 {

1130 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1131

1132 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1133 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1134 verifyItem(0, 50., 200., false);

1135 verifyItem(1, 250., 350., false);

1136 verifyItem(2, 600., 350., true);

1137 QCOMPARE(lvwph->m_minYExtent, 0.);

1138 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1139 QCOMPARE(lvwph->m_clipItem->clip(), false);

1140 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1141 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1142 QCOMPARE(lvwph->contentY(), 0.);

1143 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1144

1145 }

1146

1147 void testMoveFirstToLastAtBottom()

1148 {

1149 scrollToBottom();

1150

1151 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1152 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1153 verifyItem(0, -508., 350., true);

1154 verifyItem(1, -158, 350., false);

1155 verifyItem(2, 192, 350., false);

1156 QCOMPARE(lvwph->m_minYExtent, 350.);

1157 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

1158 QCOMPARE(lvwph->m_clipItem->clip(), false);

1159 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1160 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1161 QCOMPARE(lvwph->contentY(), 1258.);

1162 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1163

1164 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1165

1166 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1167 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1168 verifyItem(0, -508., 350., true);

1169 verifyItem(1, -158, 350., false);

1170 verifyItem(2, 192, 350., false);

1171 verifyItem(3, 542, 150., true);

1172 QCOMPARE(lvwph->m_minYExtent, -100.);

1173 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

1174 QCOMPARE(lvwph->m_clipItem->clip(), false);

1175 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1176 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1177 QCOMPARE(lvwph->contentY(), 1258.);

1178 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1179 QVERIFY(!lvwph->isAtYEnd());

1180 }

1181

1182 void testChangeSizeVisibleItemNotOnViewport()

1183 {

1184 changeContentY(440);

1185

1186 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1187 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1188 verifyItem(0, -390., 150., true);

1189 verifyItem(1, -240., 200., true);

1190 verifyItem(2, -40, 350., false);

1191 verifyItem(3, 310, 350., false);

1192 verifyItem(4, 660, 350., true);

1193 QCOMPARE(lvwph->m_minYExtent, 0.);

1194 QCOMPARE(lvwph->m_clipItem->y(), 440.);

1195 QCOMPARE(lvwph->m_clipItem->clip(), false);

1196 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1197 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1198 QCOMPARE(lvwph->contentY(), 440.);

1199 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1200

1201 model->setProperty(1, "size", 100);

1202

1203 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1204 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1205 verifyItem(0, -290., 150., true);

1206 verifyItem(1, -140., 100., true);

1207 verifyItem(2, -40, 350., false);

1208 verifyItem(3, 310, 350., false);

1209 verifyItem(4, 660, 350., true);

1210 QCOMPARE(lvwph->m_minYExtent, -100.);

1211 QCOMPARE(lvwph->m_clipItem->y(), 440.);

1212 QCOMPARE(lvwph->m_clipItem->clip(), false);

1213 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1214 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1215 QCOMPARE(lvwph->contentY(), 440.);

1216 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1217 }

1218

1219 void testShowHeaderCloseToTheTop()

1220 {

1221 changeContentY(375);

1222

1223 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1224 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1225 verifyItem(0, -325., 150., true);

1226 verifyItem(1, -175, 200., false);

1227 verifyItem(2, 25, 350., false);

1228 verifyItem(3, 375, 350., false);

1229 verifyItem(4, 725, 350., true);

1230 QCOMPARE(lvwph->m_minYExtent, 0.);

1231 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1232 QCOMPARE(lvwph->m_clipItem->clip(), false);

1233 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1234 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1235 QCOMPARE(lvwph->contentY(), 375.);

1236 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1237

1238 lvwph->showHeader();

1239

1240 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1241 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1242 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1243 verifyItem(0, -375., 150., true);

1244 verifyItem(1, -225, 200., true);

1245 verifyItem(2, -25, 350., false);

1246 verifyItem(3, 325, 350., false);

1247 verifyItem(4, 675, 350., true);

1248 QCOMPARE(lvwph->m_minYExtent, 50.);

1249 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1250 QCOMPARE(lvwph->m_clipItem->clip(), true);

1251 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1252 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1253 QCOMPARE(lvwph->contentY(), 325.);

1254 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;

1255

1256 scrollToTop();

1257

1258 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1259 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1260 verifyItem(0, 50., 150., false);

1261 verifyItem(1, 200., 200., false);

1262 verifyItem(2, 400., 350., false);

1263 verifyItem(3, 750., 350., true);

1264 QCOMPARE(lvwph->m_minYExtent, 50.);

1265 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1266 QCOMPARE(lvwph->m_clipItem->clip(), false);

1267 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1268 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1269 QCOMPARE(lvwph->contentY(), -50.);

1270 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1271 }

1272

1273 void testShowHeaderHalfShown()

1274 {

1275#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1276 QSKIP("This test is extremely unstable in 5.0.x");

1277#endif

1278 changeContentY(20);

1279

1280 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1281 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1282 verifyItem(0, 30., 150., false);

1283 verifyItem(1, 180, 200., false);

1284 verifyItem(2, 380, 350., false);

1285 verifyItem(3, 730, 350., true);

1286 QCOMPARE(lvwph->m_minYExtent, 0.);

1287 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1288 QCOMPARE(lvwph->m_clipItem->clip(), false);

1289 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1290 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1291 QCOMPARE(lvwph->contentY(), 20.);

1292 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1293

1294 lvwph->showHeader();

1295

1296 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1297 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1298 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1299 verifyItem(0, -20., 150., false);

1300 verifyItem(1, 130, 200., false);

1301 verifyItem(2, 330, 350., false);

1302 verifyItem(3, 680, 350., true);

1303 QCOMPARE(lvwph->m_minYExtent, 20.);

1304 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1305 QCOMPARE(lvwph->m_clipItem->clip(), true);

1306 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1307 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1308 QCOMPARE(lvwph->contentY(), 0.);

1309 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1310

1311 scrollToTop();

1312

1313 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1314 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1315 verifyItem(0, 50., 150., false);

1316 verifyItem(1, 200., 200., false);

1317 verifyItem(2, 400., 350., false);

1318 verifyItem(3, 750, 350., true);

1319 QCOMPARE(lvwph->m_minYExtent, 20.);

1320 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1321 QCOMPARE(lvwph->m_clipItem->clip(), false);

1322 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1323 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1324 QCOMPARE(lvwph->contentY(), -20.);

1325 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1326 }

1327

1328 void testShowHeaderAtBottom()

1329 {

1330 scrollToBottom();

1331

1332 lvwph->showHeader();

1333

1334 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1335 QTRY_VERIFY (lvwph->isAtYEnd());

1336 }

1337

1338 void growWindow()

1339 {

1340 view->rootObject()->setHeight(850);

1341

1342 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1343 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1344 verifyItem(0, 50., 150., false);

1345 verifyItem(1, 200., 200., false);

1346 verifyItem(2, 400., 350., false);

1347 verifyItem(3, 750., 350., false);

1348 verifyItem(4, 1100., 350., true);

1349 QCOMPARE(lvwph->m_minYExtent, 0.);

1350 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1351 QCOMPARE(lvwph->m_clipItem->clip(), false);

1352 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1353 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1354 QCOMPARE(lvwph->contentY(), 0.);

1355 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1356 }

1357

1358 void growWindowAtBottom()

1359 {

1360 scrollToBottom();

1361

1362 view->rootObject()->setHeight(850);

1363

1364 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1365 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1366 verifyItem(0, -550., 350., true);

1367 verifyItem(1, -200., 350., false);

1368 verifyItem(2, 150, 350., false);

1369 verifyItem(3, 500, 350., false);

1370 QCOMPARE(lvwph->m_minYExtent, 350.);

1371 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1372 QCOMPARE(lvwph->m_clipItem->clip(), false);

1373 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1374 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1375 QCOMPARE(lvwph->contentY(), 950.);

1376 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1377 }

1378

1379 void testCrashShowHeaderWithNoHeader()

1380 {

1381 lvwph->setHeader(nullptr);

1382 lvwph->showHeader();

1383 }

1384

1385private:

1386 QQuickView *view;

1387 ListViewWithPageHeader *lvwph;

1388 QQuickListModel *model;

1389 QQmlComponent *otherDelegate;

1390};

1391

1392QTEST_MAIN(ListViewWithPageHeaderTest)

1393

1394#include "listviewwithpageheadertest.moc"