tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 5b03213 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp

1840 lines 70 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 <QSignalSpy>

23#include <QtTestGui>

24#pragma GCC diagnostic push

25#pragma GCC diagnostic ignored "-pedantic"

26#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

27#include <private/qquicklistmodel_p.h>

28#else

29#include <private/qqmllistmodel_p.h>

30#endif

31#include <private/qquickanimation_p.h>

32#include <private/qquickitem_p.h>

33#pragma GCC diagnostic pop

35class ListViewWithPageHeaderTest : public QObject

36{

37 Q_OBJECT

39private:

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

41 {

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

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

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

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

46 }

48 void changeContentY(qreal change)

49 {

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

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

52 const qreal jump = 25;

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

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

55 QTest::qWait(1);

56 }

57 } else {

58 const qreal jump = -25;

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

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

61 QTest::qWait(1);

62 }

63 }

64 lvwph->setContentY(dest);

65 QTest::qWait(1);

66 }

68 void scrollToTop()

69 {

70 const qreal jump = -25;

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

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

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

74 } else {

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

76 }

77 QTest::qWait(1);

78 }

79 }

81 void scrollToBottom()

82 {

83 const qreal jump = 25;

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

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

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

87 } else {

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

89 }

90 QTest::qWait(1);

91 }

92 }

94 void verifyInitialTopPosition()

95 {

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

97 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

109 }

110

111private Q_SLOTS:

112

113 void initTestCase()

114 {

115 }

116

117 void init()

118 {

119 view = new QQuickView();

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

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

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

123#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

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

125#else

126 model = view->rootObject()->findChild<QQmlListModel*>();

127#endif

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

129 QVERIFY(lvwph);

130 QVERIFY(model);

131 QVERIFY(otherDelegate);

132 view->show();

133 QTest::qWaitForWindowExposed(view);

134

135 verifyInitialTopPosition();

136 }

137

138 void cleanup()

139 {

140 delete view;

141 }

142

143 void testCreationDeletion()

144 {

145 // Nothing, init/cleanup already tests this

146 }

147

148 void testDrag1PixelUp()

149 {

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

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

152 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

164 }

165

166 void testHeaderDetachDragDown()

167 {

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QTest::qWait(100);

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

179 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

191

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

193

194 verifyInitialTopPosition();

195 }

196

197 void testDrag375PixelUp()

198 {

199 changeContentY(375);

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

201 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

214 }

215

216 void testDrag520PixelUp()

217 {

218 changeContentY(520);

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

220 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

231 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

238 }

239

240 void testDragHeaderUpThenShow()

241 {

242 changeContentY(120);

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

244 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

256

257 changeContentY(-30);

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

259 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

271 }

272

273 void testDragHeaderUpThenShowWithoutHidingTotally()

274 {

275 changeContentY(10);

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

277 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

289

290 changeContentY(-1);

291

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

293 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

305 }

306

307 void testPositionAtBeginningIndex0Visible()

308 {

309 changeContentY(375);

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

311 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

324

325 lvwph->positionAtBeginning();

326

327 verifyInitialTopPosition();

328 }

329

330 void testPositionAtBeginningIndex0NotVisible()

331 {

332 changeContentY(520);

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

334 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

339 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

346

347 lvwph->positionAtBeginning();

348

349 verifyInitialTopPosition();

350 }

351

352 void testIndex0GrowOnScreen()

353 {

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

355

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

357 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

368 }

369

370 void testIndex0GrowOffScreen()

371 {

372 changeContentY(375);

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

374 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

387

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

389

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

391 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

404

405 scrollToTop();

406

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

408 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

419

420 changeContentY(30);

421

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

423 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

434 }

435

436 void testIndex0GrowNotCreated()

437 {

438 changeContentY(520);

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

440 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

445 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

452

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

454

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

456 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

461 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

468

469 scrollToTop();

470

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

472 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

483 }

484

485 void testShowHideShowHeaderAtBottom()

486 {

487 scrollToBottom();

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

489 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

500

501 changeContentY(-30);

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

503 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

514

515 changeContentY(30);

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

517 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

528

529 changeContentY(-30);

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

531 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

542 }

543

544 void testChangeDelegateAtBottom()

545 {

546 scrollToBottom();

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

548 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

559

560 lvwph->setDelegate(otherDelegate);

561

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

563 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

577 }

578

579 void testSetEmptyHeaderAtTop()

580 {

581 lvwph->setHeader(nullptr);

582

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

584 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

595 }

596

597 void testSetEmptyHeaderAtBottom()

598 {

599 scrollToBottom();

600 lvwph->setHeader(nullptr);

601

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

603 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

613

614 scrollToTop();

615

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

617 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

628 }

629

630 void testSetEmptyHeaderWhenPartlyShownClipped()

631 {

632 scrollToBottom();

633 changeContentY(-30);

634 lvwph->setHeader(nullptr);

635

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

637 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

647 QTRY_VERIFY(lvwph->isAtYEnd());

648

649 scrollToTop();

650

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

652 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

663 }

664

665 void testSetEmptyHeaderWhenPartlyShownNotClipped()

666 {

667 changeContentY(30);

668 lvwph->setHeader(nullptr);

669

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

671 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

682 }

683

684 void testSetNullDelegate()

685 {

686 lvwph->setDelegate(nullptr);

687

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

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

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

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

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

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

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

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

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

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

698 QVERIFY(lvwph->isAtYBeginning());

699 QVERIFY(lvwph->isAtYEnd());

700 }

701

702 void testInsertItems()

703 {

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

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

706

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

708 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

721 }

722

723 void testInsertItemsOnNotShownPosition()

724 {

725 changeContentY(700);

726

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

728 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

740

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

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

743

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

745 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

757

758 scrollToTop();

759

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

761 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

774 }

775

776 void testInsertItemsAtEndOfViewport()

777 {

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

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

780

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

782 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

794 }

795

796 void testInsertItemsBeforeValidIndex()

797 {

798 changeContentY(520);

799

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

801 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

806 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

813

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

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

816

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

818 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

823 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

830 }

831

832 void testInsertItemsBeforeViewport()

833 {

834 changeContentY(375);

835

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

837 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

850

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

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

853

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

855 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

868

869 scrollToTop();

870

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

872 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

885 }

886

887 void testInsertItemsAtBottom()

888 {

889 scrollToBottom();

890

891 QVERIFY(lvwph->isAtYEnd());

892

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

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

895

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

897 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

911

912 scrollToBottom();

913

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

915 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

927 QVERIFY(lvwph->isAtYEnd());

928 }

929

930 void testInsertItemAtTop()

931 {

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

933

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

935 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

947 QVERIFY(lvwph->isAtYBeginning());

948 }

949

950 void testInsertItem10SmallItemsAtTopWhenAtBottom()

951 {

952 scrollToBottom();

953

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

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

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

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

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

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

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

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

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

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

964

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

966 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

977

978 changeContentY(-1700);

979

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

981 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1001 }

1002

1003 void testInsertToEmpty()

1004 {

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

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

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

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

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

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

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

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

1013

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

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

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

1017 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1020 }

1021

1022 void testRemoveItemsAtTop()

1023 {

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

1025

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

1027 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1038 QVERIFY(lvwph->isAtYBeginning());

1039 }

1040

1041 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1042 {

1043 scrollToBottom();

1044

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

1046

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

1048 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1059 }

1060

1061 void testRemoveLastItemsAtBottom()

1062 {

1063 scrollToBottom();

1064

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

1066

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

1068 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1079 }

1080

1081 void testRemoveItemOutOfViewport()

1082 {

1083 changeContentY(520);

1084

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

1086 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1091 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1098

1099

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

1101

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

1103 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1115 }

1116

1117 void testMoveFirstItems()

1118 {

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

1120

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

1122 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1134

1135 }

1136

1137 void testMoveFirstOutOfVisibleItems()

1138 {

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

1140

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

1142 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1153

1154 }

1155

1156 void testMoveFirstToLastAtBottom()

1157 {

1158 scrollToBottom();

1159

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

1161 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1172

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

1174

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

1176 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1189 }

1190

1191 void testChangeSizeVisibleItemNotOnViewport()

1192 {

1193 changeContentY(440);

1194

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

1196 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1209

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

1211

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

1213 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1226 }

1227

1228 void testShowHeaderCloseToTheTop()

1229 {

1230 changeContentY(375);

1231

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

1233 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1246

1247 lvwph->showHeader();

1248

1249 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

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

1251 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1264

1265 scrollToTop();

1266

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

1268 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

1270 verifyItem(1, 200., 200., false);

1271 verifyItem(2, 400., 350., false);

1272 verifyItem(3, 750., 350., true);

1273 QCOMPARE(lvwph->m_minYExtent, 50.);

1274 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1275 QCOMPARE(lvwph->m_clipItem->clip(), false);

1276 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1277 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1278 QCOMPARE(lvwph->contentY(), -50.);

1279 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1280 }

1281

1282 void testShowHeaderHalfShown()

1283 {

1284#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1285 QSKIP("This test is extremely unstable in 5.0.x");

1286#endif

1287 changeContentY(20);

1288

1289 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1290 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1291 verifyItem(0, 30., 150., false);

1292 verifyItem(1, 180, 200., false);

1293 verifyItem(2, 380, 350., false);

1294 verifyItem(3, 730, 350., true);

1295 QCOMPARE(lvwph->m_minYExtent, 0.);

1296 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1297 QCOMPARE(lvwph->m_clipItem->clip(), false);

1298 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1299 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1300 QCOMPARE(lvwph->contentY(), 20.);

1301 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1302

1303 lvwph->showHeader();

1304

1305 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1306 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1307 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1308 verifyItem(0, -20., 150., false);

1309 verifyItem(1, 130, 200., false);

1310 verifyItem(2, 330, 350., false);

1311 verifyItem(3, 680, 350., true);

1312 QCOMPARE(lvwph->m_minYExtent, 20.);

1313 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1314 QCOMPARE(lvwph->m_clipItem->clip(), true);

1315 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1316 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1317 QCOMPARE(lvwph->contentY(), 0.);

1318 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1319

1320 scrollToTop();

1321

1322 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1323 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1324 verifyItem(0, 50., 150., false);

1325 verifyItem(1, 200., 200., false);

1326 verifyItem(2, 400., 350., false);

1327 verifyItem(3, 750, 350., true);

1328 QCOMPARE(lvwph->m_minYExtent, 20.);

1329 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1330 QCOMPARE(lvwph->m_clipItem->clip(), false);

1331 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1332 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1333 QCOMPARE(lvwph->contentY(), -20.);

1334 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1335 }

1336

1337 void testShowHeaderAtBottom()

1338 {

1339 scrollToBottom();

1340

1341 lvwph->showHeader();

1342

1343 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1344 QTRY_VERIFY (lvwph->isAtYEnd());

1345 }

1346

1347 void growWindow()

1348 {

1349 view->rootObject()->setHeight(850);

1350

1351 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1352 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1353 verifyItem(0, 50., 150., false);

1354 verifyItem(1, 200., 200., false);

1355 verifyItem(2, 400., 350., false);

1356 verifyItem(3, 750., 350., false);

1357 verifyItem(4, 1100., 350., true);

1358 QCOMPARE(lvwph->m_minYExtent, 0.);

1359 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1360 QCOMPARE(lvwph->m_clipItem->clip(), false);

1361 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1362 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1363 QCOMPARE(lvwph->contentY(), 0.);

1364 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1365 }

1366

1367 void growWindowAtBottom()

1368 {

1369 scrollToBottom();

1370

1371 view->rootObject()->setHeight(850);

1372

1373 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1374 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1375 verifyItem(0, -550., 350., true);

1376 verifyItem(1, -200., 350., false);

1377 verifyItem(2, 150, 350., false);

1378 verifyItem(3, 500, 350., false);

1379 QCOMPARE(lvwph->m_minYExtent, 350.);

1380 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1381 QCOMPARE(lvwph->m_clipItem->clip(), false);

1382 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1383 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1384 QCOMPARE(lvwph->contentY(), 950.);

1385 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1386 }

1387

1388 void testCrashShowHeaderWithNoHeader()

1389 {

1390 lvwph->setHeader(nullptr);

1391 lvwph->showHeader();

1392 }

1393

1394 void testCullOnBottomEdge()

1395 {

1396 changeContentY(200);

1397

1398 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1399 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1400 verifyItem(0, -150., 150., true);

1401 verifyItem(1, 0., 200., false);

1402 verifyItem(2, 200., 350., false);

1403 verifyItem(3, 550., 350., true);

1404 QCOMPARE(lvwph->m_minYExtent, 0.);

1405 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1406 QCOMPARE(lvwph->m_clipItem->clip(), false);

1407 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1408 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1409 QCOMPARE(lvwph->contentY(), 200.);

1410 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1411 }

1412

1413 void testMaximizeVisibleArea()

1414 {

1415 bool res = lvwph->maximizeVisibleArea(2);

1416 QVERIFY(res);

1417 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1418

1419 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1420 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1421 verifyItem(0, -158., 150., true);

1422 verifyItem(1, -8., 200., false);

1423 verifyItem(2, 192, 350., false);

1424 verifyItem(3, 542, 350., true);

1425 QCOMPARE(lvwph->m_minYExtent, 0.);

1426 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1427 QCOMPARE(lvwph->m_clipItem->clip(), false);

1428 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1429 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1430 QCOMPARE(lvwph->contentY(), 208.);

1431 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1432 }

1433

1434 void testMaximizeVisibleAreaVisibleItems()

1435 {

1436 bool res = lvwph->maximizeVisibleArea(0);

1437 QVERIFY(res);

1438 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1439

1440 verifyInitialTopPosition();

1441

1442 res = lvwph->maximizeVisibleArea(1);

1443 QVERIFY(res);

1444 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1445

1446 verifyInitialTopPosition();

1447 }

1448

1449 void testMaximizeVisibleAreaInvalidIndexes()

1450 {

1451 bool res = lvwph->maximizeVisibleArea(-1);

1452 QVERIFY(!res);

1453 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1454

1455 verifyInitialTopPosition();

1456

1457 res = lvwph->maximizeVisibleArea(1000);

1458 QVERIFY(!res);

1459 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1460

1461 verifyInitialTopPosition();

1462

1463 res = lvwph->maximizeVisibleArea(4);

1464 QVERIFY(!res);

1465 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1466

1467 verifyInitialTopPosition();

1468 }

1469

1470 void testMaximizeVisibleAreaBigElement()

1471 {

1472 model->setProperty(2, "size", 4000);

1473 bool res = lvwph->maximizeVisibleArea(2);

1474 QVERIFY(res);

1475 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1476

1477 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1478 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1479 verifyItem(0, -350., 150., true);

1480 verifyItem(1, -200., 200., true);

1481 verifyItem(2, 0, 4000., false);

1482 QCOMPARE(lvwph->m_minYExtent, 0.);

1483 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1484 QCOMPARE(lvwph->m_clipItem->clip(), false);

1485 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1486 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1487 QCOMPARE(lvwph->contentY(), 400.);

1488 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1489 }

1490

1491 void testMaximizeVisibleAreaScrollDown()

1492 {

1493 changeContentY(250);

1494 bool res = lvwph->maximizeVisibleArea(1);

1495 QVERIFY(res);

1496 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1497

1498 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1499 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1500 verifyItem(0, -150., 150., true);

1501 verifyItem(1, 0., 200., false);

1502 verifyItem(2, 200, 350., false);

1503 verifyItem(3, 550, 350., true);

1504 QCOMPARE(lvwph->m_minYExtent, 0.);

1505 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1506 QCOMPARE(lvwph->m_clipItem->clip(), false);

1507 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1508 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1509 QCOMPARE(lvwph->contentY(), 200.);

1510 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1511 }

1512

1513 void testMaximizeVisibleAreaScrollDownBigElement()

1514 {

1515 model->setProperty(1, "size", 1000);

1516 changeContentY(1150);

1517 bool res = lvwph->maximizeVisibleArea(1);

1518 QVERIFY(res);

1519 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1520

1521 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1522 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1523 verifyItem(0, -458., 1000., false);

1524 verifyItem(1, 542., 350., true);

1525 QCOMPARE(lvwph->m_minYExtent, 525.);

1526 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1527 QCOMPARE(lvwph->m_clipItem->clip(), false);

1528 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1529 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1530 QCOMPARE(lvwph->contentY(), 658.);

1531 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1532 }

1533

1534 void testMaximizeVisibleAreaBigElementInTheMiddle()

1535 {

1536 model->setProperty(1, "size", 1000);

1537 changeContentY(650);

1538

1539 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1540 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1541 verifyItem(0, -450., 1000., false);

1542 verifyItem(1, 550., 350., true);

1543 QCOMPARE(lvwph->m_minYExtent, 525.);

1544 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1545 QCOMPARE(lvwph->m_clipItem->clip(), false);

1546 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1547 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1548 QCOMPARE(lvwph->contentY(), 650.);

1549 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1550

1551 bool res = lvwph->maximizeVisibleArea(1);

1552 QVERIFY(res);

1553 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1554

1555 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1556 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1557 verifyItem(0, -450., 1000., false);

1558 verifyItem(1, 550., 350., true);

1559 QCOMPARE(lvwph->m_minYExtent, 525.);

1560 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1561 QCOMPARE(lvwph->m_clipItem->clip(), false);

1562 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1563 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1564 QCOMPARE(lvwph->contentY(), 650.);

1565 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1566 }

1567

1568 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1569 {

1570 changeContentY(430);

1571 changeContentY(-30);

1572

1573 bool res = lvwph->maximizeVisibleArea(1);

1574 QVERIFY(res);

1575 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1576

1577 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1578 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1579 verifyItem(0, -150., 150., true);

1580 verifyItem(1, 0., 200., false);

1581 verifyItem(2, 200, 350., false);

1582 verifyItem(3, 550, 350., true);

1583 QCOMPARE(lvwph->m_minYExtent, 0.);

1584 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1585 QCOMPARE(lvwph->m_clipItem->clip(), false);

1586 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1587 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1588 QCOMPARE(lvwph->contentY(), 200.);

1589 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1590 }

1591

1592 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1593 {

1594 changeContentY(430);

1595 changeContentY(-30);

1596

1597 bool res = lvwph->maximizeVisibleArea(3);

1598 QVERIFY(res);

1599 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1600

1601 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1602 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1603 verifyItem(0, -358., 200., true);

1604 verifyItem(1, -158., 350., false);

1605 verifyItem(2, 192, 350., false);

1606 verifyItem(3, 542, 350., true);

1607 QCOMPARE(lvwph->m_minYExtent, 162.5);

1608 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1609 QCOMPARE(lvwph->m_clipItem->clip(), false);

1610 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1611 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1612 QCOMPARE(lvwph->contentY(), 558.);

1613 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1614 }

1615

1616 void testMaximizeVisibleAreaWithItemResize()

1617 {

1618 model->setProperty(0, "size", 1000);

1619

1620 bool res = lvwph->maximizeVisibleArea(1);

1621 QVERIFY(res);

1622 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1623

1624 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1625 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1626 verifyItem(0, -658., 1000., false);

1627 verifyItem(1, 342., 200., false);

1628 verifyItem(2, 542, 350., true);

1629 QCOMPARE(lvwph->m_minYExtent, 0.);

1630 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1631 QCOMPARE(lvwph->m_clipItem->clip(), false);

1632 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1633 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1634 QCOMPARE(lvwph->contentY(), 708.);

1635 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1636 }

1637

1638 void addingRemoveItemsShouldNotChangeContentY()

1639 {

1640 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1642 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1643

1644 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1645 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1646 verifyItem(0, 50., 150., false);

1647 QCOMPARE(lvwph->m_minYExtent, 0.);

1648 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1649 QCOMPARE(lvwph->m_clipItem->clip(), false);

1650 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1651 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1652 QCOMPARE(lvwph->contentY(), 0.);

1653 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1654

1655 QCOMPARE(spy.count(), 0);

1656 }

1657

1658 void testOvershootOnSameSize()

1659 {

1660 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1661 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1662 QCOMPARE(lvwph->m_minYExtent, 0.);

1663 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1664 QCOMPARE(lvwph->m_clipItem->clip(), false);

1665 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1666 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1667 QCOMPARE(lvwph->contentY(), 0.);

1668

1669 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1670 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1671 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1672 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1673 verifyItem(0, 50., 392., false);

1674 verifyItem(1, 442., 100., false);

1675

1676 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1677

1678 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1679 QTest::qWait(100);

1680 QTest::mouseMove(view, QPoint(0, 5));

1681 QTest::qWait(100);

1682 QTest::mouseMove(view, QPoint(0, 10));

1683 QTest::qWait(100);

1684 QTest::mouseMove(view, QPoint(0, 15));

1685 QTest::qWait(100);

1686 QTest::mouseMove(view, QPoint(0, 20));

1687 QTest::qWait(100);

1688 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1689 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1690 verifyItem(0, 55., 392., false);

1691 verifyItem(1, 447., 100., false);

1692 QCOMPARE(lvwph->m_minYExtent, 0.);

1693 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1694

1695 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1696 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1697 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1698 verifyItem(0, 50., 392., false);

1699 verifyItem(1, 442., 100., false);

1700 }

1701

1702 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1703 {

1704 model->setProperty(0, "size", 800);

1705 verifyItem(0, 50., 800., false);

1706

1707 lvwph->maximizeVisibleArea(0);

1708 QTRY_COMPARE(lvwph->contentY(), 50.);

1709

1710 changeContentY(10);

1711 QTRY_COMPARE(lvwph->contentY(), 60.);

1712

1713 lvwph->showHeader();

1714 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1715 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1716 QCOMPARE(lvwph->m_minYExtent, 50.);

1717 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1718 QCOMPARE(lvwph->m_clipItem->clip(), true);

1719 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1720 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1721 QCOMPARE(lvwph->contentY(), 10.);

1722 verifyItem(0, -60., 800., false);

1723 }

1724

1725 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1726 {

1727 model->setProperty(0, "size", 800);

1728 verifyItem(0, 50., 800., false);

1729

1730 lvwph->maximizeVisibleArea(0);

1731 QTRY_COMPARE(lvwph->contentY(), 50.);

1732

1733 changeContentY(-10);

1734 QTRY_COMPARE(lvwph->contentY(), 40.);

1735

1736 lvwph->showHeader();

1737 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1738 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1739 QCOMPARE(lvwph->m_minYExtent, 40.);

1740 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1741 QCOMPARE(lvwph->m_clipItem->clip(), true);

1742 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1743 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1744 QCOMPARE(lvwph->contentY(), 0.);

1745 verifyItem(0, -40., 800., false);

1746 }

1747

1748 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1749 {

1750 model->setProperty(0, "size", 800);

1751 verifyItem(0, 50., 800., false);

1752

1753 lvwph->maximizeVisibleArea(0);

1754 QTRY_COMPARE(lvwph->contentY(), 50.);

1755

1756 changeContentY(-10);

1757 QTRY_COMPARE(lvwph->contentY(), 40.);

1758 changeContentY(10);

1759 QTRY_COMPARE(lvwph->contentY(), 50.);

1760

1761 lvwph->showHeader();

1762 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1763

1764 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1765 QCOMPARE(lvwph->m_minYExtent, 50.);

1766 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1767 QCOMPARE(lvwph->m_clipItem->clip(), true);

1768 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1769 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1770 QCOMPARE(lvwph->contentY(), 0.);

1771 verifyItem(0, -50., 800., false);

1772 }

1773

1774 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1775 {

1776 model->setProperty(0, "size", 800);

1777 verifyItem(0, 50., 800., false);

1778

1779 lvwph->maximizeVisibleArea(0);

1780 QTRY_COMPARE(lvwph->contentY(), 50.);

1781

1782 changeContentY(10);

1783 QTRY_COMPARE(lvwph->contentY(), 60.);

1784 changeContentY(-10);

1785 QTRY_COMPARE(lvwph->contentY(), 50.);

1786

1787 lvwph->showHeader();

1788 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1789 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1790 QCOMPARE(lvwph->m_minYExtent, 40.);

1791 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1792 QCOMPARE(lvwph->m_clipItem->clip(), true);

1793 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1794 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1795 QCOMPARE(lvwph->contentY(), 10.);

1796 verifyItem(0, -50., 800., false);

1797 }

1798

1799 void testMaximizeVisibleAreaAndShowHeader()

1800 {

1801 model->setProperty(0, "size", 800);

1802 verifyItem(0, 50., 800., false);

1803

1804 lvwph->maximizeVisibleArea(0);

1805 QTRY_COMPARE(lvwph->contentY(), 50.);

1806

1807 lvwph->showHeader();

1808 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1809 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1810 QCOMPARE(lvwph->m_minYExtent, 50.);

1811 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1812 QCOMPARE(lvwph->m_clipItem->clip(), true);

1813 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1814 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1815 QCOMPARE(lvwph->contentY(), 0.);

1816 verifyItem(0, -50., 800., false);

1817 }

1818

1819 void positionAtBeginningEmpty()

1820 {

1821 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1822 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1823

1824 lvwph->positionAtBeginning();

1825 }

1826

1827private:

1828 QQuickView *view;

1829 ListViewWithPageHeader *lvwph;

1830#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1831 QQuickListModel *model;

1832#else

1833 QQmlListModel *model;

1834#endif

1835 QQmlComponent *otherDelegate;

1836};

1837

1838QTEST_MAIN(ListViewWithPageHeaderTest)

1839

1840#include "listviewwithpageheadertest.moc"