tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 631e710 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp

1468 lines 57 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 <QtTestGui>

23#include <private/qquicklistmodel_p.h>

24#include <private/qquickanimation_p.h>

25#include <private/qquickitem_p.h>

27class ListViewWithPageHeaderTest : public QObject

28{

29 Q_OBJECT

31private:

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

33 {

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

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

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

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

38 }

40 void changeContentY(qreal change)

41 {

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

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

44 const qreal jump = 25;

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

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

47 QTest::qWait(1);

48 }

49 } else {

50 const qreal jump = -25;

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

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

53 QTest::qWait(1);

54 }

55 }

56 lvwph->setContentY(dest);

57 QTest::qWait(1);

58 }

60 void scrollToTop()

61 {

62 const qreal jump = -25;

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

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

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

66 } else {

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

68 }

69 QTest::qWait(1);

70 }

71 }

73 void scrollToBottom()

74 {

75 const qreal jump = 25;

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

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

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

79 } else {

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

81 }

82 QTest::qWait(1);

83 }

84 }

86 void verifyInitialTopPosition()

87 {

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

89 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

101 }

102

103private Q_SLOTS:

104

105 void initTestCase()

106 {

107 }

108

109 void init()

110 {

111 view = new QQuickView();

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

113 view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test.qml"));

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

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

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

117 QVERIFY(lvwph);

118 QVERIFY(model);

119 QVERIFY(otherDelegate);

120 view->show();

121 QTest::qWaitForWindowExposed(view);

122

123 verifyInitialTopPosition();

124 }

125

126 void cleanup()

127 {

128 delete view;

129 }

130

131 void testCreationDeletion()

132 {

133 // Nothing, init/cleanup already tests this

134 }

135

136 void testDrag1PixelUp()

137 {

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

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

140 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

152 }

153

154 void testHeaderDetachDragDown()

155 {

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

157 QTest::qWait(100);

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

159 QTest::qWait(100);

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

161 QTest::qWait(100);

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

163 QTest::qWait(100);

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

165 QTest::qWait(100);

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

167 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

179

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

181

182 verifyInitialTopPosition();

183 }

184

185 void testDrag375PixelUp()

186 {

187 changeContentY(375);

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

189 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

202 }

203

204 void testDrag520PixelUp()

205 {

206 changeContentY(520);

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

208 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

219 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

226 }

227

228 void testDragHeaderUpThenShow()

229 {

230 changeContentY(120);

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

232 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

244

245 changeContentY(-30);

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

247 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

259 }

260

261 void testDragHeaderUpThenShowWithoutHidingTotally()

262 {

263 changeContentY(10);

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

265 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

277

278 changeContentY(-1);

279

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

281 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

293 }

294

295 void testPositionAtBeginningIndex0Visible()

296 {

297 changeContentY(375);

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

299 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

312

313 lvwph->positionAtBeginning();

314

315 verifyInitialTopPosition();

316 }

317

318 void testPositionAtBeginningIndex0NotVisible()

319 {

320 changeContentY(520);

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

322 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

327 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

334

335 lvwph->positionAtBeginning();

336

337 verifyInitialTopPosition();

338 }

339

340 void testIndex0GrowOnScreen()

341 {

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

343

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

345 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

356 }

357

358 void testIndex0GrowOffScreen()

359 {

360 changeContentY(375);

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

362 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

375

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

377

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

379 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

392

393 scrollToTop();

394

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

396 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

407

408 changeContentY(30);

409

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

411 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

422 }

423

424 void testIndex0GrowNotCreated()

425 {

426 changeContentY(520);

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

428 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

433 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

440

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

442

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

444 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

449 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

456

457 scrollToTop();

458

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

460 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

471 }

472

473 void testShowHideShowHeaderAtBottom()

474 {

475 scrollToBottom();

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

477 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

488

489 changeContentY(-30);

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(), true);

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

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

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

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

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(), false);

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

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

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

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

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(), true);

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

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

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

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

530 }

531

532 void testChangeDelegateAtBottom()

533 {

534 scrollToBottom();

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

536 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

547

548 lvwph->setDelegate(otherDelegate);

549

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

551 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

565 }

566

567 void testGrowHeaderAtTop()

568 {

569 lvwph->m_headerItem->setHeight(100);

570

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

572 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

574 verifyItem(1, 250., 200., false);

575 verifyItem(2, 450., 350., false);

576 verifyItem(3, 800., 350., true);

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

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

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

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

581 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

584 }

585

586 void testGrowHeaderAtBottom()

587 {

588 scrollToBottom();

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

590 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

601

602 lvwph->m_headerItem->setHeight(100);

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, 400.);

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

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

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

613 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

616

617 changeContentY(-30);

618

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

620 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

627 QCOMPARE(lvwph->m_headerItem->y(), 1158.);

628 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

631

632

633 scrollToTop();

634

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

636 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

638 verifyItem(1, 250., 200., false);

639 verifyItem(2, 450., 350., false);

640 verifyItem(3, 800., 350., true);

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

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

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

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

645 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

648 }

649

650 void testGrowHeaderPartlyShown()

651 {

652 scrollToBottom();

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

654 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

665

666 changeContentY(-30);

667

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

669 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

680

681 lvwph->m_headerItem->setHeight(100);

682

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

684 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

689 QCOMPARE(lvwph->m_clipItem->y(), 1308.);

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

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

692 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

694 QCOMPARE(lvwph->m_headerItemShownHeight, 80.);

695

696 scrollToTop();

697

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

699 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

701 verifyItem(1, 250., 200., false);

702 verifyItem(2, 450., 350., false);

703 verifyItem(3, 800., 350., true);

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

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

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

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

708 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

711 }

712

713 void testShrinkHeaderMoreThanPartlyShown()

714 {

715 scrollToBottom();

716 lvwph->m_headerItem->setHeight(100);

717 changeContentY(-30);

718

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

720 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

724 QCOMPARE(lvwph->m_minYExtent, 400.);

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

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

727 QCOMPARE(lvwph->m_headerItem->y(), 1158.);

728 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

731

732 lvwph->m_headerItem->setHeight(50);

733

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

735 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

742 QCOMPARE(lvwph->m_headerItem->y(), 1158.);

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

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

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

746 QTRY_VERIFY(lvwph->isAtYEnd());

747

748 scrollToTop();

749

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

751 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

756 QCOMPARE(lvwph->m_minYExtent, 30.);

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

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

759 QCOMPARE(lvwph->m_headerItem->y(), -30.);

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

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

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

763 }

764

765 void testSetEmptyHeaderAtTop()

766 {

767 lvwph->setHeader(nullptr);

768

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

770 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

781 }

782

783 void testSetEmptyHeaderAtBottom()

784 {

785 scrollToBottom();

786 lvwph->setHeader(nullptr);

787

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

789 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

799

800 scrollToTop();

801

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

803 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

814 }

815

816 void testSetEmptyHeaderWhenPartlyShownClipped()

817 {

818 scrollToBottom();

819 changeContentY(-30);

820 lvwph->setHeader(nullptr);

821

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

823 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

833 QTRY_VERIFY(lvwph->isAtYEnd());

834

835 scrollToTop();

836

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

838 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

849 }

850

851 void testSetEmptyHeaderWhenPartlyShownNotClipped()

852 {

853 changeContentY(30);

854 lvwph->setHeader(nullptr);

855

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

857 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

868 }

869

870 void testSetNullDelegate()

871 {

872 lvwph->setDelegate(nullptr);

873

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

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

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

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

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

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

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

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

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

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

884 QVERIFY(lvwph->isAtYBeginning());

885 QVERIFY(lvwph->isAtYEnd());

886 }

887

888 void testInsertItems()

889 {

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

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

892

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

894 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

907 }

908

909 void testInsertItemsOnNotShownPosition()

910 {

911 changeContentY(700);

912

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

914 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

926

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

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

929

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

931 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

943

944 scrollToTop();

945

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

947 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

960 }

961

962 void testInsertItemsAtEndOfViewport()

963 {

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

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

966

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

968 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

980 }

981

982 void testInsertItemsBeforeValidIndex()

983 {

984 changeContentY(520);

985

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

987 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

992 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

999

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

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

1002

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

1004 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

1009 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

1016 }

1017

1018 void testInsertItemsBeforeViewport()

1019 {

1020 changeContentY(375);

1021

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

1023 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1036

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

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

1039

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

1041 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1054

1055 scrollToTop();

1056

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

1058 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1071 }

1072

1073 void testInsertItemsAtBottom()

1074 {

1075 scrollToBottom();

1076

1077 QVERIFY(lvwph->isAtYEnd());

1078

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

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

1081

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

1083 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

1097

1098 scrollToBottom();

1099

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

1101 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1113 QVERIFY(lvwph->isAtYEnd());

1114 }

1115

1116 void testInsertItemAtTop()

1117 {

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

1119

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

1121 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1133 QVERIFY(lvwph->isAtYBeginning());

1134 }

1135

1136 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1137 {

1138 scrollToBottom();

1139

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

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

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

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

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

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

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

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

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

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

1150

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

1152 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

1163

1164 changeContentY(-1700);

1165

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

1167 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1187 }

1188

1189 void testRemoveItemsAtTop()

1190 {

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

1192

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

1194 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1205 QVERIFY(lvwph->isAtYBeginning());

1206 }

1207

1208 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1209 {

1210 scrollToBottom();

1211

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

1213

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

1215 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1226 }

1227

1228 void testRemoveLastItemsAtBottom()

1229 {

1230 scrollToBottom();

1231

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

1233

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

1235 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1246 }

1247

1248 void testRemoveItemOutOfViewport()

1249 {

1250 changeContentY(520);

1251

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

1253 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1258 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1265

1266

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

1268

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

1270 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1282 }

1283

1284 void testMoveFirstItems()

1285 {

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

1287

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

1289 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1301

1302 }

1303

1304 void testMoveFirstOutOfVisibleItems()

1305 {

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

1307

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

1309 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1320

1321 }

1322

1323 void testMoveFirstToLastAtBottom()

1324 {

1325 scrollToBottom();

1326

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

1328 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

1336 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1337 QCOMPARE(lvwph->contentY(), 1258.);

1338 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1339

1340 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1341

1342 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1343 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1344 verifyItem(0, -508., 350., true);

1345 verifyItem(1, -158, 350., false);

1346 verifyItem(2, 192, 350., false);

1347 verifyItem(3, 542, 150., true);

1348 QCOMPARE(lvwph->m_minYExtent, -100.);

1349 QCOMPARE(lvwph->m_clipItem->y(), 1258.);

1350 QCOMPARE(lvwph->m_clipItem->clip(), false);

1351 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1352 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1353 QCOMPARE(lvwph->contentY(), 1258.);

1354 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1355 QVERIFY(!lvwph->isAtYEnd());

1356 }

1357

1358 void testChangeSizeVisibleItemNotOnViewport()

1359 {

1360 changeContentY(440);

1361

1362 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1363 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1364 verifyItem(0, -390., 150., true);

1365 verifyItem(1, -240., 200., true);

1366 verifyItem(2, -40, 350., false);

1367 verifyItem(3, 310, 350., false);

1368 verifyItem(4, 660, 350., true);

1369 QCOMPARE(lvwph->m_minYExtent, 0.);

1370 QCOMPARE(lvwph->m_clipItem->y(), 440.);

1371 QCOMPARE(lvwph->m_clipItem->clip(), false);

1372 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1373 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1374 QCOMPARE(lvwph->contentY(), 440.);

1375 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1376

1377 model->setProperty(1, "size", 100);

1378

1379 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1380 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1381 verifyItem(0, -290., 150., true);

1382 verifyItem(1, -140., 100., true);

1383 verifyItem(2, -40, 350., false);

1384 verifyItem(3, 310, 350., false);

1385 verifyItem(4, 660, 350., true);

1386 QCOMPARE(lvwph->m_minYExtent, -100.);

1387 QCOMPARE(lvwph->m_clipItem->y(), 440.);

1388 QCOMPARE(lvwph->m_clipItem->clip(), false);

1389 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1390 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1391 QCOMPARE(lvwph->contentY(), 440.);

1392 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1393 }

1394

1395 void testShowHeaderCloseToTheTop()

1396 {

1397 changeContentY(375);

1398

1399 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1400 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1401 verifyItem(0, -325., 150., true);

1402 verifyItem(1, -175, 200., false);

1403 verifyItem(2, 25, 350., false);

1404 verifyItem(3, 375, 350., false);

1405 verifyItem(4, 725, 350., true);

1406 QCOMPARE(lvwph->m_minYExtent, 0.);

1407 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1408 QCOMPARE(lvwph->m_clipItem->clip(), false);

1409 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1410 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1411 QCOMPARE(lvwph->contentY(), 375.);

1412 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1413

1414 lvwph->showHeader();

1415

1416 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1417 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1418 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1419 verifyItem(0, -375., 150., true);

1420 verifyItem(1, -225, 200., true);

1421 verifyItem(2, -25, 350., false);

1422 verifyItem(3, 325, 350., false);

1423 verifyItem(4, 675, 350., true);

1424 QCOMPARE(lvwph->m_minYExtent, 50.);

1425 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1426 QCOMPARE(lvwph->m_clipItem->clip(), true);

1427 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1428 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1429 QCOMPARE(lvwph->contentY(), 325.);

1430 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;

1431

1432 scrollToTop();

1433

1434 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1435 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1436 verifyItem(0, 50., 150., false);

1437 verifyItem(1, 200., 200., false);

1438 verifyItem(2, 400., 350., false);

1439 verifyItem(3, 750., 350., true);

1440 QCOMPARE(lvwph->m_minYExtent, 50.);

1441 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1442 QCOMPARE(lvwph->m_clipItem->clip(), false);

1443 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1444 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1445 QCOMPARE(lvwph->contentY(), -50.);

1446 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1447 }

1448

1449 void testShowHeaderAtBottom()

1450 {

1451 scrollToBottom();

1452

1453 lvwph->showHeader();

1454

1455 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1456 QVERIFY (lvwph->isAtYEnd());

1457 }

1458

1459private:

1460 QQuickView *view;

1461 ListViewWithPageHeader *lvwph;

1462 QQuickListModel *model;

1463 QQmlComponent *otherDelegate;

1464};

1465

1466QTEST_MAIN(ListViewWithPageHeaderTest)

1467

1468#include "listviewwithpageheadertest.moc"