tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on ed593dc help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

1989 lines 76 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QSignalSpy>

23#include <QtTestGui>

24#pragma GCC diagnostic push

25#pragma GCC diagnostic ignored "-pedantic"

26#include <private/qqmllistmodel_p.h>

27#include <private/qquickanimation_p.h>

28#include <private/qquickitem_p.h>

29#pragma GCC diagnostic pop

31#include <limits>

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

34// particullary making sure that lost items are culled

35// and then removed in the next updatePolish cycle

37class ListViewWithPageHeaderTest : public QObject

38{

39 Q_OBJECT

41private:

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

43 {

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

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

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

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

48 }

50 void changeContentY(qreal change)

51 {

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

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

54 const qreal jump = 25;

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

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

57 QTest::qWait(1);

58 }

59 } else {

60 const qreal jump = -25;

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

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

63 QTest::qWait(1);

64 }

65 }

66 lvwph->setContentY(dest);

67 QTest::qWait(1);

68 }

70 void scrollToTop()

71 {

72 const qreal jump = -25;

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

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

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

76 } else {

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

78 }

79 QTest::qWait(1);

80 }

81 }

83 void scrollToBottom()

84 {

85 const qreal jump = 25;

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

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

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

89 } else {

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

91 }

92 QTest::qWait(1);

93 }

94 }

96 void verifyInitialTopPosition()

97 {

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

99 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

111 }

112

113private Q_SLOTS:

114

115 void initTestCase()

116 {

117 }

118

119 void init()

120 {

121 view = new QQuickView();

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

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

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

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

126 QVERIFY(lvwph);

127 QVERIFY(model);

128 QVERIFY(otherDelegate);

129 view->show();

130 QTest::qWaitForWindowExposed(view);

131

132 verifyInitialTopPosition();

133 }

134

135 void cleanup()

136 {

137 delete view;

138 }

139

140 void testCreationDeletion()

141 {

142 // Nothing, init/cleanup already tests this

143 }

144

145 void testDrag1PixelUp()

146 {

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

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

149 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

161 }

162

163 void testHeaderDetachDragDown()

164 {

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

166 QTest::qWait(100);

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

168 QTest::qWait(100);

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

170 QTest::qWait(100);

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

172 QTest::qWait(100);

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

174 QTest::qWait(100);

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

176 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

188

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

190

191 verifyInitialTopPosition();

192 }

193

194 void testDrag375PixelUp()

195 {

196 changeContentY(375);

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

198 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

211 }

212

213 void testDrag520PixelUp()

214 {

215 changeContentY(520);

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

217 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

228 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

235 }

236

237 void testDragHeaderUpThenShow()

238 {

239 changeContentY(120);

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

241 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

253

254 changeContentY(-30);

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

256 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

268 }

269

270 void testDragHeaderUpThenShowWithoutHidingTotally()

271 {

272 changeContentY(10);

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

274 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

286

287 changeContentY(-1);

288

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

290 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

302 }

303

304 void testPositionAtBeginningIndex0Visible()

305 {

306 changeContentY(375);

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

308 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

321

322 lvwph->positionAtBeginning();

323

324 verifyInitialTopPosition();

325 }

326

327 void testPositionAtBeginningIndex0NotVisible()

328 {

329 changeContentY(520);

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

331 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

336 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

343

344 lvwph->positionAtBeginning();

345

346 verifyInitialTopPosition();

347 }

348

349 void testIndex0GrowOnScreen()

350 {

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

352

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

354 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

365 }

366

367 void testIndex0GrowOffScreen()

368 {

369 changeContentY(375);

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

371 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

384

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

386

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

388 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

401

402 scrollToTop();

403

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

405 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

416

417 changeContentY(30);

418

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

420 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

431 }

432

433 void testIndex0GrowNotCreated()

434 {

435 changeContentY(520);

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

437 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

442 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

449

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

451

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

453 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

458 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

465

466 scrollToTop();

467

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

469 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

480 }

481

482 void testShowHideShowHeaderAtBottom()

483 {

484 scrollToBottom();

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

486 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

497

498 changeContentY(-30);

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

500 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

511

512 changeContentY(30);

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

514 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

525

526 changeContentY(-30);

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

528 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

539 }

540

541 void testChangeDelegateAtBottom()

542 {

543 scrollToBottom();

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

545 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

556

557 lvwph->setDelegate(otherDelegate);

558

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

560 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

574 }

575

576 void testSetEmptyHeaderAtTop()

577 {

578 lvwph->setHeader(nullptr);

579

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

581 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

592 }

593

594 void testSetEmptyHeaderAtBottom()

595 {

596 scrollToBottom();

597 lvwph->setHeader(nullptr);

598

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

600 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

610

611 scrollToTop();

612

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

614 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

625 }

626

627 void testSetEmptyHeaderWhenPartlyShownClipped()

628 {

629 scrollToBottom();

630 changeContentY(-30);

631 lvwph->setHeader(nullptr);

632

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

634 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

644 QTRY_VERIFY(lvwph->isAtYEnd());

645

646 scrollToTop();

647

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

649 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

660 }

661

662 void testSetEmptyHeaderWhenPartlyShownNotClipped()

663 {

664 changeContentY(30);

665 lvwph->setHeader(nullptr);

666

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

668 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

679 }

680

681 void testSetNullDelegate()

682 {

683 lvwph->setDelegate(nullptr);

684

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

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

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

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

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

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

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

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

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

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

695 QVERIFY(lvwph->isAtYBeginning());

696 QVERIFY(lvwph->isAtYEnd());

697 }

698

699 void testInsertItems()

700 {

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

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

703

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

705 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

718 }

719

720 void testInsertItemsOnNotShownPosition()

721 {

722 changeContentY(700);

723

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

725 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

737

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

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

740

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

742 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

754

755 scrollToTop();

756

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

758 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

771 }

772

773 void testInsertItemsAtEndOfViewport()

774 {

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

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

777

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

779 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

791 }

792

793 void testInsertItemsBeforeValidIndex()

794 {

795 changeContentY(520);

796

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

798 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

803 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

810

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

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

813

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

815 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

820 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

827 }

828

829 void testInsertItemsBeforeViewport()

830 {

831 changeContentY(375);

832

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

834 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

847

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

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

850

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

852 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

865

866 scrollToTop();

867

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

869 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

882 }

883

884 void testInsertItemsAtBottom()

885 {

886 scrollToBottom();

887

888 QVERIFY(lvwph->isAtYEnd());

889

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

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

892

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

894 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

908

909 scrollToBottom();

910

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

912 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

924 QVERIFY(lvwph->isAtYEnd());

925 }

926

927 void testInsertItemAtTop()

928 {

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

930

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

932 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

944 QVERIFY(lvwph->isAtYBeginning());

945 }

946

947 void testInsertItem10SmallItemsAtTopWhenAtBottom()

948 {

949 scrollToBottom();

950

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

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

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

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

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

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

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

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

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

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

961

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

963 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

974

975 changeContentY(-800);

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

977 changeContentY(-400);

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

979 changeContentY(-200);

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

981 changeContentY(-300);

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

983

984 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1004 }

1005

1006 void testInsertToEmpty()

1007 {

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

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

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

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

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

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

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

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

1016

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

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

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

1020 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1023 }

1024

1025 void testRemoveItemsAtTop()

1026 {

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

1028

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

1030 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1041 QVERIFY(lvwph->isAtYBeginning());

1042 }

1043

1044 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1045 {

1046 scrollToBottom();

1047

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

1049

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

1051 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1062 }

1063

1064 void testRemoveLastItemsAtBottom()

1065 {

1066 scrollToBottom();

1067

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

1069

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

1071 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1082 }

1083

1084 void testRemoveItemOutOfViewport()

1085 {

1086 changeContentY(520);

1087

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

1089 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1094 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1101

1102

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

1104

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

1106 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1118 }

1119

1120 void testMoveFirstItems()

1121 {

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

1123

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

1125 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1137

1138 }

1139

1140 void testMoveFirstOutOfVisibleItems()

1141 {

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

1143

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

1145 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1156

1157 }

1158

1159 void testMoveFirstToLastAtBottom()

1160 {

1161 scrollToBottom();

1162

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

1164 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1175

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

1177

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

1179 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1192 }

1193

1194 void testChangeSizeVisibleItemNotOnViewport()

1195 {

1196 changeContentY(440);

1197

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

1199 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1212

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

1214

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

1216 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1229 }

1230

1231 void testShowHeaderCloseToTheTop()

1232 {

1233 changeContentY(375);

1234

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

1236 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1249

1250 lvwph->showHeader();

1251

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

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

1254 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

1258 verifyItem(3, 325, 350., false);

1259 verifyItem(4, 675, 350., true);

1260 QCOMPARE(lvwph->m_minYExtent, 50.);

1261 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1262 QCOMPARE(lvwph->m_clipItem->clip(), true);

1263 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1264 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1265 QCOMPARE(lvwph->contentY(), 325.);

1266 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;

1267

1268 scrollToTop();

1269

1270 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1271 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1272 verifyItem(0, 50., 150., false);

1273 verifyItem(1, 200., 200., false);

1274 verifyItem(2, 400., 350., false);

1275 verifyItem(3, 750., 350., true);

1276 QCOMPARE(lvwph->m_minYExtent, 50.);

1277 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1278 QCOMPARE(lvwph->m_clipItem->clip(), false);

1279 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1280 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1281 QCOMPARE(lvwph->contentY(), -50.);

1282 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1283 }

1284

1285 void testShowHeaderHalfShown()

1286 {

1287 changeContentY(20);

1288

1289 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1290 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1291 verifyItem(0, 30., 150., false);

1292 verifyItem(1, 180, 200., false);

1293 verifyItem(2, 380, 350., false);

1294 verifyItem(3, 730, 350., true);

1295 QCOMPARE(lvwph->m_minYExtent, 0.);

1296 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1297 QCOMPARE(lvwph->m_clipItem->clip(), false);

1298 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1299 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1300 QCOMPARE(lvwph->contentY(), 20.);

1301 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1302

1303 lvwph->showHeader();

1304

1305 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1306 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1307 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1308 verifyItem(0, -20., 150., false);

1309 verifyItem(1, 130, 200., false);

1310 verifyItem(2, 330, 350., false);

1311 verifyItem(3, 680, 350., true);

1312 QCOMPARE(lvwph->m_minYExtent, 20.);

1313 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1314 QCOMPARE(lvwph->m_clipItem->clip(), true);

1315 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1316 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1317 QCOMPARE(lvwph->contentY(), 0.);

1318 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1319

1320 scrollToTop();

1321

1322 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1323 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1324 verifyItem(0, 50., 150., false);

1325 verifyItem(1, 200., 200., false);

1326 verifyItem(2, 400., 350., false);

1327 verifyItem(3, 750, 350., true);

1328 QCOMPARE(lvwph->m_minYExtent, 20.);

1329 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1330 QCOMPARE(lvwph->m_clipItem->clip(), false);

1331 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1332 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1333 QCOMPARE(lvwph->contentY(), -20.);

1334 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1335 }

1336

1337 void testShowHeaderAtBottom()

1338 {

1339 scrollToBottom();

1340

1341 lvwph->showHeader();

1342

1343 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1344 QTRY_VERIFY (lvwph->isAtYEnd());

1345 }

1346

1347 void growWindow()

1348 {

1349 view->rootObject()->setHeight(850);

1350

1351 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1352 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1353 verifyItem(0, 50., 150., false);

1354 verifyItem(1, 200., 200., false);

1355 verifyItem(2, 400., 350., false);

1356 verifyItem(3, 750., 350., false);

1357 verifyItem(4, 1100., 350., true);

1358 QCOMPARE(lvwph->m_minYExtent, 0.);

1359 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1360 QCOMPARE(lvwph->m_clipItem->clip(), false);

1361 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1362 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1363 QCOMPARE(lvwph->contentY(), 0.);

1364 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1365 }

1366

1367 void growWindowAtBottom()

1368 {

1369 scrollToBottom();

1370

1371 view->rootObject()->setHeight(850);

1372

1373 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1374 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1375 verifyItem(0, -550., 350., true);

1376 verifyItem(1, -200., 350., false);

1377 verifyItem(2, 150, 350., false);

1378 verifyItem(3, 500, 350., false);

1379 QCOMPARE(lvwph->m_minYExtent, 350.);

1380 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1381 QCOMPARE(lvwph->m_clipItem->clip(), false);

1382 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1383 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1384 QCOMPARE(lvwph->contentY(), 950.);

1385 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1386 }

1387

1388 void testCrashShowHeaderWithNoHeader()

1389 {

1390 lvwph->setHeader(nullptr);

1391 lvwph->showHeader();

1392 }

1393

1394 void testCullOnBottomEdge()

1395 {

1396 changeContentY(200);

1397

1398 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1399 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1400 verifyItem(0, -150., 150., true);

1401 verifyItem(1, 0., 200., false);

1402 verifyItem(2, 200., 350., false);

1403 verifyItem(3, 550., 350., true);

1404 QCOMPARE(lvwph->m_minYExtent, 0.);

1405 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1406 QCOMPARE(lvwph->m_clipItem->clip(), false);

1407 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1408 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1409 QCOMPARE(lvwph->contentY(), 200.);

1410 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1411 }

1412

1413 void testMaximizeVisibleArea()

1414 {

1415 bool res = lvwph->maximizeVisibleArea(2);

1416 QVERIFY(res);

1417 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1418

1419 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1420 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1421 verifyItem(0, -158., 150., true);

1422 verifyItem(1, -8., 200., false);

1423 verifyItem(2, 192, 350., false);

1424 verifyItem(3, 542, 350., true);

1425 QCOMPARE(lvwph->m_minYExtent, 0.);

1426 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1427 QCOMPARE(lvwph->m_clipItem->clip(), false);

1428 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1429 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1430 QCOMPARE(lvwph->contentY(), 208.);

1431 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1432 }

1433

1434 void testMaximizeVisibleAreaVisibleItems()

1435 {

1436 bool res = lvwph->maximizeVisibleArea(0);

1437 QVERIFY(res);

1438 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1439

1440 verifyInitialTopPosition();

1441

1442 res = lvwph->maximizeVisibleArea(1);

1443 QVERIFY(res);

1444 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1445

1446 verifyInitialTopPosition();

1447 }

1448

1449 void testMaximizeVisibleAreaInvalidIndexes()

1450 {

1451 bool res = lvwph->maximizeVisibleArea(-1);

1452 QVERIFY(!res);

1453 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1454

1455 verifyInitialTopPosition();

1456

1457 res = lvwph->maximizeVisibleArea(1000);

1458 QVERIFY(!res);

1459 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1460

1461 verifyInitialTopPosition();

1462

1463 res = lvwph->maximizeVisibleArea(4);

1464 QVERIFY(!res);

1465 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1466

1467 verifyInitialTopPosition();

1468 }

1469

1470 void testMaximizeVisibleAreaBigElement()

1471 {

1472 model->setProperty(2, "size", 4000);

1473 bool res = lvwph->maximizeVisibleArea(2);

1474 QVERIFY(res);

1475 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1476

1477 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1478 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1479 verifyItem(0, -350., 150., true);

1480 verifyItem(1, -200., 200., true);

1481 verifyItem(2, 0, 4000., false);

1482 QCOMPARE(lvwph->m_minYExtent, 0.);

1483 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1484 QCOMPARE(lvwph->m_clipItem->clip(), false);

1485 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1486 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1487 QCOMPARE(lvwph->contentY(), 400.);

1488 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1489 }

1490

1491 void testMaximizeVisibleAreaScrollDown()

1492 {

1493 changeContentY(250);

1494 bool res = lvwph->maximizeVisibleArea(1);

1495 QVERIFY(res);

1496 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1497

1498 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1499 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1500 verifyItem(0, -150., 150., true);

1501 verifyItem(1, 0., 200., false);

1502 verifyItem(2, 200, 350., false);

1503 verifyItem(3, 550, 350., true);

1504 QCOMPARE(lvwph->m_minYExtent, 0.);

1505 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1506 QCOMPARE(lvwph->m_clipItem->clip(), false);

1507 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1508 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1509 QCOMPARE(lvwph->contentY(), 200.);

1510 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1511 }

1512

1513 void testMaximizeVisibleAreaScrollDownBigElement()

1514 {

1515 model->setProperty(1, "size", 1000);

1516 changeContentY(1150);

1517 bool res = lvwph->maximizeVisibleArea(1);

1518 QVERIFY(res);

1519 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1520

1521 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1522 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1523 verifyItem(0, -458., 1000., false);

1524 verifyItem(1, 542., 350., true);

1525 QCOMPARE(lvwph->m_minYExtent, 525.);

1526 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1527 QCOMPARE(lvwph->m_clipItem->clip(), false);

1528 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1529 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1530 QCOMPARE(lvwph->contentY(), 658.);

1531 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1532 }

1533

1534 void testMaximizeVisibleAreaBigElementInTheMiddle()

1535 {

1536 model->setProperty(1, "size", 1000);

1537 changeContentY(650);

1538

1539 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1540 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1541 verifyItem(0, -450., 1000., false);

1542 verifyItem(1, 550., 350., true);

1543 QCOMPARE(lvwph->m_minYExtent, 525.);

1544 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1545 QCOMPARE(lvwph->m_clipItem->clip(), false);

1546 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1547 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1548 QCOMPARE(lvwph->contentY(), 650.);

1549 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1550

1551 bool res = lvwph->maximizeVisibleArea(1);

1552 QVERIFY(res);

1553 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1554

1555 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1556 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1557 verifyItem(0, -450., 1000., false);

1558 verifyItem(1, 550., 350., true);

1559 QCOMPARE(lvwph->m_minYExtent, 525.);

1560 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1561 QCOMPARE(lvwph->m_clipItem->clip(), false);

1562 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1563 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1564 QCOMPARE(lvwph->contentY(), 650.);

1565 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1566 }

1567

1568 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1569 {

1570 changeContentY(430);

1571 changeContentY(-30);

1572

1573 bool res = lvwph->maximizeVisibleArea(1);

1574 QVERIFY(res);

1575 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1576

1577 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1578 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1579 verifyItem(0, -150., 150., true);

1580 verifyItem(1, 0., 200., false);

1581 verifyItem(2, 200, 350., false);

1582 verifyItem(3, 550, 350., true);

1583 QCOMPARE(lvwph->m_minYExtent, 0.);

1584 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1585 QCOMPARE(lvwph->m_clipItem->clip(), false);

1586 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1587 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1588 QCOMPARE(lvwph->contentY(), 200.);

1589 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1590 }

1591

1592 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1593 {

1594 testMaximizeVisibleAreaTopWithHalfPageHeader();

1595

1596 changeContentY(-60);

1597 changeContentY(15);

1598

1599 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1600 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1601 verifyItem(0, -140., 150., false);

1602 verifyItem(1, 10., 200., false);

1603 verifyItem(2, 210, 350., false);

1604 verifyItem(3, 560, 350., true);

1605 QCOMPARE(lvwph->m_minYExtent, 0.);

1606 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1607 QCOMPARE(lvwph->m_clipItem->clip(), true);

1608 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1609 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1610 QCOMPARE(lvwph->contentY(), 155.);

1611 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1612 }

1613

1614 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1615 {

1616 changeContentY(430);

1617 changeContentY(-30);

1618

1619 bool res = lvwph->maximizeVisibleArea(3);

1620 QVERIFY(res);

1621 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1622

1623 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1624 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1625 verifyItem(0, -358., 200., true);

1626 verifyItem(1, -158., 350., false);

1627 verifyItem(2, 192, 350., false);

1628 verifyItem(3, 542, 350., true);

1629 QCOMPARE(lvwph->m_minYExtent, 162.5);

1630 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1631 QCOMPARE(lvwph->m_clipItem->clip(), false);

1632 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1633 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1634 QCOMPARE(lvwph->contentY(), 558.);

1635 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1636 }

1637

1638 void testMaximizeVisibleAreaWithItemResize()

1639 {

1640 model->setProperty(0, "size", 1000);

1641

1642 bool res = lvwph->maximizeVisibleArea(1);

1643 QVERIFY(res);

1644 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1645

1646 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1647 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1648 verifyItem(0, -658., 1000., false);

1649 verifyItem(1, 342., 200., false);

1650 verifyItem(2, 542, 350., true);

1651 QCOMPARE(lvwph->m_minYExtent, 0.);

1652 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1653 QCOMPARE(lvwph->m_clipItem->clip(), false);

1654 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1655 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1656 QCOMPARE(lvwph->contentY(), 708.);

1657 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1658 }

1659

1660 void addingRemoveItemsShouldNotChangeContentY()

1661 {

1662 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

1663 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1664 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1665

1666 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1667 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1668 verifyItem(0, 50., 150., false);

1669 QCOMPARE(lvwph->m_minYExtent, 0.);

1670 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1671 QCOMPARE(lvwph->m_clipItem->clip(), false);

1672 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1673 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1674 QCOMPARE(lvwph->contentY(), 0.);

1675 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1676

1677 QCOMPARE(spy.count(), 0);

1678 }

1679

1680 void testOvershootOnSameSize()

1681 {

1682 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1683 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1684 QCOMPARE(lvwph->m_minYExtent, 0.);

1685 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1686 QCOMPARE(lvwph->m_clipItem->clip(), false);

1687 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1688 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1689 QCOMPARE(lvwph->contentY(), 0.);

1690

1691 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1692 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1693 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1694 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1695 verifyItem(0, 50., 392., false);

1696 verifyItem(1, 442., 100., false);

1697

1698 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1699

1700 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1701 QTest::qWait(100);

1702 QTest::mouseMove(view, QPoint(0, 5));

1703 QTest::qWait(100);

1704 QTest::mouseMove(view, QPoint(0, 10));

1705 QTest::qWait(100);

1706 QTest::mouseMove(view, QPoint(0, 15));

1707 QTest::qWait(100);

1708 QTest::mouseMove(view, QPoint(0, 20));

1709 QTest::qWait(100);

1710 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1711 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1712 verifyItem(0, 55., 392., false);

1713 verifyItem(1, 447., 100., false);

1714 QCOMPARE(lvwph->m_minYExtent, 0.);

1715 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1716

1717 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1718 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1719 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1720 verifyItem(0, 50., 392., false);

1721 verifyItem(1, 442., 100., false);

1722 }

1723

1724 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1725 {

1726 model->setProperty(0, "size", 800);

1727 verifyItem(0, 50., 800., false);

1728

1729 lvwph->maximizeVisibleArea(0);

1730 QTRY_COMPARE(lvwph->contentY(), 50.);

1731

1732 changeContentY(10);

1733 QTRY_COMPARE(lvwph->contentY(), 60.);

1734

1735 lvwph->showHeader();

1736 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1737 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1738 QCOMPARE(lvwph->m_minYExtent, 50.);

1739 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1740 QCOMPARE(lvwph->m_clipItem->clip(), true);

1741 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1742 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1743 QCOMPARE(lvwph->contentY(), 10.);

1744 verifyItem(0, -60., 800., false);

1745 }

1746

1747 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1748 {

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 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1855 model->setProperty(3, "size", 10);

1856 model->setProperty(4, "size", 10);

1857 model->setProperty(5, "size", 10);

1858 model->setProperty(6, "size", 10);

1859 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1860 }

1861

1862 void testResizeRemoveInsertBug1279434()

1863 {

1864 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1865 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1866

1867 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1868 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1869 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1870 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1871 verifyItem(0, 50., 125., false);

1872 verifyItem(1, 175., 100., false);

1873

1874 lvwph->setContentY(175);

1875

1876 model->setProperty(1, "size", 4);

1877 model->setProperty(0, "size", 4);

1878

1879 model->setProperty(0, "size", 6);

1880

1881 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1882 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1883 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1884

1885 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1886 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1887 }

1888

1889 void testResizeScrolledBigItem()

1890 {

1891 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1892 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1893

1894 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1895 changeContentY(8000);

1896

1897 // Pretend the list is busy requesting some other index

1898 lvwph->m_asyncRequestedIndex = 4;

1899

1900 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1901 // This resize makes the item go outside the viewport so its deleted

1902 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1903 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1904 // On the next polish the item will be readded

1905 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1906 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1907 }

1908

1909 void testNoCacheBuffer()

1910 {

1911 lvwph->setCacheBuffer(0);

1912 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1913 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1914 verifyItem(0, 50., 150., false);

1915 verifyItem(1, 200., 200., false);

1916 verifyItem(2, 400., 350., false);

1917 QCOMPARE(lvwph->m_minYExtent, 0.);

1918 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1919 QCOMPARE(lvwph->m_clipItem->clip(), false);

1920 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1921 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1922 QCOMPARE(lvwph->contentY(), 0.);

1923 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1924 }

1925

1926 void testAllCacheBuffer()

1927 {

1928 lvwph->setCacheBuffer(std::numeric_limits<int>::max());

1929 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

1930 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1931 verifyItem(0, 50., 150., false);

1932 verifyItem(1, 200., 200., false);

1933 verifyItem(2, 400., 350., false);

1934 verifyItem(3, 750., 350., true);

1935 verifyItem(4, 1100., 350., true);

1936 verifyItem(5, 1450., 350., true);

1937 QCOMPARE(lvwph->m_minYExtent, 0.);

1938 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1939 QCOMPARE(lvwph->m_clipItem->clip(), false);

1940 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1941 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1942 QCOMPARE(lvwph->contentY(), 0.);

1943 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1944 }

1945

1946 void testFirstVisibleIndexRemove()

1947 {

1948 changeContentY(520);

1949 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1950 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1951

1952 // Remove 0 and 1, the previously visible index 2 will be 0 and visible

1953 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1954 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1955 }

1956

1957 void testBug1540490()

1958 {

1959 lvwph->header()->setImplicitHeight(150);

1960 verifyItem(0, 150., 150., false);

1961

1962 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1963 model->setProperty(0, "size", 400);

1964 model->setProperty(1, "size", 600);

1965 model->setProperty(2, "size", 300);

1966

1967 scrollToBottom();

1968 changeContentY(-200);

1969

1970 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 2));

1971 model->setProperty(0, "size", 100);

1972 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1));

1973 lvwph->header()->setImplicitHeight(50);

1974 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 200));

1975

1976 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1977 verifyItem(0, 50., 200., false);

1978 }

1979

1980private:

1981 QQuickView *view;

1982 ListViewWithPageHeader *lvwph;

1983 QQmlListModel *model;

1984 QQmlComponent *otherDelegate;

1985};

1986

1987QTEST_MAIN(ListViewWithPageHeaderTest)

1988

1989#include "listviewwithpageheadertest.moc"