tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 0144005 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

2038 lines 79 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#include <private/qqmllistmodel_p.h>

25#include <private/qquickanimation_p.h>

26#include <private/qquickitem_p.h>

28#include <limits>

30#include <paths.h>

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

33// particullary making sure that lost items are culled

34// and then removed in the next updatePolish cycle

36class ListViewWithPageHeaderTest : public QObject

37{

38 Q_OBJECT

40private:

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

42 {

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

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

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

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

47 if (lvwph->delegate() == otherDelegate) {

48 QCOMPARE(item->m_item->width(), lvwph->width());

49 } else {

50 QCOMPARE(item->m_item->width(), lvwph->width() - 20);

51 }

52 }

54 void changeContentY(qreal change)

55 {

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

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

58 const qreal jump = 25;

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

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

61 QTest::qWait(1);

62 }

63 } else {

64 const qreal jump = -25;

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

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

67 QTest::qWait(1);

68 }

69 }

70 lvwph->setContentY(dest);

71 QTest::qWait(1);

72 }

74 void scrollToTop()

75 {

76 const qreal jump = -25;

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

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

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

80 } else {

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

82 }

83 QTest::qWait(1);

84 }

85 }

87 void scrollToBottom()

88 {

89 const qreal jump = 25;

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

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

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

93 } else {

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

95 }

96 QTest::qWait(1);

97 }

98 }

100 void verifyInitialTopPosition()

101 {

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

103 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

115 }

116

117private Q_SLOTS:

118

119 void initTestCase()

120 {

121 }

122

123 void init()

124 {

125 view = new QQuickView();

126 view->setSource(QUrl::fromLocalFile(testDataDir() + "/" TEST_DIR "/listviewwithpageheadertest.qml"));

127 lvwph = static_cast<ListViewWithPageHeader*>(view->rootObject()->findChild<QQuickFlickable*>());

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

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

130 QVERIFY(lvwph);

131 QVERIFY(model);

132 QVERIFY(otherDelegate);

133 view->show();

134 QTest::qWaitForWindowExposed(view);

135

136 verifyInitialTopPosition();

137 }

138

139 void cleanup()

140 {

141 delete view;

142 }

143

144 void testCreationDeletion()

145 {

146 // Nothing, init/cleanup already tests this

147 }

148

149 void testDrag1PixelUp()

150 {

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

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

153 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

165 }

166

167 void testHeaderDetachDragDown()

168 {

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

170 QTest::qWait(100);

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

172 QTest::qWait(100);

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

174 QTest::qWait(100);

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

176 QTest::qWait(100);

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

178 QTest::qWait(100);

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

180 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

192

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

194

195 verifyInitialTopPosition();

196 }

197

198 void testDrag375PixelUp()

199 {

200 changeContentY(375);

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

202 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

215 }

216

217 void testDrag520PixelUp()

218 {

219 changeContentY(520);

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

221 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

232 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

239 }

240

241 void testDragHeaderUpThenShow()

242 {

243 changeContentY(120);

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

245 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

257

258 changeContentY(-30);

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

260 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

272 }

273

274 void testDragHeaderUpThenShowWithoutHidingTotally()

275 {

276 changeContentY(10);

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

278 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

290

291 changeContentY(-1);

292

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

294 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

306 }

307

308 void testPositionAtBeginningIndex0Visible()

309 {

310 changeContentY(375);

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

312 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

325

326 lvwph->positionAtBeginning();

327

328 verifyInitialTopPosition();

329 }

330

331 void testPositionAtBeginningIndex0NotVisible()

332 {

333 changeContentY(520);

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

335 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

340 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

347

348 lvwph->positionAtBeginning();

349

350 verifyInitialTopPosition();

351 }

352

353 void testIndex0GrowOnScreen()

354 {

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

356

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

358 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

369 }

370

371 void testIndex0GrowOffScreen()

372 {

373 changeContentY(375);

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

375 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

388

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

390

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

392 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

405

406 scrollToTop();

407

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

409 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

420

421 changeContentY(30);

422

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

424 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

435 }

436

437 void testIndex0GrowNotCreated()

438 {

439 changeContentY(520);

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

441 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

446 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

453

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

455

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

457 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

462 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

469

470 scrollToTop();

471

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

473 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

484 }

485

486 void testShowHideShowHeaderAtBottom()

487 {

488 scrollToBottom();

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

490 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

501

502 changeContentY(-30);

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

504 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

515

516 changeContentY(30);

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

518 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

529

530 changeContentY(-30);

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

532 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

543 }

544

545 void testChangeDelegateAtBottom()

546 {

547 scrollToBottom();

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

549 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

560

561 lvwph->setDelegate(otherDelegate);

562

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

564 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

578 }

579

580 void testSetEmptyHeaderAtTop()

581 {

582 lvwph->setHeader(nullptr);

583

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

585 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

596 }

597

598 void testSetEmptyHeaderAtBottom()

599 {

600 scrollToBottom();

601 lvwph->setHeader(nullptr);

602

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

604 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

614

615 scrollToTop();

616

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

618 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

629 }

630

631 void testSetEmptyHeaderWhenPartlyShownClipped()

632 {

633 scrollToBottom();

634 changeContentY(-30);

635 lvwph->setHeader(nullptr);

636

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

638 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

648 QTRY_VERIFY(lvwph->isAtYEnd());

649

650 scrollToTop();

651

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

653 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

664 }

665

666 void testSetEmptyHeaderWhenPartlyShownNotClipped()

667 {

668 changeContentY(30);

669 lvwph->setHeader(nullptr);

670

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

672 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

683 }

684

685 void testSetNullDelegate()

686 {

687 lvwph->setDelegate(nullptr);

688

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

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

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

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

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

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

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

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

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

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

699 QVERIFY(lvwph->isAtYBeginning());

700 QVERIFY(lvwph->isAtYEnd());

701 }

702

703 void testInsertItems()

704 {

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

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

707

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

709 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

722 }

723

724 void testInsertItemsOnNotShownPosition()

725 {

726 changeContentY(700);

727

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

729 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

741

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

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

744

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

746 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

758

759 scrollToTop();

760

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

762 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

775 }

776

777 void testInsertItemsAtEndOfViewport()

778 {

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

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

781

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

783 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

795 }

796

797 void testInsertItemsBeforeValidIndex()

798 {

799 changeContentY(520);

800

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

802 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

807 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

814

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

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

817

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

819 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

824 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

831 }

832

833 void testInsertItemsBeforeViewport()

834 {

835 changeContentY(375);

836

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

838 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

851

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

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

854

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

856 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

869

870 scrollToTop();

871

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

873 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

886 }

887

888 void testInsertItemsAtBottom()

889 {

890 scrollToBottom();

891

892 QVERIFY(lvwph->isAtYEnd());

893

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

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

896

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

898 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

912

913 scrollToBottom();

914

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

916 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

928 QVERIFY(lvwph->isAtYEnd());

929 }

930

931 void testInsertItemAtTop()

932 {

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

934

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

936 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

948 QVERIFY(lvwph->isAtYBeginning());

949 }

950

951 void testInsertItem10SmallItemsAtTopWhenAtBottom()

952 {

953 scrollToBottom();

954

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 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));

965

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

967 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

978

979 changeContentY(-800);

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

981 changeContentY(-400);

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

983 changeContentY(-200);

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

985 changeContentY(-300);

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

987

988 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1008 }

1009

1010 void testInsertToEmpty()

1011 {

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

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

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

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

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

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

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

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

1020

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

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

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

1024 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1027 }

1028

1029 void testRemoveItemsAtTop()

1030 {

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

1032

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

1034 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1045 QVERIFY(lvwph->isAtYBeginning());

1046 }

1047

1048 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1049 {

1050 scrollToBottom();

1051

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

1053

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

1055 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1066 }

1067

1068 void testRemoveLastItemsAtBottom()

1069 {

1070 scrollToBottom();

1071

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

1073

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

1075 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1086 }

1087

1088 void testRemoveItemOutOfViewport()

1089 {

1090 changeContentY(520);

1091

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

1093 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1098 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1105

1106

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

1108

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

1110 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1122 }

1123

1124 void testMoveFirstItems()

1125 {

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

1127

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

1129 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1141

1142 }

1143

1144 void testMoveFirstOutOfVisibleItems()

1145 {

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

1147

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

1149 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1160

1161 }

1162

1163 void testMoveFirstToLastAtBottom()

1164 {

1165 scrollToBottom();

1166

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

1168 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1179

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

1181

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

1183 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1196 }

1197

1198 void testChangeSizeVisibleItemNotOnViewport()

1199 {

1200 changeContentY(440);

1201

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

1203 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1216

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

1218

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

1220 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1233 }

1234

1235 void testShowHeaderCloseToTheTop()

1236 {

1237 changeContentY(375);

1238

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

1240 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1253

1254 lvwph->showHeader();

1255

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

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

1258 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1271

1272 scrollToTop();

1273

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

1275 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1285 QCOMPARE(lvwph->contentY(), -50.);

1286 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1287 }

1288

1289 void testShowHeaderHalfShown()

1290 {

1291 changeContentY(20);

1292

1293 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1294 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1295 verifyItem(0, 30., 150., false);

1296 verifyItem(1, 180, 200., false);

1297 verifyItem(2, 380, 350., false);

1298 verifyItem(3, 730, 350., true);

1299 QCOMPARE(lvwph->m_minYExtent, 0.);

1300 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1301 QCOMPARE(lvwph->m_clipItem->clip(), false);

1302 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1303 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1304 QCOMPARE(lvwph->contentY(), 20.);

1305 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1306

1307 lvwph->showHeader();

1308

1309 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1310 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1311 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1312 verifyItem(0, -20., 150., false);

1313 verifyItem(1, 130, 200., false);

1314 verifyItem(2, 330, 350., false);

1315 verifyItem(3, 680, 350., true);

1316 QCOMPARE(lvwph->m_minYExtent, 20.);

1317 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1318 QCOMPARE(lvwph->m_clipItem->clip(), true);

1319 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1320 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1321 QCOMPARE(lvwph->contentY(), 0.);

1322 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1323

1324 scrollToTop();

1325

1326 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1327 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1328 verifyItem(0, 50., 150., false);

1329 verifyItem(1, 200., 200., false);

1330 verifyItem(2, 400., 350., false);

1331 verifyItem(3, 750, 350., true);

1332 QCOMPARE(lvwph->m_minYExtent, 20.);

1333 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1334 QCOMPARE(lvwph->m_clipItem->clip(), false);

1335 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1336 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1337 QCOMPARE(lvwph->contentY(), -20.);

1338 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1339 }

1340

1341 void testShowHeaderAtBottom()

1342 {

1343 scrollToBottom();

1344

1345 lvwph->showHeader();

1346

1347 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1348 QTRY_VERIFY (lvwph->isAtYEnd());

1349 }

1350

1351 void growWindow()

1352 {

1353 view->rootObject()->setHeight(850);

1354

1355 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1356 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1357 verifyItem(0, 50., 150., false);

1358 verifyItem(1, 200., 200., false);

1359 verifyItem(2, 400., 350., false);

1360 verifyItem(3, 750., 350., false);

1361 verifyItem(4, 1100., 350., true);

1362 QCOMPARE(lvwph->m_minYExtent, 0.);

1363 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1364 QCOMPARE(lvwph->m_clipItem->clip(), false);

1365 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1366 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1367 QCOMPARE(lvwph->contentY(), 0.);

1368 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1369 }

1370

1371 void growWindowAtBottom()

1372 {

1373 scrollToBottom();

1374

1375 view->rootObject()->setHeight(850);

1376

1377 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1378 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1379 verifyItem(0, -550., 350., true);

1380 verifyItem(1, -200., 350., false);

1381 verifyItem(2, 150, 350., false);

1382 verifyItem(3, 500, 350., false);

1383 QCOMPARE(lvwph->m_minYExtent, 350.);

1384 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1385 QCOMPARE(lvwph->m_clipItem->clip(), false);

1386 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1387 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1388 QCOMPARE(lvwph->contentY(), 950.);

1389 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1390 }

1391

1392 void testCrashShowHeaderWithNoHeader()

1393 {

1394 lvwph->setHeader(nullptr);

1395 lvwph->showHeader();

1396 }

1397

1398 void testCullOnBottomEdge()

1399 {

1400 changeContentY(200);

1401

1402 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1403 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1404 verifyItem(0, -150., 150., true);

1405 verifyItem(1, 0., 200., false);

1406 verifyItem(2, 200., 350., false);

1407 verifyItem(3, 550., 350., true);

1408 QCOMPARE(lvwph->m_minYExtent, 0.);

1409 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1410 QCOMPARE(lvwph->m_clipItem->clip(), false);

1411 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1412 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1413 QCOMPARE(lvwph->contentY(), 200.);

1414 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1415 }

1416

1417 void testMaximizeVisibleArea()

1418 {

1419 bool res = lvwph->maximizeVisibleArea(2);

1420 QVERIFY(res);

1421 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1422

1423 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1424 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1425 verifyItem(0, -158., 150., true);

1426 verifyItem(1, -8., 200., false);

1427 verifyItem(2, 192, 350., false);

1428 verifyItem(3, 542, 350., true);

1429 QCOMPARE(lvwph->m_minYExtent, 0.);

1430 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1431 QCOMPARE(lvwph->m_clipItem->clip(), false);

1432 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1433 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1434 QCOMPARE(lvwph->contentY(), 208.);

1435 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1436 }

1437

1438 void testMaximizeVisibleAreaVisibleItems()

1439 {

1440 bool res = lvwph->maximizeVisibleArea(0);

1441 QVERIFY(res);

1442 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1443

1444 verifyInitialTopPosition();

1445

1446 res = lvwph->maximizeVisibleArea(1);

1447 QVERIFY(res);

1448 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1449

1450 verifyInitialTopPosition();

1451 }

1452

1453 void testMaximizeVisibleAreaInvalidIndexes()

1454 {

1455 bool res = lvwph->maximizeVisibleArea(-1);

1456 QVERIFY(!res);

1457 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1458

1459 verifyInitialTopPosition();

1460

1461 res = lvwph->maximizeVisibleArea(1000);

1462 QVERIFY(!res);

1463 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1464

1465 verifyInitialTopPosition();

1466

1467 res = lvwph->maximizeVisibleArea(4);

1468 QVERIFY(!res);

1469 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1470

1471 verifyInitialTopPosition();

1472 }

1473

1474 void testMaximizeVisibleAreaBigElement()

1475 {

1476 model->setProperty(2, "size", 4000);

1477 bool res = lvwph->maximizeVisibleArea(2);

1478 QVERIFY(res);

1479 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1480

1481 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1482 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1483 verifyItem(0, -350., 150., true);

1484 verifyItem(1, -200., 200., true);

1485 verifyItem(2, 0, 4000., false);

1486 QCOMPARE(lvwph->m_minYExtent, 0.);

1487 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1488 QCOMPARE(lvwph->m_clipItem->clip(), false);

1489 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1490 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1491 QCOMPARE(lvwph->contentY(), 400.);

1492 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1493 }

1494

1495 void testMaximizeVisibleAreaScrollDown()

1496 {

1497 changeContentY(250);

1498 bool res = lvwph->maximizeVisibleArea(1);

1499 QVERIFY(res);

1500 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1501

1502 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1503 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1504 verifyItem(0, -150., 150., true);

1505 verifyItem(1, 0., 200., false);

1506 verifyItem(2, 200, 350., false);

1507 verifyItem(3, 550, 350., true);

1508 QCOMPARE(lvwph->m_minYExtent, 0.);

1509 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1510 QCOMPARE(lvwph->m_clipItem->clip(), false);

1511 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1512 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1513 QCOMPARE(lvwph->contentY(), 200.);

1514 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1515 }

1516

1517 void testMaximizeVisibleAreaScrollDownBigElement()

1518 {

1519 model->setProperty(1, "size", 1000);

1520 changeContentY(1150);

1521 bool res = lvwph->maximizeVisibleArea(1);

1522 QVERIFY(res);

1523 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1524

1525 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1526 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1527 verifyItem(0, -458., 1000., false);

1528 verifyItem(1, 542., 350., true);

1529 QCOMPARE(lvwph->m_minYExtent, 525.);

1530 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1531 QCOMPARE(lvwph->m_clipItem->clip(), false);

1532 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1533 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1534 QCOMPARE(lvwph->contentY(), 658.);

1535 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1536 }

1537

1538 void testMaximizeVisibleAreaBigElementInTheMiddle()

1539 {

1540 model->setProperty(1, "size", 1000);

1541 changeContentY(650);

1542

1543 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1544 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1545 verifyItem(0, -450., 1000., false);

1546 verifyItem(1, 550., 350., true);

1547 QCOMPARE(lvwph->m_minYExtent, 525.);

1548 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1549 QCOMPARE(lvwph->m_clipItem->clip(), false);

1550 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1551 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1552 QCOMPARE(lvwph->contentY(), 650.);

1553 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1554

1555 bool res = lvwph->maximizeVisibleArea(1);

1556 QVERIFY(res);

1557 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1558

1559 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1560 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1561 verifyItem(0, -450., 1000., false);

1562 verifyItem(1, 550., 350., true);

1563 QCOMPARE(lvwph->m_minYExtent, 525.);

1564 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1565 QCOMPARE(lvwph->m_clipItem->clip(), false);

1566 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1567 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1568 QCOMPARE(lvwph->contentY(), 650.);

1569 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1570 }

1571

1572 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1573 {

1574 changeContentY(430);

1575 changeContentY(-30);

1576

1577 bool res = lvwph->maximizeVisibleArea(1);

1578 QVERIFY(res);

1579 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1580

1581 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1582 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1583 verifyItem(0, -150., 150., true);

1584 verifyItem(1, 0., 200., false);

1585 verifyItem(2, 200, 350., false);

1586 verifyItem(3, 550, 350., true);

1587 QCOMPARE(lvwph->m_minYExtent, 0.);

1588 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1589 QCOMPARE(lvwph->m_clipItem->clip(), false);

1590 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1591 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1592 QCOMPARE(lvwph->contentY(), 200.);

1593 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1594 }

1595

1596 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1597 {

1598 testMaximizeVisibleAreaTopWithHalfPageHeader();

1599

1600 changeContentY(-60);

1601 changeContentY(15);

1602

1603 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1604 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1605 verifyItem(0, -140., 150., false);

1606 verifyItem(1, 10., 200., false);

1607 verifyItem(2, 210, 350., false);

1608 verifyItem(3, 560, 350., true);

1609 QCOMPARE(lvwph->m_minYExtent, 0.);

1610 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1611 QCOMPARE(lvwph->m_clipItem->clip(), true);

1612 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1613 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1614 QCOMPARE(lvwph->contentY(), 155.);

1615 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1616 }

1617

1618 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1619 {

1620 changeContentY(430);

1621 changeContentY(-30);

1622

1623 bool res = lvwph->maximizeVisibleArea(3);

1624 QVERIFY(res);

1625 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1626

1627 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1628 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1629 verifyItem(0, -358., 200., true);

1630 verifyItem(1, -158., 350., false);

1631 verifyItem(2, 192, 350., false);

1632 verifyItem(3, 542, 350., true);

1633 QCOMPARE(lvwph->m_minYExtent, 162.5);

1634 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1635 QCOMPARE(lvwph->m_clipItem->clip(), false);

1636 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1637 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1638 QCOMPARE(lvwph->contentY(), 558.);

1639 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1640 }

1641

1642 void testMaximizeVisibleAreaWithItemResize()

1643 {

1644 model->setProperty(0, "size", 1000);

1645

1646 bool res = lvwph->maximizeVisibleArea(1);

1647 QVERIFY(res);

1648 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1649

1650 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1651 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1652 verifyItem(0, -658., 1000., false);

1653 verifyItem(1, 342., 200., false);

1654 verifyItem(2, 542, 350., true);

1655 QCOMPARE(lvwph->m_minYExtent, 0.);

1656 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1657 QCOMPARE(lvwph->m_clipItem->clip(), false);

1658 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1659 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1660 QCOMPARE(lvwph->contentY(), 708.);

1661 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1662 }

1663

1664 void addingRemoveItemsShouldNotChangeContentY()

1665 {

1666 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

1667 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1668 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1669

1670 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1671 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1672 verifyItem(0, 50., 150., false);

1673 QCOMPARE(lvwph->m_minYExtent, 0.);

1674 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1675 QCOMPARE(lvwph->m_clipItem->clip(), false);

1676 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1677 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1678 QCOMPARE(lvwph->contentY(), 0.);

1679 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1680

1681 QCOMPARE(spy.count(), 0);

1682 }

1683

1684 void testOvershootOnSameSize()

1685 {

1686 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1687 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1688 QCOMPARE(lvwph->m_minYExtent, 0.);

1689 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1690 QCOMPARE(lvwph->m_clipItem->clip(), false);

1691 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1692 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1693 QCOMPARE(lvwph->contentY(), 0.);

1694

1695 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1696 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1697 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1698 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1699 verifyItem(0, 50., 392., false);

1700 verifyItem(1, 442., 100., false);

1701

1702 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1703

1704 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1705 QTest::qWait(100);

1706 QTest::mouseMove(view, QPoint(0, 5));

1707 QTest::qWait(100);

1708 QTest::mouseMove(view, QPoint(0, 10));

1709 QTest::qWait(100);

1710 QTest::mouseMove(view, QPoint(0, 15));

1711 QTest::qWait(100);

1712 QTest::mouseMove(view, QPoint(0, 20));

1713 QTest::qWait(100);

1714 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1715 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1716 verifyItem(0, 55., 392., false);

1717 verifyItem(1, 447., 100., false);

1718 QCOMPARE(lvwph->m_minYExtent, 0.);

1719 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1720

1721 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1722 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1723 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1724 verifyItem(0, 50., 392., false);

1725 verifyItem(1, 442., 100., false);

1726 }

1727

1728 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1729 {

1730 model->setProperty(0, "size", 800);

1731 verifyItem(0, 50., 800., false);

1732

1733 lvwph->maximizeVisibleArea(0);

1734 QTRY_COMPARE(lvwph->contentY(), 50.);

1735

1736 changeContentY(10);

1737 QTRY_COMPARE(lvwph->contentY(), 60.);

1738

1739 lvwph->showHeader();

1740 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1741 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1742 QCOMPARE(lvwph->m_minYExtent, 50.);

1743 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1744 QCOMPARE(lvwph->m_clipItem->clip(), true);

1745 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1746 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1747 QCOMPARE(lvwph->contentY(), 10.);

1748 verifyItem(0, -60., 800., false);

1749 }

1750

1751 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1752 {

1753 model->setProperty(0, "size", 800);

1754 verifyItem(0, 50., 800., false);

1755

1756 lvwph->maximizeVisibleArea(0);

1757 QTRY_COMPARE(lvwph->contentY(), 50.);

1758

1759 changeContentY(-10);

1760 QTRY_COMPARE(lvwph->contentY(), 40.);

1761

1762 lvwph->showHeader();

1763 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1764 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1765 QCOMPARE(lvwph->m_minYExtent, 40.);

1766 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1767 QCOMPARE(lvwph->m_clipItem->clip(), true);

1768 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1769 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1770 QCOMPARE(lvwph->contentY(), 0.);

1771 verifyItem(0, -40., 800., false);

1772 }

1773

1774 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1775 {

1776 model->setProperty(0, "size", 800);

1777 verifyItem(0, 50., 800., false);

1778

1779 lvwph->maximizeVisibleArea(0);

1780 QTRY_COMPARE(lvwph->contentY(), 50.);

1781

1782 changeContentY(-10);

1783 QTRY_COMPARE(lvwph->contentY(), 40.);

1784 changeContentY(10);

1785 QTRY_COMPARE(lvwph->contentY(), 50.);

1786

1787 lvwph->showHeader();

1788 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1789

1790 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1791 QCOMPARE(lvwph->m_minYExtent, 50.);

1792 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1793 QCOMPARE(lvwph->m_clipItem->clip(), true);

1794 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1795 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1796 QCOMPARE(lvwph->contentY(), 0.);

1797 verifyItem(0, -50., 800., false);

1798 }

1799

1800 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1801 {

1802 model->setProperty(0, "size", 800);

1803 verifyItem(0, 50., 800., false);

1804

1805 lvwph->maximizeVisibleArea(0);

1806 QTRY_COMPARE(lvwph->contentY(), 50.);

1807

1808 changeContentY(10);

1809 QTRY_COMPARE(lvwph->contentY(), 60.);

1810 changeContentY(-10);

1811 QTRY_COMPARE(lvwph->contentY(), 50.);

1812

1813 lvwph->showHeader();

1814 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1815 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1816 QCOMPARE(lvwph->m_minYExtent, 40.);

1817 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1818 QCOMPARE(lvwph->m_clipItem->clip(), true);

1819 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1820 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1821 QCOMPARE(lvwph->contentY(), 10.);

1822 verifyItem(0, -50., 800., false);

1823 }

1824

1825 void testMaximizeVisibleAreaAndShowHeader()

1826 {

1827 model->setProperty(0, "size", 800);

1828 verifyItem(0, 50., 800., false);

1829

1830 lvwph->maximizeVisibleArea(0);

1831 QTRY_COMPARE(lvwph->contentY(), 50.);

1832

1833 lvwph->showHeader();

1834 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1835 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1836 QCOMPARE(lvwph->m_minYExtent, 50.);

1837 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1838 QCOMPARE(lvwph->m_clipItem->clip(), true);

1839 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1840 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1841 QCOMPARE(lvwph->contentY(), 0.);

1842 verifyItem(0, -50., 800., false);

1843 }

1844

1845 void positionAtBeginningEmpty()

1846 {

1847 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1848 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1849

1850 lvwph->positionAtBeginning();

1851 }

1852

1853 void testHeaderPositionBug1240118()

1854 {

1855 scrollToBottom();

1856 lvwph->showHeader();

1857 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1858 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1859 model->setProperty(3, "size", 10);

1860 model->setProperty(4, "size", 10);

1861 model->setProperty(5, "size", 10);

1862 model->setProperty(6, "size", 10);

1863 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1864 }

1865

1866 void testResizeRemoveInsertBug1279434()

1867 {

1868 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1869 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1870

1871 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1872 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1873 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1874 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1875 verifyItem(0, 50., 125., false);

1876 verifyItem(1, 175., 100., false);

1877

1878 lvwph->setContentY(175);

1879

1880 model->setProperty(1, "size", 4);

1881 model->setProperty(0, "size", 4);

1882

1883 model->setProperty(0, "size", 6);

1884

1885 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1886 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1887 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1888

1889 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1890 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1891 }

1892

1893 void testResizeScrolledBigItem()

1894 {

1895 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1896 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1897

1898 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1899 changeContentY(8000);

1900

1901 // Pretend the list is busy requesting some other index

1902 lvwph->m_asyncRequestedIndex = 4;

1903

1904 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1905 // This resize makes the item go outside the viewport so its deleted

1906 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1907 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1908 // On the next polish the item will be readded

1909 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1910 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1911 }

1912

1913 void testNoCacheBuffer()

1914 {

1915 lvwph->setCacheBuffer(0);

1916 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1917 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1918 verifyItem(0, 50., 150., false);

1919 verifyItem(1, 200., 200., false);

1920 verifyItem(2, 400., 350., false);

1921 QCOMPARE(lvwph->m_minYExtent, 0.);

1922 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1923 QCOMPARE(lvwph->m_clipItem->clip(), false);

1924 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1925 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1926 QCOMPARE(lvwph->contentY(), 0.);

1927 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1928 }

1929

1930 void testAllCacheBuffer()

1931 {

1932 lvwph->setCacheBuffer(std::numeric_limits<int>::max());

1933 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

1934 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1935 verifyItem(0, 50., 150., false);

1936 verifyItem(1, 200., 200., false);

1937 verifyItem(2, 400., 350., false);

1938 verifyItem(3, 750., 350., true);

1939 verifyItem(4, 1100., 350., true);

1940 verifyItem(5, 1450., 350., true);

1941 QCOMPARE(lvwph->m_minYExtent, 0.);

1942 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1943 QCOMPARE(lvwph->m_clipItem->clip(), false);

1944 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1945 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1946 QCOMPARE(lvwph->contentY(), 0.);

1947 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1948 }

1949

1950 void testFirstVisibleIndexRemove()

1951 {

1952 changeContentY(520);

1953 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1954 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1955

1956 // Remove 0 and 1, the previously visible index 2 will be 0 and visible

1957 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1958 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1959 }

1960

1961 void testBug1540490()

1962 {

1963 lvwph->header()->setImplicitHeight(150);

1964 verifyItem(0, 150., 150., false);

1965

1966 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1967 model->setProperty(0, "size", 400);

1968 model->setProperty(1, "size", 600);

1969 model->setProperty(2, "size", 300);

1970

1971 scrollToBottom();

1972 changeContentY(-200);

1973

1974 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 2));

1975 model->setProperty(0, "size", 100);

1976 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1));

1977 lvwph->header()->setImplicitHeight(50);

1978 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 200));

1979

1980 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1981 verifyItem(0, 50., 200., false);

1982 }

1983

1984 void testBug1569976()

1985 {

1986 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1987

1988 for (int i = 0; i < 10; ++i) {

1989 scrollToBottom();

1990 lvwph->showHeader();

1991 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1992 scrollToTop();

1993 }

1994 verifyItem(0, 50., 150., false);

1995 verifyItem(1, 200., 200., false);

1996 verifyItem(2, 400., 350., false);

1997 }

1998

1999 void testRemoveItemNotShowHeader()

2000 {

2001 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

2002 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 90));

2003 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 600));

2004 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

2005 scrollToBottom();

2006 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 2000));

2007 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2008 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 2), Q_ARG(QVariant, 1));

2009 QTRY_COMPARE(lvwph->m_headerItem->y(), -610.);

2010 QTRY_COMPARE(lvwph->m_minYExtent, 610.);

2011 }

2012

2013 void testRemoveItemCutContents()

2014 {

2015 view->rootObject()->setHeight(921);

2016 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

2017 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1000));

2018 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2019 QTRY_COMPARE(lvwph->contentHeight(), 1050.);

2020 scrollToBottom();

2021 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 530));

2022 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

2023 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

2024 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2025 verifyItem(0, 50., 530., false);

2026 QTRY_COMPARE(lvwph->m_minYExtent, 530.);

2027 }

2028

2029private:

2030 QQuickView *view;

2031 ListViewWithPageHeader *lvwph;

2032 QQmlListModel *model;

2033 QQmlComponent *otherDelegate;

2034};

2035

2036QTEST_MAIN(ListViewWithPageHeaderTest)

2037

2038#include "listviewwithpageheadertest.moc"