tests/plugins/DashViews/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 64f9dc0 help sign in

unity8/tests/plugins/DashViews/listviewwithpageheadertest.cpp

1909 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#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

27#include <private/qquicklistmodel_p.h>

28#else

29#include <private/qqmllistmodel_p.h>

30#endif

31#include <private/qquickanimation_p.h>

32#include <private/qquickitem_p.h>

33#pragma GCC diagnostic pop

35class ListViewWithPageHeaderTest : public QObject

36{

37 Q_OBJECT

39private:

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

41 {

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

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

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

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

46 }

48 void changeContentY(qreal change)

49 {

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

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

52 const qreal jump = 25;

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

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

55 QTest::qWait(1);

56 }

57 } else {

58 const qreal jump = -25;

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

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

61 QTest::qWait(1);

62 }

63 }

64 lvwph->setContentY(dest);

65 QTest::qWait(1);

66 }

68 void scrollToTop()

69 {

70 const qreal jump = -25;

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

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

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

74 } else {

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

76 }

77 QTest::qWait(1);

78 }

79 }

81 void scrollToBottom()

82 {

83 const qreal jump = 25;

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

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

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

87 } else {

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

89 }

90 QTest::qWait(1);

91 }

92 }

94 void verifyInitialTopPosition()

95 {

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

97 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

109 }

110

111private Q_SLOTS:

112

113 void initTestCase()

114 {

115 }

116

117 void init()

118 {

119 view = new QQuickView();

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

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

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

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

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

125#else

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

127#endif

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

129 QVERIFY(lvwph);

130 QVERIFY(model);

131 QVERIFY(otherDelegate);

132 view->show();

133 QTest::qWaitForWindowExposed(view);

134

135 verifyInitialTopPosition();

136 }

137

138 void cleanup()

139 {

140 delete view;

141 }

142

143 void testCreationDeletion()

144 {

145 // Nothing, init/cleanup already tests this

146 }

147

148 void testDrag1PixelUp()

149 {

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

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

152 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

164 }

165

166 void testHeaderDetachDragDown()

167 {

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QTest::qWait(100);

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

179 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

191

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

193

194 verifyInitialTopPosition();

195 }

196

197 void testDrag375PixelUp()

198 {

199 changeContentY(375);

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

201 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

214 }

215

216 void testDrag520PixelUp()

217 {

218 changeContentY(520);

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

220 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

231 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

238 }

239

240 void testDragHeaderUpThenShow()

241 {

242 changeContentY(120);

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

244 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

256

257 changeContentY(-30);

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

259 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

271 }

272

273 void testDragHeaderUpThenShowWithoutHidingTotally()

274 {

275 changeContentY(10);

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

277 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

289

290 changeContentY(-1);

291

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

293 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

305 }

306

307 void testPositionAtBeginningIndex0Visible()

308 {

309 changeContentY(375);

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

311 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

324

325 lvwph->positionAtBeginning();

326

327 verifyInitialTopPosition();

328 }

329

330 void testPositionAtBeginningIndex0NotVisible()

331 {

332 changeContentY(520);

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

334 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

339 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

346

347 lvwph->positionAtBeginning();

348

349 verifyInitialTopPosition();

350 }

351

352 void testIndex0GrowOnScreen()

353 {

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

355

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

357 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

368 }

369

370 void testIndex0GrowOffScreen()

371 {

372 changeContentY(375);

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

374 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

387

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

389

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

391 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

404

405 scrollToTop();

406

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

408 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

419

420 changeContentY(30);

421

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

423 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

434 }

435

436 void testIndex0GrowNotCreated()

437 {

438 changeContentY(520);

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

440 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

445 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

452

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

454

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

456 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

461 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

468

469 scrollToTop();

470

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

472 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

483 }

484

485 void testShowHideShowHeaderAtBottom()

486 {

487 scrollToBottom();

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

489 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

500

501 changeContentY(-30);

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

503 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

514

515 changeContentY(30);

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

517 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

528

529 changeContentY(-30);

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

531 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

542 }

543

544 void testChangeDelegateAtBottom()

545 {

546 scrollToBottom();

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

548 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

559

560 lvwph->setDelegate(otherDelegate);

561

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

563 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

577 }

578

579 void testSetEmptyHeaderAtTop()

580 {

581 lvwph->setHeader(nullptr);

582

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

584 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

595 }

596

597 void testSetEmptyHeaderAtBottom()

598 {

599 scrollToBottom();

600 lvwph->setHeader(nullptr);

601

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

603 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

613

614 scrollToTop();

615

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

617 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

628 }

629

630 void testSetEmptyHeaderWhenPartlyShownClipped()

631 {

632 scrollToBottom();

633 changeContentY(-30);

634 lvwph->setHeader(nullptr);

635

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

637 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

647 QTRY_VERIFY(lvwph->isAtYEnd());

648

649 scrollToTop();

650

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

652 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

663 }

664

665 void testSetEmptyHeaderWhenPartlyShownNotClipped()

666 {

667 changeContentY(30);

668 lvwph->setHeader(nullptr);

669

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

671 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

682 }

683

684 void testSetNullDelegate()

685 {

686 lvwph->setDelegate(nullptr);

687

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

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

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

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

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

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

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

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

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

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

698 QVERIFY(lvwph->isAtYBeginning());

699 QVERIFY(lvwph->isAtYEnd());

700 }

701

702 void testInsertItems()

703 {

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

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

706

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

708 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

721 }

722

723 void testInsertItemsOnNotShownPosition()

724 {

725 changeContentY(700);

726

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

728 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

740

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

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

743

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

745 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

757

758 scrollToTop();

759

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

761 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

774 }

775

776 void testInsertItemsAtEndOfViewport()

777 {

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

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

780

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

782 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

794 }

795

796 void testInsertItemsBeforeValidIndex()

797 {

798 changeContentY(520);

799

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

801 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

806 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

813

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

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

816

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

818 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

823 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

830 }

831

832 void testInsertItemsBeforeViewport()

833 {

834 changeContentY(375);

835

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

837 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

850

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

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

853

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

855 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

868

869 scrollToTop();

870

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

872 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

885 }

886

887 void testInsertItemsAtBottom()

888 {

889 scrollToBottom();

890

891 QVERIFY(lvwph->isAtYEnd());

892

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

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

895

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

897 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

911

912 scrollToBottom();

913

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

915 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

927 QVERIFY(lvwph->isAtYEnd());

928 }

929

930 void testInsertItemAtTop()

931 {

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

933

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

935 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

947 QVERIFY(lvwph->isAtYBeginning());

948 }

949

950 void testInsertItem10SmallItemsAtTopWhenAtBottom()

951 {

952 scrollToBottom();

953

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

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

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

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

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

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

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

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

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

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

964

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

966 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

977

978 changeContentY(-1700);

979

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

981 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1001 }

1002

1003 void testInsertToEmpty()

1004 {

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

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

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

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

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

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

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

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

1013

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

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

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

1017 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1020 }

1021

1022 void testRemoveItemsAtTop()

1023 {

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

1025

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

1027 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1038 QVERIFY(lvwph->isAtYBeginning());

1039 }

1040

1041 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1042 {

1043 scrollToBottom();

1044

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

1046

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

1048 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1059 }

1060

1061 void testRemoveLastItemsAtBottom()

1062 {

1063 scrollToBottom();

1064

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

1066

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

1068 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1079 }

1080

1081 void testRemoveItemOutOfViewport()

1082 {

1083 changeContentY(520);

1084

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

1086 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1091 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1098

1099

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

1101

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

1103 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1115 }

1116

1117 void testMoveFirstItems()

1118 {

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

1120

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

1122 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1134

1135 }

1136

1137 void testMoveFirstOutOfVisibleItems()

1138 {

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

1140

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

1142 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1153

1154 }

1155

1156 void testMoveFirstToLastAtBottom()

1157 {

1158 scrollToBottom();

1159

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

1161 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1172

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

1174

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

1176 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1189 }

1190

1191 void testChangeSizeVisibleItemNotOnViewport()

1192 {

1193 changeContentY(440);

1194

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

1196 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1209

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

1211

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

1213 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1226 }

1227

1228 void testShowHeaderCloseToTheTop()

1229 {

1230 changeContentY(375);

1231

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

1233 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1246

1247 lvwph->showHeader();

1248

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

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

1251 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1263 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;

1264

1265 scrollToTop();

1266

1267 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1268 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1269 verifyItem(0, 50., 150., false);

1270 verifyItem(1, 200., 200., false);

1271 verifyItem(2, 400., 350., false);

1272 verifyItem(3, 750., 350., true);

1273 QCOMPARE(lvwph->m_minYExtent, 50.);

1274 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1275 QCOMPARE(lvwph->m_clipItem->clip(), false);

1276 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1277 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1278 QCOMPARE(lvwph->contentY(), -50.);

1279 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1280 }

1281

1282 void testShowHeaderHalfShown()

1283 {

1284 QSKIP("This test is extremely unstable in 5.0.x");

1285

1286 changeContentY(20);

1287

1288 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1289 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1290 verifyItem(0, 30., 150., false);

1291 verifyItem(1, 180, 200., false);

1292 verifyItem(2, 380, 350., false);

1293 verifyItem(3, 730, 350., true);

1294 QCOMPARE(lvwph->m_minYExtent, 0.);

1295 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1296 QCOMPARE(lvwph->m_clipItem->clip(), false);

1297 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1298 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1299 QCOMPARE(lvwph->contentY(), 20.);

1300 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1301

1302 lvwph->showHeader();

1303

1304 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1305 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1306 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1307 verifyItem(0, -20., 150., false);

1308 verifyItem(1, 130, 200., false);

1309 verifyItem(2, 330, 350., false);

1310 verifyItem(3, 680, 350., true);

1311 QCOMPARE(lvwph->m_minYExtent, 20.);

1312 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1313 QCOMPARE(lvwph->m_clipItem->clip(), true);

1314 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1315 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1316 QCOMPARE(lvwph->contentY(), 0.);

1317 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1318

1319 scrollToTop();

1320

1321 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1322 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1323 verifyItem(0, 50., 150., false);

1324 verifyItem(1, 200., 200., false);

1325 verifyItem(2, 400., 350., false);

1326 verifyItem(3, 750, 350., true);

1327 QCOMPARE(lvwph->m_minYExtent, 20.);

1328 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1329 QCOMPARE(lvwph->m_clipItem->clip(), false);

1330 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1331 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1332 QCOMPARE(lvwph->contentY(), -20.);

1333 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1334 }

1335

1336 void testShowHeaderAtBottom()

1337 {

1338 scrollToBottom();

1339

1340 lvwph->showHeader();

1341

1342 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1343 QTRY_VERIFY (lvwph->isAtYEnd());

1344 }

1345

1346 void growWindow()

1347 {

1348 view->rootObject()->setHeight(850);

1349

1350 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1351 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1352 verifyItem(0, 50., 150., false);

1353 verifyItem(1, 200., 200., false);

1354 verifyItem(2, 400., 350., false);

1355 verifyItem(3, 750., 350., false);

1356 verifyItem(4, 1100., 350., true);

1357 QCOMPARE(lvwph->m_minYExtent, 0.);

1358 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1359 QCOMPARE(lvwph->m_clipItem->clip(), false);

1360 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1361 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1362 QCOMPARE(lvwph->contentY(), 0.);

1363 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1364 }

1365

1366 void growWindowAtBottom()

1367 {

1368 scrollToBottom();

1369

1370 view->rootObject()->setHeight(850);

1371

1372 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1373 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1374 verifyItem(0, -550., 350., true);

1375 verifyItem(1, -200., 350., false);

1376 verifyItem(2, 150, 350., false);

1377 verifyItem(3, 500, 350., false);

1378 QCOMPARE(lvwph->m_minYExtent, 350.);

1379 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1380 QCOMPARE(lvwph->m_clipItem->clip(), false);

1381 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1382 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1383 QCOMPARE(lvwph->contentY(), 950.);

1384 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1385 }

1386

1387 void testCrashShowHeaderWithNoHeader()

1388 {

1389 lvwph->setHeader(nullptr);

1390 lvwph->showHeader();

1391 }

1392

1393 void testCullOnBottomEdge()

1394 {

1395 changeContentY(200);

1396

1397 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1398 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1399 verifyItem(0, -150., 150., true);

1400 verifyItem(1, 0., 200., false);

1401 verifyItem(2, 200., 350., false);

1402 verifyItem(3, 550., 350., true);

1403 QCOMPARE(lvwph->m_minYExtent, 0.);

1404 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1405 QCOMPARE(lvwph->m_clipItem->clip(), false);

1406 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1407 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1408 QCOMPARE(lvwph->contentY(), 200.);

1409 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1410 }

1411

1412 void testMaximizeVisibleArea()

1413 {

1414 bool res = lvwph->maximizeVisibleArea(2);

1415 QVERIFY(res);

1416 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1417

1418 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1419 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1420 verifyItem(0, -158., 150., true);

1421 verifyItem(1, -8., 200., false);

1422 verifyItem(2, 192, 350., false);

1423 verifyItem(3, 542, 350., true);

1424 QCOMPARE(lvwph->m_minYExtent, 0.);

1425 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1426 QCOMPARE(lvwph->m_clipItem->clip(), false);

1427 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1428 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1429 QCOMPARE(lvwph->contentY(), 208.);

1430 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1431 }

1432

1433 void testMaximizeVisibleAreaVisibleItems()

1434 {

1435 bool res = lvwph->maximizeVisibleArea(0);

1436 QVERIFY(res);

1437 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1438

1439 verifyInitialTopPosition();

1440

1441 res = lvwph->maximizeVisibleArea(1);

1442 QVERIFY(res);

1443 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1444

1445 verifyInitialTopPosition();

1446 }

1447

1448 void testMaximizeVisibleAreaInvalidIndexes()

1449 {

1450 bool res = lvwph->maximizeVisibleArea(-1);

1451 QVERIFY(!res);

1452 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1453

1454 verifyInitialTopPosition();

1455

1456 res = lvwph->maximizeVisibleArea(1000);

1457 QVERIFY(!res);

1458 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1459

1460 verifyInitialTopPosition();

1461

1462 res = lvwph->maximizeVisibleArea(4);

1463 QVERIFY(!res);

1464 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1465

1466 verifyInitialTopPosition();

1467 }

1468

1469 void testMaximizeVisibleAreaBigElement()

1470 {

1471 model->setProperty(2, "size", 4000);

1472 bool res = lvwph->maximizeVisibleArea(2);

1473 QVERIFY(res);

1474 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1475

1476 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1477 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1478 verifyItem(0, -350., 150., true);

1479 verifyItem(1, -200., 200., true);

1480 verifyItem(2, 0, 4000., false);

1481 QCOMPARE(lvwph->m_minYExtent, 0.);

1482 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1483 QCOMPARE(lvwph->m_clipItem->clip(), false);

1484 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1485 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1486 QCOMPARE(lvwph->contentY(), 400.);

1487 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1488 }

1489

1490 void testMaximizeVisibleAreaScrollDown()

1491 {

1492 changeContentY(250);

1493 bool res = lvwph->maximizeVisibleArea(1);

1494 QVERIFY(res);

1495 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1496

1497 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1498 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1499 verifyItem(0, -150., 150., true);

1500 verifyItem(1, 0., 200., false);

1501 verifyItem(2, 200, 350., false);

1502 verifyItem(3, 550, 350., true);

1503 QCOMPARE(lvwph->m_minYExtent, 0.);

1504 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1505 QCOMPARE(lvwph->m_clipItem->clip(), false);

1506 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1507 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1508 QCOMPARE(lvwph->contentY(), 200.);

1509 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1510 }

1511

1512 void testMaximizeVisibleAreaScrollDownBigElement()

1513 {

1514 model->setProperty(1, "size", 1000);

1515 changeContentY(1150);

1516 bool res = lvwph->maximizeVisibleArea(1);

1517 QVERIFY(res);

1518 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1519

1520 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1521 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1522 verifyItem(0, -458., 1000., false);

1523 verifyItem(1, 542., 350., true);

1524 QCOMPARE(lvwph->m_minYExtent, 525.);

1525 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1526 QCOMPARE(lvwph->m_clipItem->clip(), false);

1527 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1528 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1529 QCOMPARE(lvwph->contentY(), 658.);

1530 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1531 }

1532

1533 void testMaximizeVisibleAreaBigElementInTheMiddle()

1534 {

1535 model->setProperty(1, "size", 1000);

1536 changeContentY(650);

1537

1538 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1539 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1540 verifyItem(0, -450., 1000., false);

1541 verifyItem(1, 550., 350., true);

1542 QCOMPARE(lvwph->m_minYExtent, 525.);

1543 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1544 QCOMPARE(lvwph->m_clipItem->clip(), false);

1545 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1546 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1547 QCOMPARE(lvwph->contentY(), 650.);

1548 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1549

1550 bool res = lvwph->maximizeVisibleArea(1);

1551 QVERIFY(res);

1552 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1553

1554 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1555 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1556 verifyItem(0, -450., 1000., false);

1557 verifyItem(1, 550., 350., true);

1558 QCOMPARE(lvwph->m_minYExtent, 525.);

1559 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1560 QCOMPARE(lvwph->m_clipItem->clip(), false);

1561 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1562 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1563 QCOMPARE(lvwph->contentY(), 650.);

1564 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1565 }

1566

1567 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1568 {

1569 changeContentY(430);

1570 changeContentY(-30);

1571

1572 bool res = lvwph->maximizeVisibleArea(1);

1573 QVERIFY(res);

1574 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1575

1576 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1577 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1578 verifyItem(0, -150., 150., true);

1579 verifyItem(1, 0., 200., false);

1580 verifyItem(2, 200, 350., false);

1581 verifyItem(3, 550, 350., true);

1582 QCOMPARE(lvwph->m_minYExtent, 0.);

1583 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1584 QCOMPARE(lvwph->m_clipItem->clip(), false);

1585 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1586 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1587 QCOMPARE(lvwph->contentY(), 200.);

1588 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1589 }

1590

1591 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1592 {

1593 testMaximizeVisibleAreaTopWithHalfPageHeader();

1594

1595 changeContentY(-60);

1596 changeContentY(15);

1597

1598 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1599 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1600 verifyItem(0, -140., 150., false);

1601 verifyItem(1, 10., 200., false);

1602 verifyItem(2, 210, 350., false);

1603 verifyItem(3, 560, 350., true);

1604 QCOMPARE(lvwph->m_minYExtent, 0.);

1605 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1606 QCOMPARE(lvwph->m_clipItem->clip(), true);

1607 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1608 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1609 QCOMPARE(lvwph->contentY(), 155.);

1610 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1611 }

1612

1613 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1614 {

1615 changeContentY(430);

1616 changeContentY(-30);

1617

1618 bool res = lvwph->maximizeVisibleArea(3);

1619 QVERIFY(res);

1620 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1621

1622 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1623 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1624 verifyItem(0, -358., 200., true);

1625 verifyItem(1, -158., 350., false);

1626 verifyItem(2, 192, 350., false);

1627 verifyItem(3, 542, 350., true);

1628 QCOMPARE(lvwph->m_minYExtent, 162.5);

1629 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1630 QCOMPARE(lvwph->m_clipItem->clip(), false);

1631 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1632 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1633 QCOMPARE(lvwph->contentY(), 558.);

1634 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1635 }

1636

1637 void testMaximizeVisibleAreaWithItemResize()

1638 {

1639 model->setProperty(0, "size", 1000);

1640

1641 bool res = lvwph->maximizeVisibleArea(1);

1642 QVERIFY(res);

1643 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1644

1645 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1646 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1647 verifyItem(0, -658., 1000., false);

1648 verifyItem(1, 342., 200., false);

1649 verifyItem(2, 542, 350., true);

1650 QCOMPARE(lvwph->m_minYExtent, 0.);

1651 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1652 QCOMPARE(lvwph->m_clipItem->clip(), false);

1653 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1654 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1655 QCOMPARE(lvwph->contentY(), 708.);

1656 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1657 }

1658

1659 void addingRemoveItemsShouldNotChangeContentY()

1660 {

1661 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1662 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1663 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1664

1665 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1666 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1667 verifyItem(0, 50., 150., false);

1668 QCOMPARE(lvwph->m_minYExtent, 0.);

1669 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1670 QCOMPARE(lvwph->m_clipItem->clip(), false);

1671 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1672 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1673 QCOMPARE(lvwph->contentY(), 0.);

1674 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1675

1676 QCOMPARE(spy.count(), 0);

1677 }

1678

1679 void testOvershootOnSameSize()

1680 {

1681 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1682 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1683 QCOMPARE(lvwph->m_minYExtent, 0.);

1684 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1685 QCOMPARE(lvwph->m_clipItem->clip(), false);

1686 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1687 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1688 QCOMPARE(lvwph->contentY(), 0.);

1689

1690 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1691 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1692 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1693 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1694 verifyItem(0, 50., 392., false);

1695 verifyItem(1, 442., 100., false);

1696

1697 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1698

1699 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1700 QTest::qWait(100);

1701 QTest::mouseMove(view, QPoint(0, 5));

1702 QTest::qWait(100);

1703 QTest::mouseMove(view, QPoint(0, 10));

1704 QTest::qWait(100);

1705 QTest::mouseMove(view, QPoint(0, 15));

1706 QTest::qWait(100);

1707 QTest::mouseMove(view, QPoint(0, 20));

1708 QTest::qWait(100);

1709 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1710 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1711 verifyItem(0, 55., 392., false);

1712 verifyItem(1, 447., 100., false);

1713 QCOMPARE(lvwph->m_minYExtent, 0.);

1714 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1715

1716 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1717 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1718 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1719 verifyItem(0, 50., 392., false);

1720 verifyItem(1, 442., 100., false);

1721 }

1722

1723 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1724 {

1725 model->setProperty(0, "size", 800);

1726 verifyItem(0, 50., 800., false);

1727

1728 lvwph->maximizeVisibleArea(0);

1729 QTRY_COMPARE(lvwph->contentY(), 50.);

1730

1731 changeContentY(10);

1732 QTRY_COMPARE(lvwph->contentY(), 60.);

1733

1734 lvwph->showHeader();

1735 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1736 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1737 QCOMPARE(lvwph->m_minYExtent, 50.);

1738 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1739 QCOMPARE(lvwph->m_clipItem->clip(), true);

1740 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1741 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1742 QCOMPARE(lvwph->contentY(), 10.);

1743 verifyItem(0, -60., 800., false);

1744 }

1745

1746 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1747 {

1748#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1749 QSKIP("This test is extremely unstable in 5.0.x");

1750#endif

1751 model->setProperty(0, "size", 800);

1752 verifyItem(0, 50., 800., false);

1753

1754 lvwph->maximizeVisibleArea(0);

1755 QTRY_COMPARE(lvwph->contentY(), 50.);

1756

1757 changeContentY(-10);

1758 QTRY_COMPARE(lvwph->contentY(), 40.);

1759

1760 lvwph->showHeader();

1761 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1762 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1763 QCOMPARE(lvwph->m_minYExtent, 40.);

1764 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1765 QCOMPARE(lvwph->m_clipItem->clip(), true);

1766 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1767 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1768 QCOMPARE(lvwph->contentY(), 0.);

1769 verifyItem(0, -40., 800., false);

1770 }

1771

1772 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1773 {

1774 model->setProperty(0, "size", 800);

1775 verifyItem(0, 50., 800., false);

1776

1777 lvwph->maximizeVisibleArea(0);

1778 QTRY_COMPARE(lvwph->contentY(), 50.);

1779

1780 changeContentY(-10);

1781 QTRY_COMPARE(lvwph->contentY(), 40.);

1782 changeContentY(10);

1783 QTRY_COMPARE(lvwph->contentY(), 50.);

1784

1785 lvwph->showHeader();

1786 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1787

1788 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1789 QCOMPARE(lvwph->m_minYExtent, 50.);

1790 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1791 QCOMPARE(lvwph->m_clipItem->clip(), true);

1792 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1793 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1794 QCOMPARE(lvwph->contentY(), 0.);

1795 verifyItem(0, -50., 800., false);

1796 }

1797

1798 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1799 {

1800 model->setProperty(0, "size", 800);

1801 verifyItem(0, 50., 800., false);

1802

1803 lvwph->maximizeVisibleArea(0);

1804 QTRY_COMPARE(lvwph->contentY(), 50.);

1805

1806 changeContentY(10);

1807 QTRY_COMPARE(lvwph->contentY(), 60.);

1808 changeContentY(-10);

1809 QTRY_COMPARE(lvwph->contentY(), 50.);

1810

1811 lvwph->showHeader();

1812 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1813 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1814 QCOMPARE(lvwph->m_minYExtent, 40.);

1815 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1816 QCOMPARE(lvwph->m_clipItem->clip(), true);

1817 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1818 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1819 QCOMPARE(lvwph->contentY(), 10.);

1820 verifyItem(0, -50., 800., false);

1821 }

1822

1823 void testMaximizeVisibleAreaAndShowHeader()

1824 {

1825 model->setProperty(0, "size", 800);

1826 verifyItem(0, 50., 800., false);

1827

1828 lvwph->maximizeVisibleArea(0);

1829 QTRY_COMPARE(lvwph->contentY(), 50.);

1830

1831 lvwph->showHeader();

1832 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1833 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1834 QCOMPARE(lvwph->m_minYExtent, 50.);

1835 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1836 QCOMPARE(lvwph->m_clipItem->clip(), true);

1837 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1838 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1839 QCOMPARE(lvwph->contentY(), 0.);

1840 verifyItem(0, -50., 800., false);

1841 }

1842

1843 void positionAtBeginningEmpty()

1844 {

1845 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1846 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1847

1848 lvwph->positionAtBeginning();

1849 }

1850

1851 void testHeaderPositionBug1240118()

1852 {

1853 QSKIP("This test is unstable.");

1854 scrollToBottom();

1855 lvwph->showHeader();

1856 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1857 QTest::qWait(100); // Make sure stuff is stable

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#if (QT_VERSION > QT_VERSION_CHECK(5, 0, 3))

1864 QTRY_COMPARE(lvwph->m_minYExtent, 210.);

1865#endif

1866 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1867 }

1868

1869 void testResizeRemoveInsertBug1279434()

1870 {

1871 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1872 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1873

1874 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1875 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1876 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1877 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1878 verifyItem(0, 50., 125., false);

1879 verifyItem(1, 175., 100., false);

1880

1881 lvwph->setContentY(175);

1882

1883 model->setProperty(1, "size", 4);

1884 model->setProperty(0, "size", 4);

1885

1886 model->setProperty(0, "size", 6);

1887

1888 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1889 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1890 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1891

1892 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1893 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1894 }

1895

1896private:

1897 QQuickView *view;

1898 ListViewWithPageHeader *lvwph;

1899#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1900 QQuickListModel *model;

1901#else

1902 QQmlListModel *model;

1903#endif

1904 QQmlComponent *otherDelegate;

1905};

1906

1907QTEST_MAIN(ListViewWithPageHeaderTest)

1908

1909#include "listviewwithpageheadertest.moc"