tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 2e79fe0 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

2009 lines 77 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 if (lvwph->delegate() == otherDelegate) {

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

50 } else {

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

52 }

53 }

55 void changeContentY(qreal change)

56 {

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

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

59 const qreal jump = 25;

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

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

62 QTest::qWait(1);

63 }

64 } else {

65 const qreal jump = -25;

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

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

68 QTest::qWait(1);

69 }

70 }

71 lvwph->setContentY(dest);

72 QTest::qWait(1);

73 }

75 void scrollToTop()

76 {

77 const qreal jump = -25;

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

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

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

81 } else {

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

83 }

84 QTest::qWait(1);

85 }

86 }

88 void scrollToBottom()

89 {

90 const qreal jump = 25;

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

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

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

94 } else {

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

96 }

97 QTest::qWait(1);

98 }

99 }

100

101 void verifyInitialTopPosition()

102 {

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

104 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

116 }

117

118private Q_SLOTS:

119

120 void initTestCase()

121 {

122 }

123

124 void init()

125 {

126 view = new QQuickView();

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

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

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

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

131 QVERIFY(lvwph);

132 QVERIFY(model);

133 QVERIFY(otherDelegate);

134 view->show();

135 QTest::qWaitForWindowExposed(view);

136

137 verifyInitialTopPosition();

138 }

139

140 void cleanup()

141 {

142 delete view;

143 }

144

145 void testCreationDeletion()

146 {

147 // Nothing, init/cleanup already tests this

148 }

149

150 void testDrag1PixelUp()

151 {

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

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

154 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

166 }

167

168 void testHeaderDetachDragDown()

169 {

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QTest::qWait(100);

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

179 QTest::qWait(100);

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

181 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

193

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

195

196 verifyInitialTopPosition();

197 }

198

199 void testDrag375PixelUp()

200 {

201 changeContentY(375);

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

203 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

216 }

217

218 void testDrag520PixelUp()

219 {

220 changeContentY(520);

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

222 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

233 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

240 }

241

242 void testDragHeaderUpThenShow()

243 {

244 changeContentY(120);

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

246 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

258

259 changeContentY(-30);

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

261 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

273 }

274

275 void testDragHeaderUpThenShowWithoutHidingTotally()

276 {

277 changeContentY(10);

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

279 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

291

292 changeContentY(-1);

293

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

295 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

307 }

308

309 void testPositionAtBeginningIndex0Visible()

310 {

311 changeContentY(375);

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

313 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

326

327 lvwph->positionAtBeginning();

328

329 verifyInitialTopPosition();

330 }

331

332 void testPositionAtBeginningIndex0NotVisible()

333 {

334 changeContentY(520);

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

336 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

341 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

348

349 lvwph->positionAtBeginning();

350

351 verifyInitialTopPosition();

352 }

353

354 void testIndex0GrowOnScreen()

355 {

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

357

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

359 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

370 }

371

372 void testIndex0GrowOffScreen()

373 {

374 changeContentY(375);

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

376 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

389

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

391

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

393 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

406

407 scrollToTop();

408

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

410 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

421

422 changeContentY(30);

423

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

425 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

436 }

437

438 void testIndex0GrowNotCreated()

439 {

440 changeContentY(520);

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

442 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

447 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

454

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

456

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

458 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

463 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

470

471 scrollToTop();

472

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

474 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

485 }

486

487 void testShowHideShowHeaderAtBottom()

488 {

489 scrollToBottom();

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

491 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

502

503 changeContentY(-30);

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

505 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

516

517 changeContentY(30);

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

519 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

530

531 changeContentY(-30);

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

533 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

544 }

545

546 void testChangeDelegateAtBottom()

547 {

548 scrollToBottom();

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

550 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

561

562 lvwph->setDelegate(otherDelegate);

563

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

565 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

579 }

580

581 void testSetEmptyHeaderAtTop()

582 {

583 lvwph->setHeader(nullptr);

584

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

586 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

597 }

598

599 void testSetEmptyHeaderAtBottom()

600 {

601 scrollToBottom();

602 lvwph->setHeader(nullptr);

603

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

605 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

615

616 scrollToTop();

617

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

619 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

630 }

631

632 void testSetEmptyHeaderWhenPartlyShownClipped()

633 {

634 scrollToBottom();

635 changeContentY(-30);

636 lvwph->setHeader(nullptr);

637

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

639 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

649 QTRY_VERIFY(lvwph->isAtYEnd());

650

651 scrollToTop();

652

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

654 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

665 }

666

667 void testSetEmptyHeaderWhenPartlyShownNotClipped()

668 {

669 changeContentY(30);

670 lvwph->setHeader(nullptr);

671

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

673 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

684 }

685

686 void testSetNullDelegate()

687 {

688 lvwph->setDelegate(nullptr);

689

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

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

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

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

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

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

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

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

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

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

700 QVERIFY(lvwph->isAtYBeginning());

701 QVERIFY(lvwph->isAtYEnd());

702 }

703

704 void testInsertItems()

705 {

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

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

708

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

710 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

723 }

724

725 void testInsertItemsOnNotShownPosition()

726 {

727 changeContentY(700);

728

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

730 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

742

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

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

745

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

747 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

759

760 scrollToTop();

761

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

763 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

776 }

777

778 void testInsertItemsAtEndOfViewport()

779 {

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

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

782

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

784 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

796 }

797

798 void testInsertItemsBeforeValidIndex()

799 {

800 changeContentY(520);

801

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

803 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

808 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

815

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

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

818

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

820 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

825 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

832 }

833

834 void testInsertItemsBeforeViewport()

835 {

836 changeContentY(375);

837

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

839 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

852

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

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

855

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

857 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

870

871 scrollToTop();

872

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

874 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

887 }

888

889 void testInsertItemsAtBottom()

890 {

891 scrollToBottom();

892

893 QVERIFY(lvwph->isAtYEnd());

894

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

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

897

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

899 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

913

914 scrollToBottom();

915

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

917 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

929 QVERIFY(lvwph->isAtYEnd());

930 }

931

932 void testInsertItemAtTop()

933 {

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

935

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

937 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

949 QVERIFY(lvwph->isAtYBeginning());

950 }

951

952 void testInsertItem10SmallItemsAtTopWhenAtBottom()

953 {

954 scrollToBottom();

955

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

966

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

968 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

979

980 changeContentY(-800);

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

982 changeContentY(-400);

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

984 changeContentY(-200);

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

986 changeContentY(-300);

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

988

989 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1009 }

1010

1011 void testInsertToEmpty()

1012 {

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

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

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

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

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

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

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

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

1021

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

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

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

1025 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1028 }

1029

1030 void testRemoveItemsAtTop()

1031 {

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

1033

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

1035 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1046 QVERIFY(lvwph->isAtYBeginning());

1047 }

1048

1049 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1050 {

1051 scrollToBottom();

1052

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

1054

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

1056 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1067 }

1068

1069 void testRemoveLastItemsAtBottom()

1070 {

1071 scrollToBottom();

1072

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

1074

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

1076 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1087 }

1088

1089 void testRemoveItemOutOfViewport()

1090 {

1091 changeContentY(520);

1092

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

1094 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1099 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1106

1107

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

1109

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

1111 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1123 }

1124

1125 void testMoveFirstItems()

1126 {

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

1128

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

1130 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1142

1143 }

1144

1145 void testMoveFirstOutOfVisibleItems()

1146 {

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

1148

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

1150 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1161

1162 }

1163

1164 void testMoveFirstToLastAtBottom()

1165 {

1166 scrollToBottom();

1167

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

1169 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1180

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

1182

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

1184 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1197 }

1198

1199 void testChangeSizeVisibleItemNotOnViewport()

1200 {

1201 changeContentY(440);

1202

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

1204 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1217

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

1219

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

1221 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1234 }

1235

1236 void testShowHeaderCloseToTheTop()

1237 {

1238 changeContentY(375);

1239

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

1241 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1254

1255 lvwph->showHeader();

1256

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

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

1259 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1272

1273 scrollToTop();

1274

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

1276 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

1284 QCOMPARE(lvwph->m_headerItem->y(), -50.);

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

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

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

1288 }

1289

1290 void testShowHeaderHalfShown()

1291 {

1292 changeContentY(20);

1293

1294 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1295 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1296 verifyItem(0, 30., 150., false);

1297 verifyItem(1, 180, 200., false);

1298 verifyItem(2, 380, 350., false);

1299 verifyItem(3, 730, 350., true);

1300 QCOMPARE(lvwph->m_minYExtent, 0.);

1301 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1302 QCOMPARE(lvwph->m_clipItem->clip(), false);

1303 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1304 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1305 QCOMPARE(lvwph->contentY(), 20.);

1306 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1307

1308 lvwph->showHeader();

1309

1310 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1311 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1312 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1313 verifyItem(0, -20., 150., false);

1314 verifyItem(1, 130, 200., false);

1315 verifyItem(2, 330, 350., false);

1316 verifyItem(3, 680, 350., true);

1317 QCOMPARE(lvwph->m_minYExtent, 20.);

1318 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1319 QCOMPARE(lvwph->m_clipItem->clip(), true);

1320 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1321 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1322 QCOMPARE(lvwph->contentY(), 0.);

1323 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1324

1325 scrollToTop();

1326

1327 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1328 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1329 verifyItem(0, 50., 150., false);

1330 verifyItem(1, 200., 200., false);

1331 verifyItem(2, 400., 350., false);

1332 verifyItem(3, 750, 350., true);

1333 QCOMPARE(lvwph->m_minYExtent, 20.);

1334 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1335 QCOMPARE(lvwph->m_clipItem->clip(), false);

1336 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1337 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1338 QCOMPARE(lvwph->contentY(), -20.);

1339 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1340 }

1341

1342 void testShowHeaderAtBottom()

1343 {

1344 scrollToBottom();

1345

1346 lvwph->showHeader();

1347

1348 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1349 QTRY_VERIFY (lvwph->isAtYEnd());

1350 }

1351

1352 void growWindow()

1353 {

1354 view->rootObject()->setHeight(850);

1355

1356 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1357 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1358 verifyItem(0, 50., 150., false);

1359 verifyItem(1, 200., 200., false);

1360 verifyItem(2, 400., 350., false);

1361 verifyItem(3, 750., 350., false);

1362 verifyItem(4, 1100., 350., true);

1363 QCOMPARE(lvwph->m_minYExtent, 0.);

1364 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1365 QCOMPARE(lvwph->m_clipItem->clip(), false);

1366 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1367 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1368 QCOMPARE(lvwph->contentY(), 0.);

1369 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1370 }

1371

1372 void growWindowAtBottom()

1373 {

1374 scrollToBottom();

1375

1376 view->rootObject()->setHeight(850);

1377

1378 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1379 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1380 verifyItem(0, -550., 350., true);

1381 verifyItem(1, -200., 350., false);

1382 verifyItem(2, 150, 350., false);

1383 verifyItem(3, 500, 350., false);

1384 QCOMPARE(lvwph->m_minYExtent, 350.);

1385 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1386 QCOMPARE(lvwph->m_clipItem->clip(), false);

1387 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1388 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1389 QCOMPARE(lvwph->contentY(), 950.);

1390 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1391 }

1392

1393 void testCrashShowHeaderWithNoHeader()

1394 {

1395 lvwph->setHeader(nullptr);

1396 lvwph->showHeader();

1397 }

1398

1399 void testCullOnBottomEdge()

1400 {

1401 changeContentY(200);

1402

1403 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1404 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1405 verifyItem(0, -150., 150., true);

1406 verifyItem(1, 0., 200., false);

1407 verifyItem(2, 200., 350., false);

1408 verifyItem(3, 550., 350., true);

1409 QCOMPARE(lvwph->m_minYExtent, 0.);

1410 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1411 QCOMPARE(lvwph->m_clipItem->clip(), false);

1412 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1413 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1414 QCOMPARE(lvwph->contentY(), 200.);

1415 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1416 }

1417

1418 void testMaximizeVisibleArea()

1419 {

1420 bool res = lvwph->maximizeVisibleArea(2);

1421 QVERIFY(res);

1422 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1423

1424 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1425 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1426 verifyItem(0, -158., 150., true);

1427 verifyItem(1, -8., 200., false);

1428 verifyItem(2, 192, 350., false);

1429 verifyItem(3, 542, 350., true);

1430 QCOMPARE(lvwph->m_minYExtent, 0.);

1431 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1432 QCOMPARE(lvwph->m_clipItem->clip(), false);

1433 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1434 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1435 QCOMPARE(lvwph->contentY(), 208.);

1436 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1437 }

1438

1439 void testMaximizeVisibleAreaVisibleItems()

1440 {

1441 bool res = lvwph->maximizeVisibleArea(0);

1442 QVERIFY(res);

1443 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1444

1445 verifyInitialTopPosition();

1446

1447 res = lvwph->maximizeVisibleArea(1);

1448 QVERIFY(res);

1449 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1450

1451 verifyInitialTopPosition();

1452 }

1453

1454 void testMaximizeVisibleAreaInvalidIndexes()

1455 {

1456 bool res = lvwph->maximizeVisibleArea(-1);

1457 QVERIFY(!res);

1458 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1459

1460 verifyInitialTopPosition();

1461

1462 res = lvwph->maximizeVisibleArea(1000);

1463 QVERIFY(!res);

1464 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1465

1466 verifyInitialTopPosition();

1467

1468 res = lvwph->maximizeVisibleArea(4);

1469 QVERIFY(!res);

1470 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1471

1472 verifyInitialTopPosition();

1473 }

1474

1475 void testMaximizeVisibleAreaBigElement()

1476 {

1477 model->setProperty(2, "size", 4000);

1478 bool res = lvwph->maximizeVisibleArea(2);

1479 QVERIFY(res);

1480 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1481

1482 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1483 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1484 verifyItem(0, -350., 150., true);

1485 verifyItem(1, -200., 200., true);

1486 verifyItem(2, 0, 4000., false);

1487 QCOMPARE(lvwph->m_minYExtent, 0.);

1488 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1489 QCOMPARE(lvwph->m_clipItem->clip(), false);

1490 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1491 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1492 QCOMPARE(lvwph->contentY(), 400.);

1493 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1494 }

1495

1496 void testMaximizeVisibleAreaScrollDown()

1497 {

1498 changeContentY(250);

1499 bool res = lvwph->maximizeVisibleArea(1);

1500 QVERIFY(res);

1501 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1502

1503 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1504 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1505 verifyItem(0, -150., 150., true);

1506 verifyItem(1, 0., 200., false);

1507 verifyItem(2, 200, 350., false);

1508 verifyItem(3, 550, 350., true);

1509 QCOMPARE(lvwph->m_minYExtent, 0.);

1510 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1511 QCOMPARE(lvwph->m_clipItem->clip(), false);

1512 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1513 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1514 QCOMPARE(lvwph->contentY(), 200.);

1515 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1516 }

1517

1518 void testMaximizeVisibleAreaScrollDownBigElement()

1519 {

1520 model->setProperty(1, "size", 1000);

1521 changeContentY(1150);

1522 bool res = lvwph->maximizeVisibleArea(1);

1523 QVERIFY(res);

1524 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1525

1526 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1527 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1528 verifyItem(0, -458., 1000., false);

1529 verifyItem(1, 542., 350., true);

1530 QCOMPARE(lvwph->m_minYExtent, 525.);

1531 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1532 QCOMPARE(lvwph->m_clipItem->clip(), false);

1533 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1534 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1535 QCOMPARE(lvwph->contentY(), 658.);

1536 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1537 }

1538

1539 void testMaximizeVisibleAreaBigElementInTheMiddle()

1540 {

1541 model->setProperty(1, "size", 1000);

1542 changeContentY(650);

1543

1544 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1545 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1546 verifyItem(0, -450., 1000., false);

1547 verifyItem(1, 550., 350., true);

1548 QCOMPARE(lvwph->m_minYExtent, 525.);

1549 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1550 QCOMPARE(lvwph->m_clipItem->clip(), false);

1551 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1552 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1553 QCOMPARE(lvwph->contentY(), 650.);

1554 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1555

1556 bool res = lvwph->maximizeVisibleArea(1);

1557 QVERIFY(res);

1558 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1559

1560 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1561 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1562 verifyItem(0, -450., 1000., false);

1563 verifyItem(1, 550., 350., true);

1564 QCOMPARE(lvwph->m_minYExtent, 525.);

1565 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1566 QCOMPARE(lvwph->m_clipItem->clip(), false);

1567 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1568 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1569 QCOMPARE(lvwph->contentY(), 650.);

1570 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1571 }

1572

1573 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1574 {

1575 changeContentY(430);

1576 changeContentY(-30);

1577

1578 bool res = lvwph->maximizeVisibleArea(1);

1579 QVERIFY(res);

1580 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1581

1582 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1583 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1584 verifyItem(0, -150., 150., true);

1585 verifyItem(1, 0., 200., false);

1586 verifyItem(2, 200, 350., false);

1587 verifyItem(3, 550, 350., true);

1588 QCOMPARE(lvwph->m_minYExtent, 0.);

1589 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1590 QCOMPARE(lvwph->m_clipItem->clip(), false);

1591 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1592 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1593 QCOMPARE(lvwph->contentY(), 200.);

1594 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1595 }

1596

1597 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1598 {

1599 testMaximizeVisibleAreaTopWithHalfPageHeader();

1600

1601 changeContentY(-60);

1602 changeContentY(15);

1603

1604 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1605 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1606 verifyItem(0, -140., 150., false);

1607 verifyItem(1, 10., 200., false);

1608 verifyItem(2, 210, 350., false);

1609 verifyItem(3, 560, 350., true);

1610 QCOMPARE(lvwph->m_minYExtent, 0.);

1611 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1612 QCOMPARE(lvwph->m_clipItem->clip(), true);

1613 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1614 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1615 QCOMPARE(lvwph->contentY(), 155.);

1616 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1617 }

1618

1619 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1620 {

1621 changeContentY(430);

1622 changeContentY(-30);

1623

1624 bool res = lvwph->maximizeVisibleArea(3);

1625 QVERIFY(res);

1626 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1627

1628 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1629 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1630 verifyItem(0, -358., 200., true);

1631 verifyItem(1, -158., 350., false);

1632 verifyItem(2, 192, 350., false);

1633 verifyItem(3, 542, 350., true);

1634 QCOMPARE(lvwph->m_minYExtent, 162.5);

1635 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1636 QCOMPARE(lvwph->m_clipItem->clip(), false);

1637 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1638 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1639 QCOMPARE(lvwph->contentY(), 558.);

1640 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1641 }

1642

1643 void testMaximizeVisibleAreaWithItemResize()

1644 {

1645 model->setProperty(0, "size", 1000);

1646

1647 bool res = lvwph->maximizeVisibleArea(1);

1648 QVERIFY(res);

1649 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1650

1651 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1652 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1653 verifyItem(0, -658., 1000., false);

1654 verifyItem(1, 342., 200., false);

1655 verifyItem(2, 542, 350., true);

1656 QCOMPARE(lvwph->m_minYExtent, 0.);

1657 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1658 QCOMPARE(lvwph->m_clipItem->clip(), false);

1659 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1660 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1661 QCOMPARE(lvwph->contentY(), 708.);

1662 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1663 }

1664

1665 void addingRemoveItemsShouldNotChangeContentY()

1666 {

1667 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

1668 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1669 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1670

1671 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1672 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1673 verifyItem(0, 50., 150., false);

1674 QCOMPARE(lvwph->m_minYExtent, 0.);

1675 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1676 QCOMPARE(lvwph->m_clipItem->clip(), false);

1677 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1678 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1679 QCOMPARE(lvwph->contentY(), 0.);

1680 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1681

1682 QCOMPARE(spy.count(), 0);

1683 }

1684

1685 void testOvershootOnSameSize()

1686 {

1687 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1688 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1689 QCOMPARE(lvwph->m_minYExtent, 0.);

1690 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1691 QCOMPARE(lvwph->m_clipItem->clip(), false);

1692 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1693 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1694 QCOMPARE(lvwph->contentY(), 0.);

1695

1696 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1697 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1698 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1699 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1700 verifyItem(0, 50., 392., false);

1701 verifyItem(1, 442., 100., false);

1702

1703 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1704

1705 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1706 QTest::qWait(100);

1707 QTest::mouseMove(view, QPoint(0, 5));

1708 QTest::qWait(100);

1709 QTest::mouseMove(view, QPoint(0, 10));

1710 QTest::qWait(100);

1711 QTest::mouseMove(view, QPoint(0, 15));

1712 QTest::qWait(100);

1713 QTest::mouseMove(view, QPoint(0, 20));

1714 QTest::qWait(100);

1715 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1716 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1717 verifyItem(0, 55., 392., false);

1718 verifyItem(1, 447., 100., false);

1719 QCOMPARE(lvwph->m_minYExtent, 0.);

1720 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1721

1722 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1723 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1724 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1725 verifyItem(0, 50., 392., false);

1726 verifyItem(1, 442., 100., false);

1727 }

1728

1729 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1730 {

1731 model->setProperty(0, "size", 800);

1732 verifyItem(0, 50., 800., false);

1733

1734 lvwph->maximizeVisibleArea(0);

1735 QTRY_COMPARE(lvwph->contentY(), 50.);

1736

1737 changeContentY(10);

1738 QTRY_COMPARE(lvwph->contentY(), 60.);

1739

1740 lvwph->showHeader();

1741 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1742 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1743 QCOMPARE(lvwph->m_minYExtent, 50.);

1744 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1745 QCOMPARE(lvwph->m_clipItem->clip(), true);

1746 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1747 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1748 QCOMPARE(lvwph->contentY(), 10.);

1749 verifyItem(0, -60., 800., false);

1750 }

1751

1752 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1753 {

1754 model->setProperty(0, "size", 800);

1755 verifyItem(0, 50., 800., false);

1756

1757 lvwph->maximizeVisibleArea(0);

1758 QTRY_COMPARE(lvwph->contentY(), 50.);

1759

1760 changeContentY(-10);

1761 QTRY_COMPARE(lvwph->contentY(), 40.);

1762

1763 lvwph->showHeader();

1764 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1765 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1766 QCOMPARE(lvwph->m_minYExtent, 40.);

1767 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1768 QCOMPARE(lvwph->m_clipItem->clip(), true);

1769 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1770 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1771 QCOMPARE(lvwph->contentY(), 0.);

1772 verifyItem(0, -40., 800., false);

1773 }

1774

1775 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1776 {

1777 model->setProperty(0, "size", 800);

1778 verifyItem(0, 50., 800., false);

1779

1780 lvwph->maximizeVisibleArea(0);

1781 QTRY_COMPARE(lvwph->contentY(), 50.);

1782

1783 changeContentY(-10);

1784 QTRY_COMPARE(lvwph->contentY(), 40.);

1785 changeContentY(10);

1786 QTRY_COMPARE(lvwph->contentY(), 50.);

1787

1788 lvwph->showHeader();

1789 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1790

1791 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1792 QCOMPARE(lvwph->m_minYExtent, 50.);

1793 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1794 QCOMPARE(lvwph->m_clipItem->clip(), true);

1795 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1796 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1797 QCOMPARE(lvwph->contentY(), 0.);

1798 verifyItem(0, -50., 800., false);

1799 }

1800

1801 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1802 {

1803 model->setProperty(0, "size", 800);

1804 verifyItem(0, 50., 800., false);

1805

1806 lvwph->maximizeVisibleArea(0);

1807 QTRY_COMPARE(lvwph->contentY(), 50.);

1808

1809 changeContentY(10);

1810 QTRY_COMPARE(lvwph->contentY(), 60.);

1811 changeContentY(-10);

1812 QTRY_COMPARE(lvwph->contentY(), 50.);

1813

1814 lvwph->showHeader();

1815 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1816 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1817 QCOMPARE(lvwph->m_minYExtent, 40.);

1818 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1819 QCOMPARE(lvwph->m_clipItem->clip(), true);

1820 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1821 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1822 QCOMPARE(lvwph->contentY(), 10.);

1823 verifyItem(0, -50., 800., false);

1824 }

1825

1826 void testMaximizeVisibleAreaAndShowHeader()

1827 {

1828 model->setProperty(0, "size", 800);

1829 verifyItem(0, 50., 800., false);

1830

1831 lvwph->maximizeVisibleArea(0);

1832 QTRY_COMPARE(lvwph->contentY(), 50.);

1833

1834 lvwph->showHeader();

1835 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1836 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1837 QCOMPARE(lvwph->m_minYExtent, 50.);

1838 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1839 QCOMPARE(lvwph->m_clipItem->clip(), true);

1840 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1841 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1842 QCOMPARE(lvwph->contentY(), 0.);

1843 verifyItem(0, -50., 800., false);

1844 }

1845

1846 void positionAtBeginningEmpty()

1847 {

1848 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1849 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1850

1851 lvwph->positionAtBeginning();

1852 }

1853

1854 void testHeaderPositionBug1240118()

1855 {

1856 scrollToBottom();

1857 lvwph->showHeader();

1858 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1859 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1860 model->setProperty(3, "size", 10);

1861 model->setProperty(4, "size", 10);

1862 model->setProperty(5, "size", 10);

1863 model->setProperty(6, "size", 10);

1864 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1865 }

1866

1867 void testResizeRemoveInsertBug1279434()

1868 {

1869 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1870 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1871

1872 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1873 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1874 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1875 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1876 verifyItem(0, 50., 125., false);

1877 verifyItem(1, 175., 100., false);

1878

1879 lvwph->setContentY(175);

1880

1881 model->setProperty(1, "size", 4);

1882 model->setProperty(0, "size", 4);

1883

1884 model->setProperty(0, "size", 6);

1885

1886 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1887 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1888 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1889

1890 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1891 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1892 }

1893

1894 void testResizeScrolledBigItem()

1895 {

1896 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1897 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1898

1899 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1900 changeContentY(8000);

1901

1902 // Pretend the list is busy requesting some other index

1903 lvwph->m_asyncRequestedIndex = 4;

1904

1905 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1906 // This resize makes the item go outside the viewport so its deleted

1907 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1908 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1909 // On the next polish the item will be readded

1910 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1911 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1912 }

1913

1914 void testNoCacheBuffer()

1915 {

1916 lvwph->setCacheBuffer(0);

1917 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1918 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1919 verifyItem(0, 50., 150., false);

1920 verifyItem(1, 200., 200., false);

1921 verifyItem(2, 400., 350., false);

1922 QCOMPARE(lvwph->m_minYExtent, 0.);

1923 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1924 QCOMPARE(lvwph->m_clipItem->clip(), false);

1925 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1926 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1927 QCOMPARE(lvwph->contentY(), 0.);

1928 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1929 }

1930

1931 void testAllCacheBuffer()

1932 {

1933 lvwph->setCacheBuffer(std::numeric_limits<int>::max());

1934 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

1935 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1936 verifyItem(0, 50., 150., false);

1937 verifyItem(1, 200., 200., false);

1938 verifyItem(2, 400., 350., false);

1939 verifyItem(3, 750., 350., true);

1940 verifyItem(4, 1100., 350., true);

1941 verifyItem(5, 1450., 350., true);

1942 QCOMPARE(lvwph->m_minYExtent, 0.);

1943 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1944 QCOMPARE(lvwph->m_clipItem->clip(), false);

1945 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1946 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1947 QCOMPARE(lvwph->contentY(), 0.);

1948 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1949 }

1950

1951 void testFirstVisibleIndexRemove()

1952 {

1953 changeContentY(520);

1954 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1955 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1956

1957 // Remove 0 and 1, the previously visible index 2 will be 0 and visible

1958 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1959 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1960 }

1961

1962 void testBug1540490()

1963 {

1964 lvwph->header()->setImplicitHeight(150);

1965 verifyItem(0, 150., 150., false);

1966

1967 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1968 model->setProperty(0, "size", 400);

1969 model->setProperty(1, "size", 600);

1970 model->setProperty(2, "size", 300);

1971

1972 scrollToBottom();

1973 changeContentY(-200);

1974

1975 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 2));

1976 model->setProperty(0, "size", 100);

1977 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1));

1978 lvwph->header()->setImplicitHeight(50);

1979 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 200));

1980

1981 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1982 verifyItem(0, 50., 200., false);

1983 }

1984

1985 void testBug1569976()

1986 {

1987 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1988

1989 for (int i = 0; i < 10; ++i) {

1990 scrollToBottom();

1991 lvwph->showHeader();

1992 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1993 scrollToTop();

1994 }

1995 verifyItem(0, 50., 150., false);

1996 verifyItem(1, 200., 200., false);

1997 verifyItem(2, 400., 350., false);

1998 }

1999

2000private:

2001 QQuickView *view;

2002 ListViewWithPageHeader *lvwph;

2003 QQmlListModel *model;

2004 QQmlComponent *otherDelegate;

2005};

2006

2007QTEST_MAIN(ListViewWithPageHeaderTest)

2008

2009#include "listviewwithpageheadertest.moc"