tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on ffe76cc help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

1950 lines 75 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#include <private/qqmllistmodel_p.h>

27#include <private/qquickanimation_p.h>

28#include <private/qquickitem_p.h>

29#pragma GCC diagnostic pop

31#include <limits>

33// TODO Think on how doing a test for lost items

34// particullary making sure that lost items are culled

35// and then removed in the next updatePolish cycle

37class ListViewWithPageHeaderTest : public QObject

38{

39 Q_OBJECT

41private:

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

43 {

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

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

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

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

48 }

50 void changeContentY(qreal change)

51 {

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

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

54 const qreal jump = 25;

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

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

57 QTest::qWait(1);

58 }

59 } else {

60 const qreal jump = -25;

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

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

63 QTest::qWait(1);

64 }

65 }

66 lvwph->setContentY(dest);

67 QTest::qWait(1);

68 }

70 void scrollToTop()

71 {

72 const qreal jump = -25;

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

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

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

76 } else {

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

78 }

79 QTest::qWait(1);

80 }

81 }

83 void scrollToBottom()

84 {

85 const qreal jump = 25;

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

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

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

89 } else {

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

91 }

92 QTest::qWait(1);

93 }

94 }

96 void verifyInitialTopPosition()

97 {

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

99 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

111 }

112

113private Q_SLOTS:

114

115 void initTestCase()

116 {

117 }

118

119 void init()

120 {

121 view = new QQuickView();

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

123 view->setSource(QUrl::fromLocalFile(DASHVIEWSTEST_FOLDER "/listviewwithpageheadertest.qml"));

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

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

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

127 QVERIFY(lvwph);

128 QVERIFY(model);

129 QVERIFY(otherDelegate);

130 view->show();

131 QTest::qWaitForWindowExposed(view);

132

133 verifyInitialTopPosition();

134 }

135

136 void cleanup()

137 {

138 delete view;

139 }

140

141 void testCreationDeletion()

142 {

143 // Nothing, init/cleanup already tests this

144 }

145

146 void testDrag1PixelUp()

147 {

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

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

150 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

162 }

163

164 void testHeaderDetachDragDown()

165 {

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

167 QTest::qWait(100);

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

189

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

191

192 verifyInitialTopPosition();

193 }

194

195 void testDrag375PixelUp()

196 {

197 changeContentY(375);

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

199 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

212 }

213

214 void testDrag520PixelUp()

215 {

216 changeContentY(520);

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

218 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

229 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

236 }

237

238 void testDragHeaderUpThenShow()

239 {

240 changeContentY(120);

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

242 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

254

255 changeContentY(-30);

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

257 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

269 }

270

271 void testDragHeaderUpThenShowWithoutHidingTotally()

272 {

273 changeContentY(10);

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

275 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

287

288 changeContentY(-1);

289

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

291 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

303 }

304

305 void testPositionAtBeginningIndex0Visible()

306 {

307 changeContentY(375);

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

309 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

322

323 lvwph->positionAtBeginning();

324

325 verifyInitialTopPosition();

326 }

327

328 void testPositionAtBeginningIndex0NotVisible()

329 {

330 changeContentY(520);

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

332 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

337 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

344

345 lvwph->positionAtBeginning();

346

347 verifyInitialTopPosition();

348 }

349

350 void testIndex0GrowOnScreen()

351 {

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

353

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

355 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

366 }

367

368 void testIndex0GrowOffScreen()

369 {

370 changeContentY(375);

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

372 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

385

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

387

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

389 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

402

403 scrollToTop();

404

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

406 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

417

418 changeContentY(30);

419

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

421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

432 }

433

434 void testIndex0GrowNotCreated()

435 {

436 changeContentY(520);

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

438 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

443 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

450

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

452

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

454 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

459 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

466

467 scrollToTop();

468

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

470 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

481 }

482

483 void testShowHideShowHeaderAtBottom()

484 {

485 scrollToBottom();

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

487 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

498

499 changeContentY(-30);

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

501 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

512

513 changeContentY(30);

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

515 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

526

527 changeContentY(-30);

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

529 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

540 }

541

542 void testChangeDelegateAtBottom()

543 {

544 scrollToBottom();

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

546 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

557

558 lvwph->setDelegate(otherDelegate);

559

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

561 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

575 }

576

577 void testSetEmptyHeaderAtTop()

578 {

579 lvwph->setHeader(nullptr);

580

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

582 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

593 }

594

595 void testSetEmptyHeaderAtBottom()

596 {

597 scrollToBottom();

598 lvwph->setHeader(nullptr);

599

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

601 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

611

612 scrollToTop();

613

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

615 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

626 }

627

628 void testSetEmptyHeaderWhenPartlyShownClipped()

629 {

630 scrollToBottom();

631 changeContentY(-30);

632 lvwph->setHeader(nullptr);

633

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

635 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

645 QTRY_VERIFY(lvwph->isAtYEnd());

646

647 scrollToTop();

648

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

650 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

661 }

662

663 void testSetEmptyHeaderWhenPartlyShownNotClipped()

664 {

665 changeContentY(30);

666 lvwph->setHeader(nullptr);

667

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

669 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

680 }

681

682 void testSetNullDelegate()

683 {

684 lvwph->setDelegate(nullptr);

685

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

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

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

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

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

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

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

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

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

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

696 QVERIFY(lvwph->isAtYBeginning());

697 QVERIFY(lvwph->isAtYEnd());

698 }

699

700 void testInsertItems()

701 {

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

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

704

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

706 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

719 }

720

721 void testInsertItemsOnNotShownPosition()

722 {

723 changeContentY(700);

724

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

726 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

738

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

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

741

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

743 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

755

756 scrollToTop();

757

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

759 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

772 }

773

774 void testInsertItemsAtEndOfViewport()

775 {

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

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

778

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

780 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

792 }

793

794 void testInsertItemsBeforeValidIndex()

795 {

796 changeContentY(520);

797

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

799 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

804 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

811

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

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

814

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

816 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

821 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

828 }

829

830 void testInsertItemsBeforeViewport()

831 {

832 changeContentY(375);

833

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

835 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

848

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

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

851

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

853 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

866

867 scrollToTop();

868

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

870 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

883 }

884

885 void testInsertItemsAtBottom()

886 {

887 scrollToBottom();

888

889 QVERIFY(lvwph->isAtYEnd());

890

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

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

893

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

895 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

909

910 scrollToBottom();

911

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

913 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

925 QVERIFY(lvwph->isAtYEnd());

926 }

927

928 void testInsertItemAtTop()

929 {

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

931

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

933 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

945 QVERIFY(lvwph->isAtYBeginning());

946 }

947

948 void testInsertItem10SmallItemsAtTopWhenAtBottom()

949 {

950 scrollToBottom();

951

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 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

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

964 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

975

976 changeContentY(-1700);

977

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

979 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

999 }

1000

1001 void testInsertToEmpty()

1002 {

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

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

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

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

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

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

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

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

1011

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

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

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

1015 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1018 }

1019

1020 void testRemoveItemsAtTop()

1021 {

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

1023

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

1025 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1036 QVERIFY(lvwph->isAtYBeginning());

1037 }

1038

1039 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1040 {

1041 scrollToBottom();

1042

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

1044

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

1046 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1057 }

1058

1059 void testRemoveLastItemsAtBottom()

1060 {

1061 scrollToBottom();

1062

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

1064

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

1066 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1077 }

1078

1079 void testRemoveItemOutOfViewport()

1080 {

1081 changeContentY(520);

1082

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

1084 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1089 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1096

1097

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

1099

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

1101 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1113 }

1114

1115 void testMoveFirstItems()

1116 {

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

1118

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

1120 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1132

1133 }

1134

1135 void testMoveFirstOutOfVisibleItems()

1136 {

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

1138

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

1140 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1151

1152 }

1153

1154 void testMoveFirstToLastAtBottom()

1155 {

1156 scrollToBottom();

1157

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

1159 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1170

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

1172

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

1174 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1187 }

1188

1189 void testChangeSizeVisibleItemNotOnViewport()

1190 {

1191 changeContentY(440);

1192

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

1194 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1207

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

1209

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

1211 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1224 }

1225

1226 void testShowHeaderCloseToTheTop()

1227 {

1228 changeContentY(375);

1229

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

1231 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1244

1245 lvwph->showHeader();

1246

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

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

1249 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1262

1263 scrollToTop();

1264

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

1266 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

1274 QCOMPARE(lvwph->m_headerItem->y(), -50.);

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

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

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

1278 }

1279

1280 void testShowHeaderHalfShown()

1281 {

1282 changeContentY(20);

1283

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

1285 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1286 verifyItem(0, 30., 150., false);

1287 verifyItem(1, 180, 200., false);

1288 verifyItem(2, 380, 350., false);

1289 verifyItem(3, 730, 350., true);

1290 QCOMPARE(lvwph->m_minYExtent, 0.);

1291 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1292 QCOMPARE(lvwph->m_clipItem->clip(), false);

1293 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1294 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1295 QCOMPARE(lvwph->contentY(), 20.);

1296 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1297

1298 lvwph->showHeader();

1299

1300 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1301 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1302 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1303 verifyItem(0, -20., 150., false);

1304 verifyItem(1, 130, 200., false);

1305 verifyItem(2, 330, 350., false);

1306 verifyItem(3, 680, 350., true);

1307 QCOMPARE(lvwph->m_minYExtent, 20.);

1308 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1309 QCOMPARE(lvwph->m_clipItem->clip(), true);

1310 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1311 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1312 QCOMPARE(lvwph->contentY(), 0.);

1313 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1314

1315 scrollToTop();

1316

1317 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1318 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1319 verifyItem(0, 50., 150., false);

1320 verifyItem(1, 200., 200., false);

1321 verifyItem(2, 400., 350., false);

1322 verifyItem(3, 750, 350., true);

1323 QCOMPARE(lvwph->m_minYExtent, 20.);

1324 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1325 QCOMPARE(lvwph->m_clipItem->clip(), false);

1326 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1327 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1328 QCOMPARE(lvwph->contentY(), -20.);

1329 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1330 }

1331

1332 void testShowHeaderAtBottom()

1333 {

1334 scrollToBottom();

1335

1336 lvwph->showHeader();

1337

1338 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1339 QTRY_VERIFY (lvwph->isAtYEnd());

1340 }

1341

1342 void growWindow()

1343 {

1344 view->rootObject()->setHeight(850);

1345

1346 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1347 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1348 verifyItem(0, 50., 150., false);

1349 verifyItem(1, 200., 200., false);

1350 verifyItem(2, 400., 350., false);

1351 verifyItem(3, 750., 350., false);

1352 verifyItem(4, 1100., 350., true);

1353 QCOMPARE(lvwph->m_minYExtent, 0.);

1354 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1355 QCOMPARE(lvwph->m_clipItem->clip(), false);

1356 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1357 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1358 QCOMPARE(lvwph->contentY(), 0.);

1359 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1360 }

1361

1362 void growWindowAtBottom()

1363 {

1364 scrollToBottom();

1365

1366 view->rootObject()->setHeight(850);

1367

1368 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1369 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1370 verifyItem(0, -550., 350., true);

1371 verifyItem(1, -200., 350., false);

1372 verifyItem(2, 150, 350., false);

1373 verifyItem(3, 500, 350., false);

1374 QCOMPARE(lvwph->m_minYExtent, 350.);

1375 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1376 QCOMPARE(lvwph->m_clipItem->clip(), false);

1377 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1378 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1379 QCOMPARE(lvwph->contentY(), 950.);

1380 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1381 }

1382

1383 void testCrashShowHeaderWithNoHeader()

1384 {

1385 lvwph->setHeader(nullptr);

1386 lvwph->showHeader();

1387 }

1388

1389 void testCullOnBottomEdge()

1390 {

1391 changeContentY(200);

1392

1393 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1394 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1395 verifyItem(0, -150., 150., true);

1396 verifyItem(1, 0., 200., false);

1397 verifyItem(2, 200., 350., false);

1398 verifyItem(3, 550., 350., true);

1399 QCOMPARE(lvwph->m_minYExtent, 0.);

1400 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1401 QCOMPARE(lvwph->m_clipItem->clip(), false);

1402 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1403 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1404 QCOMPARE(lvwph->contentY(), 200.);

1405 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1406 }

1407

1408 void testMaximizeVisibleArea()

1409 {

1410 bool res = lvwph->maximizeVisibleArea(2);

1411 QVERIFY(res);

1412 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1413

1414 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1415 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1416 verifyItem(0, -158., 150., true);

1417 verifyItem(1, -8., 200., false);

1418 verifyItem(2, 192, 350., false);

1419 verifyItem(3, 542, 350., true);

1420 QCOMPARE(lvwph->m_minYExtent, 0.);

1421 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1422 QCOMPARE(lvwph->m_clipItem->clip(), false);

1423 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1424 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1425 QCOMPARE(lvwph->contentY(), 208.);

1426 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1427 }

1428

1429 void testMaximizeVisibleAreaVisibleItems()

1430 {

1431 bool res = lvwph->maximizeVisibleArea(0);

1432 QVERIFY(res);

1433 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1434

1435 verifyInitialTopPosition();

1436

1437 res = lvwph->maximizeVisibleArea(1);

1438 QVERIFY(res);

1439 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1440

1441 verifyInitialTopPosition();

1442 }

1443

1444 void testMaximizeVisibleAreaInvalidIndexes()

1445 {

1446 bool res = lvwph->maximizeVisibleArea(-1);

1447 QVERIFY(!res);

1448 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1449

1450 verifyInitialTopPosition();

1451

1452 res = lvwph->maximizeVisibleArea(1000);

1453 QVERIFY(!res);

1454 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1455

1456 verifyInitialTopPosition();

1457

1458 res = lvwph->maximizeVisibleArea(4);

1459 QVERIFY(!res);

1460 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1461

1462 verifyInitialTopPosition();

1463 }

1464

1465 void testMaximizeVisibleAreaBigElement()

1466 {

1467 model->setProperty(2, "size", 4000);

1468 bool res = lvwph->maximizeVisibleArea(2);

1469 QVERIFY(res);

1470 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1471

1472 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1473 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1474 verifyItem(0, -350., 150., true);

1475 verifyItem(1, -200., 200., true);

1476 verifyItem(2, 0, 4000., false);

1477 QCOMPARE(lvwph->m_minYExtent, 0.);

1478 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1479 QCOMPARE(lvwph->m_clipItem->clip(), false);

1480 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1481 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1482 QCOMPARE(lvwph->contentY(), 400.);

1483 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1484 }

1485

1486 void testMaximizeVisibleAreaScrollDown()

1487 {

1488 changeContentY(250);

1489 bool res = lvwph->maximizeVisibleArea(1);

1490 QVERIFY(res);

1491 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1492

1493 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1494 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1495 verifyItem(0, -150., 150., true);

1496 verifyItem(1, 0., 200., false);

1497 verifyItem(2, 200, 350., false);

1498 verifyItem(3, 550, 350., true);

1499 QCOMPARE(lvwph->m_minYExtent, 0.);

1500 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1501 QCOMPARE(lvwph->m_clipItem->clip(), false);

1502 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1503 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1504 QCOMPARE(lvwph->contentY(), 200.);

1505 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1506 }

1507

1508 void testMaximizeVisibleAreaScrollDownBigElement()

1509 {

1510 model->setProperty(1, "size", 1000);

1511 changeContentY(1150);

1512 bool res = lvwph->maximizeVisibleArea(1);

1513 QVERIFY(res);

1514 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1515

1516 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1517 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1518 verifyItem(0, -458., 1000., false);

1519 verifyItem(1, 542., 350., true);

1520 QCOMPARE(lvwph->m_minYExtent, 525.);

1521 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1522 QCOMPARE(lvwph->m_clipItem->clip(), false);

1523 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1524 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1525 QCOMPARE(lvwph->contentY(), 658.);

1526 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1527 }

1528

1529 void testMaximizeVisibleAreaBigElementInTheMiddle()

1530 {

1531 model->setProperty(1, "size", 1000);

1532 changeContentY(650);

1533

1534 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1535 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1536 verifyItem(0, -450., 1000., false);

1537 verifyItem(1, 550., 350., true);

1538 QCOMPARE(lvwph->m_minYExtent, 525.);

1539 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1540 QCOMPARE(lvwph->m_clipItem->clip(), false);

1541 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1542 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1543 QCOMPARE(lvwph->contentY(), 650.);

1544 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1545

1546 bool res = lvwph->maximizeVisibleArea(1);

1547 QVERIFY(res);

1548 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1549

1550 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1551 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1552 verifyItem(0, -450., 1000., false);

1553 verifyItem(1, 550., 350., true);

1554 QCOMPARE(lvwph->m_minYExtent, 525.);

1555 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1556 QCOMPARE(lvwph->m_clipItem->clip(), false);

1557 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1558 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1559 QCOMPARE(lvwph->contentY(), 650.);

1560 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1561 }

1562

1563 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1564 {

1565 changeContentY(430);

1566 changeContentY(-30);

1567

1568 bool res = lvwph->maximizeVisibleArea(1);

1569 QVERIFY(res);

1570 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1571

1572 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1573 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1574 verifyItem(0, -150., 150., true);

1575 verifyItem(1, 0., 200., false);

1576 verifyItem(2, 200, 350., false);

1577 verifyItem(3, 550, 350., true);

1578 QCOMPARE(lvwph->m_minYExtent, 0.);

1579 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1580 QCOMPARE(lvwph->m_clipItem->clip(), false);

1581 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1582 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1583 QCOMPARE(lvwph->contentY(), 200.);

1584 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1585 }

1586

1587 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1588 {

1589 testMaximizeVisibleAreaTopWithHalfPageHeader();

1590

1591 changeContentY(-60);

1592 changeContentY(15);

1593

1594 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1595 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1596 verifyItem(0, -140., 150., false);

1597 verifyItem(1, 10., 200., false);

1598 verifyItem(2, 210, 350., false);

1599 verifyItem(3, 560, 350., true);

1600 QCOMPARE(lvwph->m_minYExtent, 0.);

1601 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1602 QCOMPARE(lvwph->m_clipItem->clip(), true);

1603 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1604 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1605 QCOMPARE(lvwph->contentY(), 155.);

1606 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1607 }

1608

1609 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1610 {

1611 changeContentY(430);

1612 changeContentY(-30);

1613

1614 bool res = lvwph->maximizeVisibleArea(3);

1615 QVERIFY(res);

1616 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1617

1618 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1619 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1620 verifyItem(0, -358., 200., true);

1621 verifyItem(1, -158., 350., false);

1622 verifyItem(2, 192, 350., false);

1623 verifyItem(3, 542, 350., true);

1624 QCOMPARE(lvwph->m_minYExtent, 162.5);

1625 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1626 QCOMPARE(lvwph->m_clipItem->clip(), false);

1627 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1628 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1629 QCOMPARE(lvwph->contentY(), 558.);

1630 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1631 }

1632

1633 void testMaximizeVisibleAreaWithItemResize()

1634 {

1635 model->setProperty(0, "size", 1000);

1636

1637 bool res = lvwph->maximizeVisibleArea(1);

1638 QVERIFY(res);

1639 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1640

1641 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1642 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1643 verifyItem(0, -658., 1000., false);

1644 verifyItem(1, 342., 200., false);

1645 verifyItem(2, 542, 350., true);

1646 QCOMPARE(lvwph->m_minYExtent, 0.);

1647 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1648 QCOMPARE(lvwph->m_clipItem->clip(), false);

1649 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1650 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1651 QCOMPARE(lvwph->contentY(), 708.);

1652 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1653 }

1654

1655 void addingRemoveItemsShouldNotChangeContentY()

1656 {

1657 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1658 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1659 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1660

1661 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1662 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1663 verifyItem(0, 50., 150., false);

1664 QCOMPARE(lvwph->m_minYExtent, 0.);

1665 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1666 QCOMPARE(lvwph->m_clipItem->clip(), false);

1667 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1668 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1669 QCOMPARE(lvwph->contentY(), 0.);

1670 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1671

1672 QCOMPARE(spy.count(), 0);

1673 }

1674

1675 void testOvershootOnSameSize()

1676 {

1677 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1678 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1679 QCOMPARE(lvwph->m_minYExtent, 0.);

1680 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1681 QCOMPARE(lvwph->m_clipItem->clip(), false);

1682 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1683 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1684 QCOMPARE(lvwph->contentY(), 0.);

1685

1686 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1687 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1688 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1689 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1690 verifyItem(0, 50., 392., false);

1691 verifyItem(1, 442., 100., false);

1692

1693 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1694

1695 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1696 QTest::qWait(100);

1697 QTest::mouseMove(view, QPoint(0, 5));

1698 QTest::qWait(100);

1699 QTest::mouseMove(view, QPoint(0, 10));

1700 QTest::qWait(100);

1701 QTest::mouseMove(view, QPoint(0, 15));

1702 QTest::qWait(100);

1703 QTest::mouseMove(view, QPoint(0, 20));

1704 QTest::qWait(100);

1705 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1706 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1707 verifyItem(0, 55., 392., false);

1708 verifyItem(1, 447., 100., false);

1709 QCOMPARE(lvwph->m_minYExtent, 0.);

1710 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1711

1712 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1713 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1714 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1715 verifyItem(0, 50., 392., false);

1716 verifyItem(1, 442., 100., false);

1717 }

1718

1719 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1720 {

1721 model->setProperty(0, "size", 800);

1722 verifyItem(0, 50., 800., false);

1723

1724 lvwph->maximizeVisibleArea(0);

1725 QTRY_COMPARE(lvwph->contentY(), 50.);

1726

1727 changeContentY(10);

1728 QTRY_COMPARE(lvwph->contentY(), 60.);

1729

1730 lvwph->showHeader();

1731 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1732 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1733 QCOMPARE(lvwph->m_minYExtent, 50.);

1734 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1735 QCOMPARE(lvwph->m_clipItem->clip(), true);

1736 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1737 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1738 QCOMPARE(lvwph->contentY(), 10.);

1739 verifyItem(0, -60., 800., false);

1740 }

1741

1742 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1743 {

1744 model->setProperty(0, "size", 800);

1745 verifyItem(0, 50., 800., false);

1746

1747 lvwph->maximizeVisibleArea(0);

1748 QTRY_COMPARE(lvwph->contentY(), 50.);

1749

1750 changeContentY(-10);

1751 QTRY_COMPARE(lvwph->contentY(), 40.);

1752

1753 lvwph->showHeader();

1754 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1755 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1756 QCOMPARE(lvwph->m_minYExtent, 40.);

1757 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1758 QCOMPARE(lvwph->m_clipItem->clip(), true);

1759 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1760 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1761 QCOMPARE(lvwph->contentY(), 0.);

1762 verifyItem(0, -40., 800., false);

1763 }

1764

1765 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1766 {

1767 model->setProperty(0, "size", 800);

1768 verifyItem(0, 50., 800., false);

1769

1770 lvwph->maximizeVisibleArea(0);

1771 QTRY_COMPARE(lvwph->contentY(), 50.);

1772

1773 changeContentY(-10);

1774 QTRY_COMPARE(lvwph->contentY(), 40.);

1775 changeContentY(10);

1776 QTRY_COMPARE(lvwph->contentY(), 50.);

1777

1778 lvwph->showHeader();

1779 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1780

1781 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1782 QCOMPARE(lvwph->m_minYExtent, 50.);

1783 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1784 QCOMPARE(lvwph->m_clipItem->clip(), true);

1785 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1786 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1787 QCOMPARE(lvwph->contentY(), 0.);

1788 verifyItem(0, -50., 800., false);

1789 }

1790

1791 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1792 {

1793 model->setProperty(0, "size", 800);

1794 verifyItem(0, 50., 800., false);

1795

1796 lvwph->maximizeVisibleArea(0);

1797 QTRY_COMPARE(lvwph->contentY(), 50.);

1798

1799 changeContentY(10);

1800 QTRY_COMPARE(lvwph->contentY(), 60.);

1801 changeContentY(-10);

1802 QTRY_COMPARE(lvwph->contentY(), 50.);

1803

1804 lvwph->showHeader();

1805 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1806 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1807 QCOMPARE(lvwph->m_minYExtent, 40.);

1808 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1809 QCOMPARE(lvwph->m_clipItem->clip(), true);

1810 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1811 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1812 QCOMPARE(lvwph->contentY(), 10.);

1813 verifyItem(0, -50., 800., false);

1814 }

1815

1816 void testMaximizeVisibleAreaAndShowHeader()

1817 {

1818 model->setProperty(0, "size", 800);

1819 verifyItem(0, 50., 800., false);

1820

1821 lvwph->maximizeVisibleArea(0);

1822 QTRY_COMPARE(lvwph->contentY(), 50.);

1823

1824 lvwph->showHeader();

1825 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1826 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1827 QCOMPARE(lvwph->m_minYExtent, 50.);

1828 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1829 QCOMPARE(lvwph->m_clipItem->clip(), true);

1830 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1831 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1832 QCOMPARE(lvwph->contentY(), 0.);

1833 verifyItem(0, -50., 800., false);

1834 }

1835

1836 void positionAtBeginningEmpty()

1837 {

1838 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1839 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1840

1841 lvwph->positionAtBeginning();

1842 }

1843

1844 void testHeaderPositionBug1240118()

1845 {

1846 scrollToBottom();

1847 lvwph->showHeader();

1848 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1849 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1850 model->setProperty(3, "size", 10);

1851 model->setProperty(4, "size", 10);

1852 model->setProperty(5, "size", 10);

1853 model->setProperty(6, "size", 10);

1854 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1855 }

1856

1857 void testResizeRemoveInsertBug1279434()

1858 {

1859 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1860 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1861

1862 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1863 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1864 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1865 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1866 verifyItem(0, 50., 125., false);

1867 verifyItem(1, 175., 100., false);

1868

1869 lvwph->setContentY(175);

1870

1871 model->setProperty(1, "size", 4);

1872 model->setProperty(0, "size", 4);

1873

1874 model->setProperty(0, "size", 6);

1875

1876 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1877 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1878 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1879

1880 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1881 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1882 }

1883

1884 void testResizeScrolledBigItem()

1885 {

1886 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1887 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1888

1889 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1890 changeContentY(8000);

1891

1892 // Pretend the list is busy requesting some other index

1893 lvwph->m_asyncRequestedIndex = 4;

1894

1895 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1896 // This resize makes the item go outside the viewport so its deleted

1897 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1898 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1899 // On the next polish the item will be readded

1900 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1901 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1902 }

1903

1904 void testNoCacheBuffer()

1905 {

1906 lvwph->setCacheBuffer(0);

1907 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1908 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1909 verifyItem(0, 50., 150., false);

1910 verifyItem(1, 200., 200., false);

1911 verifyItem(2, 400., 350., false);

1912 QCOMPARE(lvwph->m_minYExtent, 0.);

1913 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1914 QCOMPARE(lvwph->m_clipItem->clip(), false);

1915 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1916 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1917 QCOMPARE(lvwph->contentY(), 0.);

1918 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1919 }

1920

1921 void testAllCacheBuffer()

1922 {

1923 lvwph->setCacheBuffer(std::numeric_limits<qreal>::max());

1924 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

1925 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1926 verifyItem(0, 50., 150., false);

1927 verifyItem(1, 200., 200., false);

1928 verifyItem(2, 400., 350., false);

1929 verifyItem(3, 750., 350., true);

1930 verifyItem(4, 1100., 350., true);

1931 verifyItem(5, 1450., 350., true);

1932 QCOMPARE(lvwph->m_minYExtent, 0.);

1933 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1934 QCOMPARE(lvwph->m_clipItem->clip(), false);

1935 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1936 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1937 QCOMPARE(lvwph->contentY(), 0.);

1938 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1939 }

1940

1941private:

1942 QQuickView *view;

1943 ListViewWithPageHeader *lvwph;

1944 QQmlListModel *model;

1945 QQmlComponent *otherDelegate;

1946};

1947

1948QTEST_MAIN(ListViewWithPageHeaderTest)

1949

1950#include "listviewwithpageheadertest.moc"