tests/plugins/DashViews/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 4283f67 help sign in

unity8/tests/plugins/DashViews/listviewwithpageheadertest.cpp

1923 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

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 changeContentY(20);

1285

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

1287 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1299

1300 lvwph->showHeader();

1301

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

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

1304 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1316

1317 scrollToTop();

1318

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

1320 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

1328 QCOMPARE(lvwph->m_headerItem->y(), -20.);

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

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

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

1332 }

1333

1334 void testShowHeaderAtBottom()

1335 {

1336 scrollToBottom();

1337

1338 lvwph->showHeader();

1339

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

1341 QTRY_VERIFY (lvwph->isAtYEnd());

1342 }

1343

1344 void growWindow()

1345 {

1346 view->rootObject()->setHeight(850);

1347

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

1349 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

1353 verifyItem(3, 750., 350., false);

1354 verifyItem(4, 1100., 350., true);

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

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

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

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

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

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

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

1362 }

1363

1364 void growWindowAtBottom()

1365 {

1366 scrollToBottom();

1367

1368 view->rootObject()->setHeight(850);

1369

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

1371 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1372 verifyItem(0, -550., 350., true);

1373 verifyItem(1, -200., 350., false);

1374 verifyItem(2, 150, 350., false);

1375 verifyItem(3, 500, 350., false);

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

1377 QCOMPARE(lvwph->m_clipItem->y(), 950.);

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

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

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

1381 QCOMPARE(lvwph->contentY(), 950.);

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

1383 }

1384

1385 void testCrashShowHeaderWithNoHeader()

1386 {

1387 lvwph->setHeader(nullptr);

1388 lvwph->showHeader();

1389 }

1390

1391 void testCullOnBottomEdge()

1392 {

1393 changeContentY(200);

1394

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

1396 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1397 verifyItem(0, -150., 150., true);

1398 verifyItem(1, 0., 200., false);

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

1400 verifyItem(3, 550., 350., true);

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

1402 QCOMPARE(lvwph->m_clipItem->y(), 200.);

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

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

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

1406 QCOMPARE(lvwph->contentY(), 200.);

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

1408 }

1409

1410 void testMaximizeVisibleArea()

1411 {

1412 bool res = lvwph->maximizeVisibleArea(2);

1413 QVERIFY(res);

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

1415

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

1417 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1418 verifyItem(0, -158., 150., true);

1419 verifyItem(1, -8., 200., false);

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

1421 verifyItem(3, 542, 350., true);

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

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

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

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

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

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

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

1429 }

1430

1431 void testMaximizeVisibleAreaVisibleItems()

1432 {

1433 bool res = lvwph->maximizeVisibleArea(0);

1434 QVERIFY(res);

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

1436

1437 verifyInitialTopPosition();

1438

1439 res = lvwph->maximizeVisibleArea(1);

1440 QVERIFY(res);

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

1442

1443 verifyInitialTopPosition();

1444 }

1445

1446 void testMaximizeVisibleAreaInvalidIndexes()

1447 {

1448 bool res = lvwph->maximizeVisibleArea(-1);

1449 QVERIFY(!res);

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

1451

1452 verifyInitialTopPosition();

1453

1454 res = lvwph->maximizeVisibleArea(1000);

1455 QVERIFY(!res);

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

1457

1458 verifyInitialTopPosition();

1459

1460 res = lvwph->maximizeVisibleArea(4);

1461 QVERIFY(!res);

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

1463

1464 verifyInitialTopPosition();

1465 }

1466

1467 void testMaximizeVisibleAreaBigElement()

1468 {

1469 model->setProperty(2, "size", 4000);

1470 bool res = lvwph->maximizeVisibleArea(2);

1471 QVERIFY(res);

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

1473

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

1475 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1476 verifyItem(0, -350., 150., true);

1477 verifyItem(1, -200., 200., true);

1478 verifyItem(2, 0, 4000., false);

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

1480 QCOMPARE(lvwph->m_clipItem->y(), 400.);

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

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

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

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

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

1486 }

1487

1488 void testMaximizeVisibleAreaScrollDown()

1489 {

1490 changeContentY(250);

1491 bool res = lvwph->maximizeVisibleArea(1);

1492 QVERIFY(res);

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

1494

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

1496 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1497 verifyItem(0, -150., 150., true);

1498 verifyItem(1, 0., 200., false);

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

1500 verifyItem(3, 550, 350., true);

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

1502 QCOMPARE(lvwph->m_clipItem->y(), 200.);

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

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

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

1506 QCOMPARE(lvwph->contentY(), 200.);

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

1508 }

1509

1510 void testMaximizeVisibleAreaScrollDownBigElement()

1511 {

1512 model->setProperty(1, "size", 1000);

1513 changeContentY(1150);

1514 bool res = lvwph->maximizeVisibleArea(1);

1515 QVERIFY(res);

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

1517

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

1519 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1520 verifyItem(0, -458., 1000., false);

1521 verifyItem(1, 542., 350., true);

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

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

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

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

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

1527 QCOMPARE(lvwph->contentY(), 658.);

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

1529 }

1530

1531 void testMaximizeVisibleAreaBigElementInTheMiddle()

1532 {

1533 model->setProperty(1, "size", 1000);

1534 changeContentY(650);

1535

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

1537 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1538 verifyItem(0, -450., 1000., false);

1539 verifyItem(1, 550., 350., true);

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

1541 QCOMPARE(lvwph->m_clipItem->y(), 650.);

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

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

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

1545 QCOMPARE(lvwph->contentY(), 650.);

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

1547

1548 bool res = lvwph->maximizeVisibleArea(1);

1549 QVERIFY(res);

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

1551

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

1553 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1554 verifyItem(0, -450., 1000., false);

1555 verifyItem(1, 550., 350., true);

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

1557 QCOMPARE(lvwph->m_clipItem->y(), 650.);

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

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

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

1561 QCOMPARE(lvwph->contentY(), 650.);

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

1563 }

1564

1565 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1566 {

1567 changeContentY(430);

1568 changeContentY(-30);

1569

1570 bool res = lvwph->maximizeVisibleArea(1);

1571 QVERIFY(res);

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

1573

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

1575 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1576 verifyItem(0, -150., 150., true);

1577 verifyItem(1, 0., 200., false);

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

1579 verifyItem(3, 550, 350., true);

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

1581 QCOMPARE(lvwph->m_clipItem->y(), 200.);

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

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

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

1585 QCOMPARE(lvwph->contentY(), 200.);

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

1587 }

1588

1589 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1590 {

1591 testMaximizeVisibleAreaTopWithHalfPageHeader();

1592

1593 changeContentY(-60);

1594 changeContentY(15);

1595

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

1597 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1598 verifyItem(0, -140., 150., false);

1599 verifyItem(1, 10., 200., false);

1600 verifyItem(2, 210, 350., false);

1601 verifyItem(3, 560, 350., true);

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

1603 QCOMPARE(lvwph->m_clipItem->y(), 190.);

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

1605 QCOMPARE(lvwph->m_headerItem->y(), 140.);

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

1607 QCOMPARE(lvwph->contentY(), 155.);

1608 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1609 }

1610

1611 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1612 {

1613 changeContentY(430);

1614 changeContentY(-30);

1615

1616 bool res = lvwph->maximizeVisibleArea(3);

1617 QVERIFY(res);

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

1619

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

1621 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

1625 verifyItem(3, 542, 350., true);

1626 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1633 }

1634

1635 void testMaximizeVisibleAreaWithItemResize()

1636 {

1637 model->setProperty(0, "size", 1000);

1638

1639 bool res = lvwph->maximizeVisibleArea(1);

1640 QVERIFY(res);

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

1642

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

1644 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1645 verifyItem(0, -658., 1000., false);

1646 verifyItem(1, 342., 200., false);

1647 verifyItem(2, 542, 350., true);

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

1649 QCOMPARE(lvwph->m_clipItem->y(), 708.);

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

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

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

1653 QCOMPARE(lvwph->contentY(), 708.);

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

1655 }

1656

1657 void addingRemoveItemsShouldNotChangeContentY()

1658 {

1659 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1660 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

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

1662

1663 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1664 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

1673

1674 QCOMPARE(spy.count(), 0);

1675 }

1676

1677 void testOvershootOnSameSize()

1678 {

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

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

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

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

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

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

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

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

1687

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

1689 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

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

1691 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1692 verifyItem(0, 50., 392., false);

1693 verifyItem(1, 442., 100., false);

1694

1695 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1696

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

1698 QTest::qWait(100);

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

1700 QTest::qWait(100);

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

1702 QTest::qWait(100);

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

1704 QTest::qWait(100);

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

1706 QTest::qWait(100);

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

1708 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1709 verifyItem(0, 55., 392., false);

1710 verifyItem(1, 447., 100., false);

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

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

1713

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

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

1716 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1717 verifyItem(0, 50., 392., false);

1718 verifyItem(1, 442., 100., false);

1719 }

1720

1721 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1722 {

1723 model->setProperty(0, "size", 800);

1724 verifyItem(0, 50., 800., false);

1725

1726 lvwph->maximizeVisibleArea(0);

1727 QTRY_COMPARE(lvwph->contentY(), 50.);

1728

1729 changeContentY(10);

1730 QTRY_COMPARE(lvwph->contentY(), 60.);

1731

1732 lvwph->showHeader();

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

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

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

1736 QCOMPARE(lvwph->m_clipItem->y(), 60.);

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

1738 QCOMPARE(lvwph->m_headerItem->y(), 10.);

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

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

1741 verifyItem(0, -60., 800., false);

1742 }

1743

1744 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1745 {

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

1747 QSKIP("This test is extremely unstable in 5.0.x");

1748#endif

1749 model->setProperty(0, "size", 800);

1750 verifyItem(0, 50., 800., false);

1751

1752 lvwph->maximizeVisibleArea(0);

1753 QTRY_COMPARE(lvwph->contentY(), 50.);

1754

1755 changeContentY(-10);

1756 QTRY_COMPARE(lvwph->contentY(), 40.);

1757

1758 lvwph->showHeader();

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

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

1761 QCOMPARE(lvwph->m_minYExtent, 40.);

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

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

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

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

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

1767 verifyItem(0, -40., 800., false);

1768 }

1769

1770 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1771 {

1772 model->setProperty(0, "size", 800);

1773 verifyItem(0, 50., 800., false);

1774

1775 lvwph->maximizeVisibleArea(0);

1776 QTRY_COMPARE(lvwph->contentY(), 50.);

1777

1778 changeContentY(-10);

1779 QTRY_COMPARE(lvwph->contentY(), 40.);

1780 changeContentY(10);

1781 QTRY_COMPARE(lvwph->contentY(), 50.);

1782

1783 lvwph->showHeader();

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

1785

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

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

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

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

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

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

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

1793 verifyItem(0, -50., 800., false);

1794 }

1795

1796 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1797 {

1798 model->setProperty(0, "size", 800);

1799 verifyItem(0, 50., 800., false);

1800

1801 lvwph->maximizeVisibleArea(0);

1802 QTRY_COMPARE(lvwph->contentY(), 50.);

1803

1804 changeContentY(10);

1805 QTRY_COMPARE(lvwph->contentY(), 60.);

1806 changeContentY(-10);

1807 QTRY_COMPARE(lvwph->contentY(), 50.);

1808

1809 lvwph->showHeader();

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

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

1812 QCOMPARE(lvwph->m_minYExtent, 40.);

1813 QCOMPARE(lvwph->m_clipItem->y(), 60.);

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

1815 QCOMPARE(lvwph->m_headerItem->y(), 10.);

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

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

1818 verifyItem(0, -50., 800., false);

1819 }

1820

1821 void testMaximizeVisibleAreaAndShowHeader()

1822 {

1823 model->setProperty(0, "size", 800);

1824 verifyItem(0, 50., 800., false);

1825

1826 lvwph->maximizeVisibleArea(0);

1827 QTRY_COMPARE(lvwph->contentY(), 50.);

1828

1829 lvwph->showHeader();

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

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

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

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

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

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

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

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

1838 verifyItem(0, -50., 800., false);

1839 }

1840

1841 void positionAtBeginningEmpty()

1842 {

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

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

1845

1846 lvwph->positionAtBeginning();

1847 }

1848

1849 void testHeaderPositionBug1240118()

1850 {

1851 scrollToBottom();

1852 lvwph->showHeader();

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

1854 QTest::qWait(100); // Make sure stuff is stable

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

1856 model->setProperty(3, "size", 10);

1857 model->setProperty(4, "size", 10);

1858 model->setProperty(5, "size", 10);

1859 model->setProperty(6, "size", 10);

1860 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1861 }

1862

1863 void testResizeRemoveInsertBug1279434()

1864 {

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

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

1867

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

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

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

1871 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1874

1875 lvwph->setContentY(175);

1876

1877 model->setProperty(1, "size", 4);

1878 model->setProperty(0, "size", 4);

1879

1880 model->setProperty(0, "size", 6);

1881

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

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

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

1885

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

1887 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1888 }

1889

1890 void testResizeScrolledBigItem()

1891 {

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

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

1894

1895 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1896 changeContentY(8000);

1897

1898 // Pretend the list is busy requesting some other index

1899 lvwph->m_asyncRequestedIndex = 4;

1900

1901 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1902 // This resize makes the item go outside the viewport so its deleted

1903 QCOMPARE(lvwph->m_visibleItems.count(), 0);

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

1905 // On the next polish the item will be readded

1906 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1907 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1908 }

1909

1910private:

1911 QQuickView *view;

1912 ListViewWithPageHeader *lvwph;

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

1914 QQuickListModel *model;

1915#else

1916 QQmlListModel *model;

1917#endif

1918 QQmlComponent *otherDelegate;

1919};

1920

1921QTEST_MAIN(ListViewWithPageHeaderTest)

1922

1923#include "listviewwithpageheadertest.moc"