tests/plugins/DashViews/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on fb9fd69 help sign in

unity8/tests/plugins/DashViews/listviewwithpageheadertest.cpp

1926 lines 74 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QSignalSpy>

23#include <QtTestGui>

24#pragma GCC diagnostic push

25#pragma GCC diagnostic ignored "-pedantic"

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

27#include <private/qquicklistmodel_p.h>

28#else

29#include <private/qqmllistmodel_p.h>

30#endif

31#include <private/qquickanimation_p.h>

32#include <private/qquickitem_p.h>

33#pragma GCC diagnostic pop

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

36// particullary making sure that lost items are culled

37// and then removed in the next updatePolish cycle

39class ListViewWithPageHeaderTest : public QObject

40{

41 Q_OBJECT

43private:

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

45 {

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

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

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

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

50 }

52 void changeContentY(qreal change)

53 {

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

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

56 const qreal jump = 25;

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

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

59 QTest::qWait(1);

60 }

61 } else {

62 const qreal jump = -25;

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

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

65 QTest::qWait(1);

66 }

67 }

68 lvwph->setContentY(dest);

69 QTest::qWait(1);

70 }

72 void scrollToTop()

73 {

74 const qreal jump = -25;

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

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

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

78 } else {

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

80 }

81 QTest::qWait(1);

82 }

83 }

85 void scrollToBottom()

86 {

87 const qreal jump = 25;

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

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

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

91 } else {

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

93 }

94 QTest::qWait(1);

95 }

96 }

98 void verifyInitialTopPosition()

99 {

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

101 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

113 }

114

115private Q_SLOTS:

116

117 void initTestCase()

118 {

119 }

120

121 void init()

122 {

123 view = new QQuickView();

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

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

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

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

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

129#else

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

131#endif

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

133 QVERIFY(lvwph);

134 QVERIFY(model);

135 QVERIFY(otherDelegate);

136 view->show();

137 QTest::qWaitForWindowExposed(view);

138

139 verifyInitialTopPosition();

140 }

141

142 void cleanup()

143 {

144 delete view;

145 }

146

147 void testCreationDeletion()

148 {

149 // Nothing, init/cleanup already tests this

150 }

151

152 void testDrag1PixelUp()

153 {

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

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

156 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

168 }

169

170 void testHeaderDetachDragDown()

171 {

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QTest::qWait(100);

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

179 QTest::qWait(100);

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

181 QTest::qWait(100);

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

183 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

195

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

197

198 verifyInitialTopPosition();

199 }

200

201 void testDrag375PixelUp()

202 {

203 changeContentY(375);

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

205 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

218 }

219

220 void testDrag520PixelUp()

221 {

222 changeContentY(520);

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

224 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

235 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

242 }

243

244 void testDragHeaderUpThenShow()

245 {

246 changeContentY(120);

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

248 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

260

261 changeContentY(-30);

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

263 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

275 }

276

277 void testDragHeaderUpThenShowWithoutHidingTotally()

278 {

279 changeContentY(10);

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

281 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

293

294 changeContentY(-1);

295

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

297 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

309 }

310

311 void testPositionAtBeginningIndex0Visible()

312 {

313 changeContentY(375);

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

315 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

328

329 lvwph->positionAtBeginning();

330

331 verifyInitialTopPosition();

332 }

333

334 void testPositionAtBeginningIndex0NotVisible()

335 {

336 changeContentY(520);

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

338 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

343 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

350

351 lvwph->positionAtBeginning();

352

353 verifyInitialTopPosition();

354 }

355

356 void testIndex0GrowOnScreen()

357 {

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

359

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

361 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

372 }

373

374 void testIndex0GrowOffScreen()

375 {

376 changeContentY(375);

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

378 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

391

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

393

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

395 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

408

409 scrollToTop();

410

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

412 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

423

424 changeContentY(30);

425

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

427 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

438 }

439

440 void testIndex0GrowNotCreated()

441 {

442 changeContentY(520);

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

444 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

449 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

456

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

458

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

460 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

465 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

472

473 scrollToTop();

474

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

476 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

487 }

488

489 void testShowHideShowHeaderAtBottom()

490 {

491 scrollToBottom();

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

493 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

504

505 changeContentY(-30);

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

507 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

518

519 changeContentY(30);

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

521 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

532

533 changeContentY(-30);

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

535 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

546 }

547

548 void testChangeDelegateAtBottom()

549 {

550 scrollToBottom();

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

552 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

563

564 lvwph->setDelegate(otherDelegate);

565

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

567 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

581 }

582

583 void testSetEmptyHeaderAtTop()

584 {

585 lvwph->setHeader(nullptr);

586

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

588 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

599 }

600

601 void testSetEmptyHeaderAtBottom()

602 {

603 scrollToBottom();

604 lvwph->setHeader(nullptr);

605

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

607 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

617

618 scrollToTop();

619

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

621 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

632 }

633

634 void testSetEmptyHeaderWhenPartlyShownClipped()

635 {

636 scrollToBottom();

637 changeContentY(-30);

638 lvwph->setHeader(nullptr);

639

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

641 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

651 QTRY_VERIFY(lvwph->isAtYEnd());

652

653 scrollToTop();

654

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

656 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

667 }

668

669 void testSetEmptyHeaderWhenPartlyShownNotClipped()

670 {

671 changeContentY(30);

672 lvwph->setHeader(nullptr);

673

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

675 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

686 }

687

688 void testSetNullDelegate()

689 {

690 lvwph->setDelegate(nullptr);

691

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

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

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

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

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

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

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

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

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

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

702 QVERIFY(lvwph->isAtYBeginning());

703 QVERIFY(lvwph->isAtYEnd());

704 }

705

706 void testInsertItems()

707 {

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

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

710

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

712 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

725 }

726

727 void testInsertItemsOnNotShownPosition()

728 {

729 changeContentY(700);

730

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

732 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

744

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

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

747

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

749 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

761

762 scrollToTop();

763

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

765 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

778 }

779

780 void testInsertItemsAtEndOfViewport()

781 {

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

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

784

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

786 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

798 }

799

800 void testInsertItemsBeforeValidIndex()

801 {

802 changeContentY(520);

803

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

805 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

810 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

817

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

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

820

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

822 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

827 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

834 }

835

836 void testInsertItemsBeforeViewport()

837 {

838 changeContentY(375);

839

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

841 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

854

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

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

857

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

859 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

872

873 scrollToTop();

874

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

876 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

889 }

890

891 void testInsertItemsAtBottom()

892 {

893 scrollToBottom();

894

895 QVERIFY(lvwph->isAtYEnd());

896

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

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

899

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

901 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

915

916 scrollToBottom();

917

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

919 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

931 QVERIFY(lvwph->isAtYEnd());

932 }

933

934 void testInsertItemAtTop()

935 {

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

937

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

939 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

951 QVERIFY(lvwph->isAtYBeginning());

952 }

953

954 void testInsertItem10SmallItemsAtTopWhenAtBottom()

955 {

956 scrollToBottom();

957

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

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

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

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

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

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

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

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

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

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

968

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

970 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

981

982 changeContentY(-1700);

983

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

985 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1005 }

1006

1007 void testInsertToEmpty()

1008 {

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

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

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

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

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

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

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

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

1017

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

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

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

1021 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1024 }

1025

1026 void testRemoveItemsAtTop()

1027 {

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

1029

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

1031 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1042 QVERIFY(lvwph->isAtYBeginning());

1043 }

1044

1045 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1046 {

1047 scrollToBottom();

1048

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

1050

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

1052 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1063 }

1064

1065 void testRemoveLastItemsAtBottom()

1066 {

1067 scrollToBottom();

1068

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

1070

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

1072 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1083 }

1084

1085 void testRemoveItemOutOfViewport()

1086 {

1087 changeContentY(520);

1088

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

1090 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1095 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1102

1103

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

1105

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

1107 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1119 }

1120

1121 void testMoveFirstItems()

1122 {

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

1124

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

1126 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1138

1139 }

1140

1141 void testMoveFirstOutOfVisibleItems()

1142 {

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

1144

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

1146 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1157

1158 }

1159

1160 void testMoveFirstToLastAtBottom()

1161 {

1162 scrollToBottom();

1163

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

1165 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1176

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

1178

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

1180 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1193 }

1194

1195 void testChangeSizeVisibleItemNotOnViewport()

1196 {

1197 changeContentY(440);

1198

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

1200 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1213

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

1215

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

1217 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1230 }

1231

1232 void testShowHeaderCloseToTheTop()

1233 {

1234 changeContentY(375);

1235

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

1237 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1250

1251 lvwph->showHeader();

1252

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

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

1255 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1265 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1266 QCOMPARE(lvwph->contentY(), 325.);

1267 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;

1268

1269 scrollToTop();

1270

1271 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1272 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1273 verifyItem(0, 50., 150., false);

1274 verifyItem(1, 200., 200., false);

1275 verifyItem(2, 400., 350., false);

1276 verifyItem(3, 750., 350., true);

1277 QCOMPARE(lvwph->m_minYExtent, 50.);

1278 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1279 QCOMPARE(lvwph->m_clipItem->clip(), false);

1280 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1281 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1282 QCOMPARE(lvwph->contentY(), -50.);

1283 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1284 }

1285

1286 void testShowHeaderHalfShown()

1287 {

1288 changeContentY(20);

1289

1290 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1291 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1292 verifyItem(0, 30., 150., false);

1293 verifyItem(1, 180, 200., false);

1294 verifyItem(2, 380, 350., false);

1295 verifyItem(3, 730, 350., true);

1296 QCOMPARE(lvwph->m_minYExtent, 0.);

1297 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1298 QCOMPARE(lvwph->m_clipItem->clip(), false);

1299 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1300 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1301 QCOMPARE(lvwph->contentY(), 20.);

1302 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1303

1304 lvwph->showHeader();

1305

1306 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1307 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1308 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1309 verifyItem(0, -20., 150., false);

1310 verifyItem(1, 130, 200., false);

1311 verifyItem(2, 330, 350., false);

1312 verifyItem(3, 680, 350., true);

1313 QCOMPARE(lvwph->m_minYExtent, 20.);

1314 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1315 QCOMPARE(lvwph->m_clipItem->clip(), true);

1316 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1317 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1318 QCOMPARE(lvwph->contentY(), 0.);

1319 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1320

1321 scrollToTop();

1322

1323 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1324 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1325 verifyItem(0, 50., 150., false);

1326 verifyItem(1, 200., 200., false);

1327 verifyItem(2, 400., 350., false);

1328 verifyItem(3, 750, 350., true);

1329 QCOMPARE(lvwph->m_minYExtent, 20.);

1330 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1331 QCOMPARE(lvwph->m_clipItem->clip(), false);

1332 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1333 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1334 QCOMPARE(lvwph->contentY(), -20.);

1335 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1336 }

1337

1338 void testShowHeaderAtBottom()

1339 {

1340 scrollToBottom();

1341

1342 lvwph->showHeader();

1343

1344 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1345 QTRY_VERIFY (lvwph->isAtYEnd());

1346 }

1347

1348 void growWindow()

1349 {

1350 view->rootObject()->setHeight(850);

1351

1352 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1353 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1354 verifyItem(0, 50., 150., false);

1355 verifyItem(1, 200., 200., false);

1356 verifyItem(2, 400., 350., false);

1357 verifyItem(3, 750., 350., false);

1358 verifyItem(4, 1100., 350., true);

1359 QCOMPARE(lvwph->m_minYExtent, 0.);

1360 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1361 QCOMPARE(lvwph->m_clipItem->clip(), false);

1362 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1363 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1364 QCOMPARE(lvwph->contentY(), 0.);

1365 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1366 }

1367

1368 void growWindowAtBottom()

1369 {

1370 scrollToBottom();

1371

1372 view->rootObject()->setHeight(850);

1373

1374 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1375 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1376 verifyItem(0, -550., 350., true);

1377 verifyItem(1, -200., 350., false);

1378 verifyItem(2, 150, 350., false);

1379 verifyItem(3, 500, 350., false);

1380 QCOMPARE(lvwph->m_minYExtent, 350.);

1381 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1382 QCOMPARE(lvwph->m_clipItem->clip(), false);

1383 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1384 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1385 QCOMPARE(lvwph->contentY(), 950.);

1386 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1387 }

1388

1389 void testCrashShowHeaderWithNoHeader()

1390 {

1391 lvwph->setHeader(nullptr);

1392 lvwph->showHeader();

1393 }

1394

1395 void testCullOnBottomEdge()

1396 {

1397 changeContentY(200);

1398

1399 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1400 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1401 verifyItem(0, -150., 150., true);

1402 verifyItem(1, 0., 200., false);

1403 verifyItem(2, 200., 350., false);

1404 verifyItem(3, 550., 350., true);

1405 QCOMPARE(lvwph->m_minYExtent, 0.);

1406 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1407 QCOMPARE(lvwph->m_clipItem->clip(), false);

1408 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1409 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1410 QCOMPARE(lvwph->contentY(), 200.);

1411 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1412 }

1413

1414 void testMaximizeVisibleArea()

1415 {

1416 bool res = lvwph->maximizeVisibleArea(2);

1417 QVERIFY(res);

1418 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1419

1420 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1422 verifyItem(0, -158., 150., true);

1423 verifyItem(1, -8., 200., false);

1424 verifyItem(2, 192, 350., false);

1425 verifyItem(3, 542, 350., true);

1426 QCOMPARE(lvwph->m_minYExtent, 0.);

1427 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1428 QCOMPARE(lvwph->m_clipItem->clip(), false);

1429 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1430 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1431 QCOMPARE(lvwph->contentY(), 208.);

1432 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1433 }

1434

1435 void testMaximizeVisibleAreaVisibleItems()

1436 {

1437 bool res = lvwph->maximizeVisibleArea(0);

1438 QVERIFY(res);

1439 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1440

1441 verifyInitialTopPosition();

1442

1443 res = lvwph->maximizeVisibleArea(1);

1444 QVERIFY(res);

1445 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1446

1447 verifyInitialTopPosition();

1448 }

1449

1450 void testMaximizeVisibleAreaInvalidIndexes()

1451 {

1452 bool res = lvwph->maximizeVisibleArea(-1);

1453 QVERIFY(!res);

1454 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1455

1456 verifyInitialTopPosition();

1457

1458 res = lvwph->maximizeVisibleArea(1000);

1459 QVERIFY(!res);

1460 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1461

1462 verifyInitialTopPosition();

1463

1464 res = lvwph->maximizeVisibleArea(4);

1465 QVERIFY(!res);

1466 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1467

1468 verifyInitialTopPosition();

1469 }

1470

1471 void testMaximizeVisibleAreaBigElement()

1472 {

1473 model->setProperty(2, "size", 4000);

1474 bool res = lvwph->maximizeVisibleArea(2);

1475 QVERIFY(res);

1476 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1477

1478 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1479 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1480 verifyItem(0, -350., 150., true);

1481 verifyItem(1, -200., 200., true);

1482 verifyItem(2, 0, 4000., false);

1483 QCOMPARE(lvwph->m_minYExtent, 0.);

1484 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1485 QCOMPARE(lvwph->m_clipItem->clip(), false);

1486 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1487 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1488 QCOMPARE(lvwph->contentY(), 400.);

1489 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1490 }

1491

1492 void testMaximizeVisibleAreaScrollDown()

1493 {

1494 changeContentY(250);

1495 bool res = lvwph->maximizeVisibleArea(1);

1496 QVERIFY(res);

1497 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1498

1499 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1500 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1501 verifyItem(0, -150., 150., true);

1502 verifyItem(1, 0., 200., false);

1503 verifyItem(2, 200, 350., false);

1504 verifyItem(3, 550, 350., true);

1505 QCOMPARE(lvwph->m_minYExtent, 0.);

1506 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1507 QCOMPARE(lvwph->m_clipItem->clip(), false);

1508 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1509 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1510 QCOMPARE(lvwph->contentY(), 200.);

1511 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1512 }

1513

1514 void testMaximizeVisibleAreaScrollDownBigElement()

1515 {

1516 model->setProperty(1, "size", 1000);

1517 changeContentY(1150);

1518 bool res = lvwph->maximizeVisibleArea(1);

1519 QVERIFY(res);

1520 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1521

1522 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1523 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1524 verifyItem(0, -458., 1000., false);

1525 verifyItem(1, 542., 350., true);

1526 QCOMPARE(lvwph->m_minYExtent, 525.);

1527 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1528 QCOMPARE(lvwph->m_clipItem->clip(), false);

1529 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1530 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1531 QCOMPARE(lvwph->contentY(), 658.);

1532 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1533 }

1534

1535 void testMaximizeVisibleAreaBigElementInTheMiddle()

1536 {

1537 model->setProperty(1, "size", 1000);

1538 changeContentY(650);

1539

1540 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1541 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1542 verifyItem(0, -450., 1000., false);

1543 verifyItem(1, 550., 350., true);

1544 QCOMPARE(lvwph->m_minYExtent, 525.);

1545 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1546 QCOMPARE(lvwph->m_clipItem->clip(), false);

1547 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1548 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1549 QCOMPARE(lvwph->contentY(), 650.);

1550 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1551

1552 bool res = lvwph->maximizeVisibleArea(1);

1553 QVERIFY(res);

1554 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1555

1556 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1557 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1558 verifyItem(0, -450., 1000., false);

1559 verifyItem(1, 550., 350., true);

1560 QCOMPARE(lvwph->m_minYExtent, 525.);

1561 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1562 QCOMPARE(lvwph->m_clipItem->clip(), false);

1563 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1564 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1565 QCOMPARE(lvwph->contentY(), 650.);

1566 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1567 }

1568

1569 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1570 {

1571 changeContentY(430);

1572 changeContentY(-30);

1573

1574 bool res = lvwph->maximizeVisibleArea(1);

1575 QVERIFY(res);

1576 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1577

1578 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1579 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1580 verifyItem(0, -150., 150., true);

1581 verifyItem(1, 0., 200., false);

1582 verifyItem(2, 200, 350., false);

1583 verifyItem(3, 550, 350., true);

1584 QCOMPARE(lvwph->m_minYExtent, 0.);

1585 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1586 QCOMPARE(lvwph->m_clipItem->clip(), false);

1587 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1588 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1589 QCOMPARE(lvwph->contentY(), 200.);

1590 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1591 }

1592

1593 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1594 {

1595 testMaximizeVisibleAreaTopWithHalfPageHeader();

1596

1597 changeContentY(-60);

1598 changeContentY(15);

1599

1600 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1601 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1602 verifyItem(0, -140., 150., false);

1603 verifyItem(1, 10., 200., false);

1604 verifyItem(2, 210, 350., false);

1605 verifyItem(3, 560, 350., true);

1606 QCOMPARE(lvwph->m_minYExtent, 0.);

1607 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1608 QCOMPARE(lvwph->m_clipItem->clip(), true);

1609 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1610 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1611 QCOMPARE(lvwph->contentY(), 155.);

1612 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1613 }

1614

1615 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1616 {

1617 changeContentY(430);

1618 changeContentY(-30);

1619

1620 bool res = lvwph->maximizeVisibleArea(3);

1621 QVERIFY(res);

1622 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1623

1624 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1625 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1626 verifyItem(0, -358., 200., true);

1627 verifyItem(1, -158., 350., false);

1628 verifyItem(2, 192, 350., false);

1629 verifyItem(3, 542, 350., true);

1630 QCOMPARE(lvwph->m_minYExtent, 162.5);

1631 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1632 QCOMPARE(lvwph->m_clipItem->clip(), false);

1633 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1634 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1635 QCOMPARE(lvwph->contentY(), 558.);

1636 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1637 }

1638

1639 void testMaximizeVisibleAreaWithItemResize()

1640 {

1641 model->setProperty(0, "size", 1000);

1642

1643 bool res = lvwph->maximizeVisibleArea(1);

1644 QVERIFY(res);

1645 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1646

1647 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1648 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1649 verifyItem(0, -658., 1000., false);

1650 verifyItem(1, 342., 200., false);

1651 verifyItem(2, 542, 350., true);

1652 QCOMPARE(lvwph->m_minYExtent, 0.);

1653 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1654 QCOMPARE(lvwph->m_clipItem->clip(), false);

1655 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1656 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1657 QCOMPARE(lvwph->contentY(), 708.);

1658 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1659 }

1660

1661 void addingRemoveItemsShouldNotChangeContentY()

1662 {

1663 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1664 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1665 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1666

1667 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1668 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1669 verifyItem(0, 50., 150., false);

1670 QCOMPARE(lvwph->m_minYExtent, 0.);

1671 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1672 QCOMPARE(lvwph->m_clipItem->clip(), false);

1673 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1674 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1675 QCOMPARE(lvwph->contentY(), 0.);

1676 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1677

1678 QCOMPARE(spy.count(), 0);

1679 }

1680

1681 void testOvershootOnSameSize()

1682 {

1683 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1684 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1685 QCOMPARE(lvwph->m_minYExtent, 0.);

1686 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1687 QCOMPARE(lvwph->m_clipItem->clip(), false);

1688 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1689 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1690 QCOMPARE(lvwph->contentY(), 0.);

1691

1692 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1693 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1694 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1695 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1696 verifyItem(0, 50., 392., false);

1697 verifyItem(1, 442., 100., false);

1698

1699 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1700

1701 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1702 QTest::qWait(100);

1703 QTest::mouseMove(view, QPoint(0, 5));

1704 QTest::qWait(100);

1705 QTest::mouseMove(view, QPoint(0, 10));

1706 QTest::qWait(100);

1707 QTest::mouseMove(view, QPoint(0, 15));

1708 QTest::qWait(100);

1709 QTest::mouseMove(view, QPoint(0, 20));

1710 QTest::qWait(100);

1711 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1712 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1713 verifyItem(0, 55., 392., false);

1714 verifyItem(1, 447., 100., false);

1715 QCOMPARE(lvwph->m_minYExtent, 0.);

1716 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1717

1718 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1719 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1720 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1721 verifyItem(0, 50., 392., false);

1722 verifyItem(1, 442., 100., false);

1723 }

1724

1725 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1726 {

1727 model->setProperty(0, "size", 800);

1728 verifyItem(0, 50., 800., false);

1729

1730 lvwph->maximizeVisibleArea(0);

1731 QTRY_COMPARE(lvwph->contentY(), 50.);

1732

1733 changeContentY(10);

1734 QTRY_COMPARE(lvwph->contentY(), 60.);

1735

1736 lvwph->showHeader();

1737 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1738 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1739 QCOMPARE(lvwph->m_minYExtent, 50.);

1740 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1741 QCOMPARE(lvwph->m_clipItem->clip(), true);

1742 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1743 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1744 QCOMPARE(lvwph->contentY(), 10.);

1745 verifyItem(0, -60., 800., false);

1746 }

1747

1748 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1749 {

1750#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1751 QSKIP("This test is extremely unstable in 5.0.x");

1752#endif

1753 model->setProperty(0, "size", 800);

1754 verifyItem(0, 50., 800., false);

1755

1756 lvwph->maximizeVisibleArea(0);

1757 QTRY_COMPARE(lvwph->contentY(), 50.);

1758

1759 changeContentY(-10);

1760 QTRY_COMPARE(lvwph->contentY(), 40.);

1761

1762 lvwph->showHeader();

1763 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1764 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1765 QCOMPARE(lvwph->m_minYExtent, 40.);

1766 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1767 QCOMPARE(lvwph->m_clipItem->clip(), true);

1768 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1769 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1770 QCOMPARE(lvwph->contentY(), 0.);

1771 verifyItem(0, -40., 800., false);

1772 }

1773

1774 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1775 {

1776 model->setProperty(0, "size", 800);

1777 verifyItem(0, 50., 800., false);

1778

1779 lvwph->maximizeVisibleArea(0);

1780 QTRY_COMPARE(lvwph->contentY(), 50.);

1781

1782 changeContentY(-10);

1783 QTRY_COMPARE(lvwph->contentY(), 40.);

1784 changeContentY(10);

1785 QTRY_COMPARE(lvwph->contentY(), 50.);

1786

1787 lvwph->showHeader();

1788 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1789

1790 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1791 QCOMPARE(lvwph->m_minYExtent, 50.);

1792 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1793 QCOMPARE(lvwph->m_clipItem->clip(), true);

1794 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1795 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1796 QCOMPARE(lvwph->contentY(), 0.);

1797 verifyItem(0, -50., 800., false);

1798 }

1799

1800 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1801 {

1802 model->setProperty(0, "size", 800);

1803 verifyItem(0, 50., 800., false);

1804

1805 lvwph->maximizeVisibleArea(0);

1806 QTRY_COMPARE(lvwph->contentY(), 50.);

1807

1808 changeContentY(10);

1809 QTRY_COMPARE(lvwph->contentY(), 60.);

1810 changeContentY(-10);

1811 QTRY_COMPARE(lvwph->contentY(), 50.);

1812

1813 lvwph->showHeader();

1814 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1815 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1816 QCOMPARE(lvwph->m_minYExtent, 40.);

1817 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1818 QCOMPARE(lvwph->m_clipItem->clip(), true);

1819 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1820 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1821 QCOMPARE(lvwph->contentY(), 10.);

1822 verifyItem(0, -50., 800., false);

1823 }

1824

1825 void testMaximizeVisibleAreaAndShowHeader()

1826 {

1827 model->setProperty(0, "size", 800);

1828 verifyItem(0, 50., 800., false);

1829

1830 lvwph->maximizeVisibleArea(0);

1831 QTRY_COMPARE(lvwph->contentY(), 50.);

1832

1833 lvwph->showHeader();

1834 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1835 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1836 QCOMPARE(lvwph->m_minYExtent, 50.);

1837 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1838 QCOMPARE(lvwph->m_clipItem->clip(), true);

1839 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1840 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1841 QCOMPARE(lvwph->contentY(), 0.);

1842 verifyItem(0, -50., 800., false);

1843 }

1844

1845 void positionAtBeginningEmpty()

1846 {

1847 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1848 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1849

1850 lvwph->positionAtBeginning();

1851 }

1852

1853 void testHeaderPositionBug1240118()

1854 {

1855 scrollToBottom();

1856 lvwph->showHeader();

1857 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1858 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1859 model->setProperty(3, "size", 10);

1860 model->setProperty(4, "size", 10);

1861 model->setProperty(5, "size", 10);

1862 model->setProperty(6, "size", 10);

1863 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1864 }

1865

1866 void testResizeRemoveInsertBug1279434()

1867 {

1868 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1869 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1870

1871 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1872 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1873 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1874 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1875 verifyItem(0, 50., 125., false);

1876 verifyItem(1, 175., 100., false);

1877

1878 lvwph->setContentY(175);

1879

1880 model->setProperty(1, "size", 4);

1881 model->setProperty(0, "size", 4);

1882

1883 model->setProperty(0, "size", 6);

1884

1885 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1886 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1887 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1888

1889 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1890 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1891 }

1892

1893 void testResizeScrolledBigItem()

1894 {

1895 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1896 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1897

1898 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1899 changeContentY(8000);

1900

1901 // Pretend the list is busy requesting some other index

1902 lvwph->m_asyncRequestedIndex = 4;

1903

1904 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1905 // This resize makes the item go outside the viewport so its deleted

1906 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1907 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1908 // On the next polish the item will be readded

1909 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1910 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1911 }

1912

1913private:

1914 QQuickView *view;

1915 ListViewWithPageHeader *lvwph;

1916#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1917 QQuickListModel *model;

1918#else

1919 QQmlListModel *model;

1920#endif

1921 QQmlComponent *otherDelegate;

1922};

1923

1924QTEST_MAIN(ListViewWithPageHeaderTest)

1925

1926#include "listviewwithpageheadertest.moc"