tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 08bf9db help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

1911 lines 73 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// TODO Think on how doing a test for lost items

32// particullary making sure that lost items are culled

33// and then removed in the next updatePolish cycle

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(DASHVIEWSTEST_FOLDER "/listviewwithpageheadertest.qml"));

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

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

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

125 QVERIFY(lvwph);

126 QVERIFY(model);

127 QVERIFY(otherDelegate);

128 view->show();

129 QTest::qWaitForWindowExposed(view);

130

131 verifyInitialTopPosition();

132 }

133

134 void cleanup()

135 {

136 delete view;

137 }

138

139 void testCreationDeletion()

140 {

141 // Nothing, init/cleanup already tests this

142 }

143

144 void testDrag1PixelUp()

145 {

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

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

148 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

160 }

161

162 void testHeaderDetachDragDown()

163 {

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

165 QTest::qWait(100);

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

167 QTest::qWait(100);

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

187

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

189

190 verifyInitialTopPosition();

191 }

192

193 void testDrag375PixelUp()

194 {

195 changeContentY(375);

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

197 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

210 }

211

212 void testDrag520PixelUp()

213 {

214 changeContentY(520);

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

216 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

227 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

234 }

235

236 void testDragHeaderUpThenShow()

237 {

238 changeContentY(120);

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

240 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

252

253 changeContentY(-30);

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

255 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

267 }

268

269 void testDragHeaderUpThenShowWithoutHidingTotally()

270 {

271 changeContentY(10);

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

273 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

285

286 changeContentY(-1);

287

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

289 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

301 }

302

303 void testPositionAtBeginningIndex0Visible()

304 {

305 changeContentY(375);

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

307 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

320

321 lvwph->positionAtBeginning();

322

323 verifyInitialTopPosition();

324 }

325

326 void testPositionAtBeginningIndex0NotVisible()

327 {

328 changeContentY(520);

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

330 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

335 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

342

343 lvwph->positionAtBeginning();

344

345 verifyInitialTopPosition();

346 }

347

348 void testIndex0GrowOnScreen()

349 {

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

351

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

353 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

364 }

365

366 void testIndex0GrowOffScreen()

367 {

368 changeContentY(375);

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

370 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

383

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

385

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

387 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

400

401 scrollToTop();

402

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

404 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

415

416 changeContentY(30);

417

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

419 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

430 }

431

432 void testIndex0GrowNotCreated()

433 {

434 changeContentY(520);

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

436 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

441 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

448

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

450

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

452 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

457 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

464

465 scrollToTop();

466

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

468 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

479 }

480

481 void testShowHideShowHeaderAtBottom()

482 {

483 scrollToBottom();

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

485 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

496

497 changeContentY(-30);

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

499 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

510

511 changeContentY(30);

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

513 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

524

525 changeContentY(-30);

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

527 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

538 }

539

540 void testChangeDelegateAtBottom()

541 {

542 scrollToBottom();

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

544 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

555

556 lvwph->setDelegate(otherDelegate);

557

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

559 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

573 }

574

575 void testSetEmptyHeaderAtTop()

576 {

577 lvwph->setHeader(nullptr);

578

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

580 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

591 }

592

593 void testSetEmptyHeaderAtBottom()

594 {

595 scrollToBottom();

596 lvwph->setHeader(nullptr);

597

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

599 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

609

610 scrollToTop();

611

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

613 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

624 }

625

626 void testSetEmptyHeaderWhenPartlyShownClipped()

627 {

628 scrollToBottom();

629 changeContentY(-30);

630 lvwph->setHeader(nullptr);

631

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

633 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

643 QTRY_VERIFY(lvwph->isAtYEnd());

644

645 scrollToTop();

646

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

648 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

659 }

660

661 void testSetEmptyHeaderWhenPartlyShownNotClipped()

662 {

663 changeContentY(30);

664 lvwph->setHeader(nullptr);

665

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

667 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

678 }

679

680 void testSetNullDelegate()

681 {

682 lvwph->setDelegate(nullptr);

683

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

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

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

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

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

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

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

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

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

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

694 QVERIFY(lvwph->isAtYBeginning());

695 QVERIFY(lvwph->isAtYEnd());

696 }

697

698 void testInsertItems()

699 {

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

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

702

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

704 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

717 }

718

719 void testInsertItemsOnNotShownPosition()

720 {

721 changeContentY(700);

722

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

724 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

736

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

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

739

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

741 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

753

754 scrollToTop();

755

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

757 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

770 }

771

772 void testInsertItemsAtEndOfViewport()

773 {

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

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

776

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

778 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

790 }

791

792 void testInsertItemsBeforeValidIndex()

793 {

794 changeContentY(520);

795

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

797 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

802 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

809

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

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

812

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

814 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

819 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

826 }

827

828 void testInsertItemsBeforeViewport()

829 {

830 changeContentY(375);

831

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

833 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

846

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

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

849

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

851 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

864

865 scrollToTop();

866

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

868 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

881 }

882

883 void testInsertItemsAtBottom()

884 {

885 scrollToBottom();

886

887 QVERIFY(lvwph->isAtYEnd());

888

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

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

891

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

893 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

907

908 scrollToBottom();

909

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

911 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

923 QVERIFY(lvwph->isAtYEnd());

924 }

925

926 void testInsertItemAtTop()

927 {

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

929

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

931 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

943 QVERIFY(lvwph->isAtYBeginning());

944 }

945

946 void testInsertItem10SmallItemsAtTopWhenAtBottom()

947 {

948 scrollToBottom();

949

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

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

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

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

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

955 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

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

962 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

973

974 changeContentY(-1700);

975

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

977 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

997 }

998

999 void testInsertToEmpty()

1000 {

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

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

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

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

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

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

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

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

1009

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

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

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

1013 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1016 }

1017

1018 void testRemoveItemsAtTop()

1019 {

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

1021

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

1023 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1034 QVERIFY(lvwph->isAtYBeginning());

1035 }

1036

1037 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1038 {

1039 scrollToBottom();

1040

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

1042

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

1044 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1055 }

1056

1057 void testRemoveLastItemsAtBottom()

1058 {

1059 scrollToBottom();

1060

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

1062

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

1064 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1075 }

1076

1077 void testRemoveItemOutOfViewport()

1078 {

1079 changeContentY(520);

1080

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

1082 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1087 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1094

1095

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

1097

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

1099 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1111 }

1112

1113 void testMoveFirstItems()

1114 {

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

1116

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

1118 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1130

1131 }

1132

1133 void testMoveFirstOutOfVisibleItems()

1134 {

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

1136

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

1138 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1149

1150 }

1151

1152 void testMoveFirstToLastAtBottom()

1153 {

1154 scrollToBottom();

1155

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

1157 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1168

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

1170

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

1172 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1185 }

1186

1187 void testChangeSizeVisibleItemNotOnViewport()

1188 {

1189 changeContentY(440);

1190

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

1192 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1205

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

1207

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

1209 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1222 }

1223

1224 void testShowHeaderCloseToTheTop()

1225 {

1226 changeContentY(375);

1227

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

1229 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1242

1243 lvwph->showHeader();

1244

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

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

1247 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1260

1261 scrollToTop();

1262

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

1264 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1276 }

1277

1278 void testShowHeaderHalfShown()

1279 {

1280 changeContentY(20);

1281

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

1283 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1284 verifyItem(0, 30., 150., false);

1285 verifyItem(1, 180, 200., false);

1286 verifyItem(2, 380, 350., false);

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

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

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

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

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

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

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

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

1295

1296 lvwph->showHeader();

1297

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

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

1300 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1301 verifyItem(0, -20., 150., false);

1302 verifyItem(1, 130, 200., false);

1303 verifyItem(2, 330, 350., false);

1304 verifyItem(3, 680, 350., true);

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

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

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

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

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

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

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

1312

1313 scrollToTop();

1314

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

1316 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

1324 QCOMPARE(lvwph->m_headerItem->y(), -20.);

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

1326 QCOMPARE(lvwph->contentY(), -20.);

1327 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1328 }

1329

1330 void testShowHeaderAtBottom()

1331 {

1332 scrollToBottom();

1333

1334 lvwph->showHeader();

1335

1336 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1337 QTRY_VERIFY (lvwph->isAtYEnd());

1338 }

1339

1340 void growWindow()

1341 {

1342 view->rootObject()->setHeight(850);

1343

1344 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1345 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1346 verifyItem(0, 50., 150., false);

1347 verifyItem(1, 200., 200., false);

1348 verifyItem(2, 400., 350., false);

1349 verifyItem(3, 750., 350., false);

1350 verifyItem(4, 1100., 350., true);

1351 QCOMPARE(lvwph->m_minYExtent, 0.);

1352 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1353 QCOMPARE(lvwph->m_clipItem->clip(), false);

1354 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1355 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1356 QCOMPARE(lvwph->contentY(), 0.);

1357 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1358 }

1359

1360 void growWindowAtBottom()

1361 {

1362 scrollToBottom();

1363

1364 view->rootObject()->setHeight(850);

1365

1366 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1367 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1368 verifyItem(0, -550., 350., true);

1369 verifyItem(1, -200., 350., false);

1370 verifyItem(2, 150, 350., false);

1371 verifyItem(3, 500, 350., false);

1372 QCOMPARE(lvwph->m_minYExtent, 350.);

1373 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1374 QCOMPARE(lvwph->m_clipItem->clip(), false);

1375 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1376 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1377 QCOMPARE(lvwph->contentY(), 950.);

1378 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1379 }

1380

1381 void testCrashShowHeaderWithNoHeader()

1382 {

1383 lvwph->setHeader(nullptr);

1384 lvwph->showHeader();

1385 }

1386

1387 void testCullOnBottomEdge()

1388 {

1389 changeContentY(200);

1390

1391 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1392 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1393 verifyItem(0, -150., 150., true);

1394 verifyItem(1, 0., 200., false);

1395 verifyItem(2, 200., 350., false);

1396 verifyItem(3, 550., 350., true);

1397 QCOMPARE(lvwph->m_minYExtent, 0.);

1398 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1399 QCOMPARE(lvwph->m_clipItem->clip(), false);

1400 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1401 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1402 QCOMPARE(lvwph->contentY(), 200.);

1403 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1404 }

1405

1406 void testMaximizeVisibleArea()

1407 {

1408 bool res = lvwph->maximizeVisibleArea(2);

1409 QVERIFY(res);

1410 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1411

1412 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1413 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1414 verifyItem(0, -158., 150., true);

1415 verifyItem(1, -8., 200., false);

1416 verifyItem(2, 192, 350., false);

1417 verifyItem(3, 542, 350., true);

1418 QCOMPARE(lvwph->m_minYExtent, 0.);

1419 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1420 QCOMPARE(lvwph->m_clipItem->clip(), false);

1421 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1422 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1423 QCOMPARE(lvwph->contentY(), 208.);

1424 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1425 }

1426

1427 void testMaximizeVisibleAreaVisibleItems()

1428 {

1429 bool res = lvwph->maximizeVisibleArea(0);

1430 QVERIFY(res);

1431 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1432

1433 verifyInitialTopPosition();

1434

1435 res = lvwph->maximizeVisibleArea(1);

1436 QVERIFY(res);

1437 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1438

1439 verifyInitialTopPosition();

1440 }

1441

1442 void testMaximizeVisibleAreaInvalidIndexes()

1443 {

1444 bool res = lvwph->maximizeVisibleArea(-1);

1445 QVERIFY(!res);

1446 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1447

1448 verifyInitialTopPosition();

1449

1450 res = lvwph->maximizeVisibleArea(1000);

1451 QVERIFY(!res);

1452 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1453

1454 verifyInitialTopPosition();

1455

1456 res = lvwph->maximizeVisibleArea(4);

1457 QVERIFY(!res);

1458 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1459

1460 verifyInitialTopPosition();

1461 }

1462

1463 void testMaximizeVisibleAreaBigElement()

1464 {

1465 model->setProperty(2, "size", 4000);

1466 bool res = lvwph->maximizeVisibleArea(2);

1467 QVERIFY(res);

1468 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1469

1470 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1471 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1472 verifyItem(0, -350., 150., true);

1473 verifyItem(1, -200., 200., true);

1474 verifyItem(2, 0, 4000., false);

1475 QCOMPARE(lvwph->m_minYExtent, 0.);

1476 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1477 QCOMPARE(lvwph->m_clipItem->clip(), false);

1478 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1479 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1480 QCOMPARE(lvwph->contentY(), 400.);

1481 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1482 }

1483

1484 void testMaximizeVisibleAreaScrollDown()

1485 {

1486 changeContentY(250);

1487 bool res = lvwph->maximizeVisibleArea(1);

1488 QVERIFY(res);

1489 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1490

1491 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1492 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1493 verifyItem(0, -150., 150., true);

1494 verifyItem(1, 0., 200., false);

1495 verifyItem(2, 200, 350., false);

1496 verifyItem(3, 550, 350., true);

1497 QCOMPARE(lvwph->m_minYExtent, 0.);

1498 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1499 QCOMPARE(lvwph->m_clipItem->clip(), false);

1500 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1501 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1502 QCOMPARE(lvwph->contentY(), 200.);

1503 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1504 }

1505

1506 void testMaximizeVisibleAreaScrollDownBigElement()

1507 {

1508 model->setProperty(1, "size", 1000);

1509 changeContentY(1150);

1510 bool res = lvwph->maximizeVisibleArea(1);

1511 QVERIFY(res);

1512 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1513

1514 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1515 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1516 verifyItem(0, -458., 1000., false);

1517 verifyItem(1, 542., 350., true);

1518 QCOMPARE(lvwph->m_minYExtent, 525.);

1519 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1520 QCOMPARE(lvwph->m_clipItem->clip(), false);

1521 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1522 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1523 QCOMPARE(lvwph->contentY(), 658.);

1524 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1525 }

1526

1527 void testMaximizeVisibleAreaBigElementInTheMiddle()

1528 {

1529 model->setProperty(1, "size", 1000);

1530 changeContentY(650);

1531

1532 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1533 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1534 verifyItem(0, -450., 1000., false);

1535 verifyItem(1, 550., 350., true);

1536 QCOMPARE(lvwph->m_minYExtent, 525.);

1537 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1538 QCOMPARE(lvwph->m_clipItem->clip(), false);

1539 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1540 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1541 QCOMPARE(lvwph->contentY(), 650.);

1542 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1543

1544 bool res = lvwph->maximizeVisibleArea(1);

1545 QVERIFY(res);

1546 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1547

1548 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1549 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1550 verifyItem(0, -450., 1000., false);

1551 verifyItem(1, 550., 350., true);

1552 QCOMPARE(lvwph->m_minYExtent, 525.);

1553 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1554 QCOMPARE(lvwph->m_clipItem->clip(), false);

1555 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1556 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1557 QCOMPARE(lvwph->contentY(), 650.);

1558 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1559 }

1560

1561 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1562 {

1563 changeContentY(430);

1564 changeContentY(-30);

1565

1566 bool res = lvwph->maximizeVisibleArea(1);

1567 QVERIFY(res);

1568 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1569

1570 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1571 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1572 verifyItem(0, -150., 150., true);

1573 verifyItem(1, 0., 200., false);

1574 verifyItem(2, 200, 350., false);

1575 verifyItem(3, 550, 350., true);

1576 QCOMPARE(lvwph->m_minYExtent, 0.);

1577 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1578 QCOMPARE(lvwph->m_clipItem->clip(), false);

1579 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1580 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1581 QCOMPARE(lvwph->contentY(), 200.);

1582 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1583 }

1584

1585 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1586 {

1587 testMaximizeVisibleAreaTopWithHalfPageHeader();

1588

1589 changeContentY(-60);

1590 changeContentY(15);

1591

1592 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1593 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1594 verifyItem(0, -140., 150., false);

1595 verifyItem(1, 10., 200., false);

1596 verifyItem(2, 210, 350., false);

1597 verifyItem(3, 560, 350., true);

1598 QCOMPARE(lvwph->m_minYExtent, 0.);

1599 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1600 QCOMPARE(lvwph->m_clipItem->clip(), true);

1601 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1602 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1603 QCOMPARE(lvwph->contentY(), 155.);

1604 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1605 }

1606

1607 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1608 {

1609 changeContentY(430);

1610 changeContentY(-30);

1611

1612 bool res = lvwph->maximizeVisibleArea(3);

1613 QVERIFY(res);

1614 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1615

1616 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1617 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1618 verifyItem(0, -358., 200., true);

1619 verifyItem(1, -158., 350., false);

1620 verifyItem(2, 192, 350., false);

1621 verifyItem(3, 542, 350., true);

1622 QCOMPARE(lvwph->m_minYExtent, 162.5);

1623 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1624 QCOMPARE(lvwph->m_clipItem->clip(), false);

1625 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1626 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1627 QCOMPARE(lvwph->contentY(), 558.);

1628 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1629 }

1630

1631 void testMaximizeVisibleAreaWithItemResize()

1632 {

1633 model->setProperty(0, "size", 1000);

1634

1635 bool res = lvwph->maximizeVisibleArea(1);

1636 QVERIFY(res);

1637 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1638

1639 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1640 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1641 verifyItem(0, -658., 1000., false);

1642 verifyItem(1, 342., 200., false);

1643 verifyItem(2, 542, 350., true);

1644 QCOMPARE(lvwph->m_minYExtent, 0.);

1645 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1646 QCOMPARE(lvwph->m_clipItem->clip(), false);

1647 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1648 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1649 QCOMPARE(lvwph->contentY(), 708.);

1650 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1651 }

1652

1653 void addingRemoveItemsShouldNotChangeContentY()

1654 {

1655 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1656 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1657 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1658

1659 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1660 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1661 verifyItem(0, 50., 150., false);

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 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1669

1670 QCOMPARE(spy.count(), 0);

1671 }

1672

1673 void testOvershootOnSameSize()

1674 {

1675 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1676 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1677 QCOMPARE(lvwph->m_minYExtent, 0.);

1678 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1679 QCOMPARE(lvwph->m_clipItem->clip(), false);

1680 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1681 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1682 QCOMPARE(lvwph->contentY(), 0.);

1683

1684 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1685 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1686 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1687 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1688 verifyItem(0, 50., 392., false);

1689 verifyItem(1, 442., 100., false);

1690

1691 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1692

1693 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1694 QTest::qWait(100);

1695 QTest::mouseMove(view, QPoint(0, 5));

1696 QTest::qWait(100);

1697 QTest::mouseMove(view, QPoint(0, 10));

1698 QTest::qWait(100);

1699 QTest::mouseMove(view, QPoint(0, 15));

1700 QTest::qWait(100);

1701 QTest::mouseMove(view, QPoint(0, 20));

1702 QTest::qWait(100);

1703 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1704 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1705 verifyItem(0, 55., 392., false);

1706 verifyItem(1, 447., 100., false);

1707 QCOMPARE(lvwph->m_minYExtent, 0.);

1708 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1709

1710 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1711 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1712 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1713 verifyItem(0, 50., 392., false);

1714 verifyItem(1, 442., 100., false);

1715 }

1716

1717 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1718 {

1719 model->setProperty(0, "size", 800);

1720 verifyItem(0, 50., 800., false);

1721

1722 lvwph->maximizeVisibleArea(0);

1723 QTRY_COMPARE(lvwph->contentY(), 50.);

1724

1725 changeContentY(10);

1726 QTRY_COMPARE(lvwph->contentY(), 60.);

1727

1728 lvwph->showHeader();

1729 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1730 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1731 QCOMPARE(lvwph->m_minYExtent, 50.);

1732 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1733 QCOMPARE(lvwph->m_clipItem->clip(), true);

1734 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1735 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1736 QCOMPARE(lvwph->contentY(), 10.);

1737 verifyItem(0, -60., 800., false);

1738 }

1739

1740 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1741 {

1742 model->setProperty(0, "size", 800);

1743 verifyItem(0, 50., 800., false);

1744

1745 lvwph->maximizeVisibleArea(0);

1746 QTRY_COMPARE(lvwph->contentY(), 50.);

1747

1748 changeContentY(-10);

1749 QTRY_COMPARE(lvwph->contentY(), 40.);

1750

1751 lvwph->showHeader();

1752 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1753 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1754 QCOMPARE(lvwph->m_minYExtent, 40.);

1755 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1756 QCOMPARE(lvwph->m_clipItem->clip(), true);

1757 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1758 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1759 QCOMPARE(lvwph->contentY(), 0.);

1760 verifyItem(0, -40., 800., false);

1761 }

1762

1763 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1764 {

1765 model->setProperty(0, "size", 800);

1766 verifyItem(0, 50., 800., false);

1767

1768 lvwph->maximizeVisibleArea(0);

1769 QTRY_COMPARE(lvwph->contentY(), 50.);

1770

1771 changeContentY(-10);

1772 QTRY_COMPARE(lvwph->contentY(), 40.);

1773 changeContentY(10);

1774 QTRY_COMPARE(lvwph->contentY(), 50.);

1775

1776 lvwph->showHeader();

1777 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1778

1779 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1780 QCOMPARE(lvwph->m_minYExtent, 50.);

1781 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1782 QCOMPARE(lvwph->m_clipItem->clip(), true);

1783 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1784 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1785 QCOMPARE(lvwph->contentY(), 0.);

1786 verifyItem(0, -50., 800., false);

1787 }

1788

1789 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1790 {

1791 model->setProperty(0, "size", 800);

1792 verifyItem(0, 50., 800., false);

1793

1794 lvwph->maximizeVisibleArea(0);

1795 QTRY_COMPARE(lvwph->contentY(), 50.);

1796

1797 changeContentY(10);

1798 QTRY_COMPARE(lvwph->contentY(), 60.);

1799 changeContentY(-10);

1800 QTRY_COMPARE(lvwph->contentY(), 50.);

1801

1802 lvwph->showHeader();

1803 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1804 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1805 QCOMPARE(lvwph->m_minYExtent, 40.);

1806 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1807 QCOMPARE(lvwph->m_clipItem->clip(), true);

1808 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1809 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1810 QCOMPARE(lvwph->contentY(), 10.);

1811 verifyItem(0, -50., 800., false);

1812 }

1813

1814 void testMaximizeVisibleAreaAndShowHeader()

1815 {

1816 model->setProperty(0, "size", 800);

1817 verifyItem(0, 50., 800., false);

1818

1819 lvwph->maximizeVisibleArea(0);

1820 QTRY_COMPARE(lvwph->contentY(), 50.);

1821

1822 lvwph->showHeader();

1823 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1824 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1825 QCOMPARE(lvwph->m_minYExtent, 50.);

1826 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1827 QCOMPARE(lvwph->m_clipItem->clip(), true);

1828 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1829 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1830 QCOMPARE(lvwph->contentY(), 0.);

1831 verifyItem(0, -50., 800., false);

1832 }

1833

1834 void positionAtBeginningEmpty()

1835 {

1836 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1837 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1838

1839 lvwph->positionAtBeginning();

1840 }

1841

1842 void testHeaderPositionBug1240118()

1843 {

1844 scrollToBottom();

1845 lvwph->showHeader();

1846 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1847 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1848 model->setProperty(3, "size", 10);

1849 model->setProperty(4, "size", 10);

1850 model->setProperty(5, "size", 10);

1851 model->setProperty(6, "size", 10);

1852 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1853 }

1854

1855 void testResizeRemoveInsertBug1279434()

1856 {

1857 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1858 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1859

1860 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1861 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1862 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1863 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1864 verifyItem(0, 50., 125., false);

1865 verifyItem(1, 175., 100., false);

1866

1867 lvwph->setContentY(175);

1868

1869 model->setProperty(1, "size", 4);

1870 model->setProperty(0, "size", 4);

1871

1872 model->setProperty(0, "size", 6);

1873

1874 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1875 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1876 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1877

1878 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1879 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1880 }

1881

1882 void testResizeScrolledBigItem()

1883 {

1884 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1885 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1886

1887 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1888 changeContentY(8000);

1889

1890 // Pretend the list is busy requesting some other index

1891 lvwph->m_asyncRequestedIndex = 4;

1892

1893 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1894 // This resize makes the item go outside the viewport so its deleted

1895 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1896 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1897 // On the next polish the item will be readded

1898 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1899 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1900 }

1901

1902private:

1903 QQuickView *view;

1904 ListViewWithPageHeader *lvwph;

1905 QQmlListModel *model;

1906 QQmlComponent *otherDelegate;

1907};

1908

1909QTEST_MAIN(ListViewWithPageHeaderTest)

1910

1911#include "listviewwithpageheadertest.moc"