tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on c42e54e help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

1967 lines 75 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QSignalSpy>

23#include <QtTestGui>

24#pragma GCC diagnostic push

25#pragma GCC diagnostic ignored "-pedantic"

26#include <private/qqmllistmodel_p.h>

27#include <private/qquickanimation_p.h>

28#include <private/qquickitem_p.h>

29#pragma GCC diagnostic pop

31#include <limits>

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

34// particullary making sure that lost items are culled

35// and then removed in the next updatePolish cycle

37class ListViewWithPageHeaderTest : public QObject

38{

39 Q_OBJECT

41private:

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

43 {

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

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

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

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

48 }

50 void changeContentY(qreal change)

51 {

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

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

54 const qreal jump = 25;

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

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

57 QTest::qWait(1);

58 }

59 } else {

60 const qreal jump = -25;

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

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

63 QTest::qWait(1);

64 }

65 }

66 lvwph->setContentY(dest);

67 QTest::qWait(1);

68 }

70 void scrollToTop()

71 {

72 const qreal jump = -25;

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

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

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

76 } else {

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

78 }

79 QTest::qWait(1);

80 }

81 }

83 void scrollToBottom()

84 {

85 const qreal jump = 25;

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

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

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

89 } else {

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

91 }

92 QTest::qWait(1);

93 }

94 }

96 void verifyInitialTopPosition()

97 {

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

99 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

111 }

112

113private Q_SLOTS:

114

115 void initTestCase()

116 {

117 }

118

119 void init()

120 {

121 view = new QQuickView();

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

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

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

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

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

127 QVERIFY(lvwph);

128 QVERIFY(model);

129 QVERIFY(otherDelegate);

130 view->show();

131 QTest::qWaitForWindowExposed(view);

132

133 verifyInitialTopPosition();

134 }

135

136 void cleanup()

137 {

138 delete view;

139 }

140

141 void testCreationDeletion()

142 {

143 // Nothing, init/cleanup already tests this

144 }

145

146 void testDrag1PixelUp()

147 {

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

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

150 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

162 }

163

164 void testHeaderDetachDragDown()

165 {

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

167 QTest::qWait(100);

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

189

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

191

192 verifyInitialTopPosition();

193 }

194

195 void testDrag375PixelUp()

196 {

197 changeContentY(375);

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

199 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

212 }

213

214 void testDrag520PixelUp()

215 {

216 changeContentY(520);

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

218 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

229 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

236 }

237

238 void testDragHeaderUpThenShow()

239 {

240 changeContentY(120);

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

242 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

254

255 changeContentY(-30);

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

257 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

269 }

270

271 void testDragHeaderUpThenShowWithoutHidingTotally()

272 {

273 changeContentY(10);

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

275 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

287

288 changeContentY(-1);

289

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

291 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

303 }

304

305 void testPositionAtBeginningIndex0Visible()

306 {

307 changeContentY(375);

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

309 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

322

323 lvwph->positionAtBeginning();

324

325 verifyInitialTopPosition();

326 }

327

328 void testPositionAtBeginningIndex0NotVisible()

329 {

330 changeContentY(520);

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

332 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

337 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

344

345 lvwph->positionAtBeginning();

346

347 verifyInitialTopPosition();

348 }

349

350 void testIndex0GrowOnScreen()

351 {

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

353

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

355 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

366 }

367

368 void testIndex0GrowOffScreen()

369 {

370 changeContentY(375);

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

372 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

385

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

387

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

389 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

402

403 scrollToTop();

404

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

406 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

417

418 changeContentY(30);

419

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

421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

432 }

433

434 void testIndex0GrowNotCreated()

435 {

436 changeContentY(520);

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

438 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

443 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

450

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

452

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

454 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

459 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

466

467 scrollToTop();

468

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

470 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

481 }

482

483 void testShowHideShowHeaderAtBottom()

484 {

485 scrollToBottom();

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

487 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

498

499 changeContentY(-30);

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

501 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

512

513 changeContentY(30);

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

515 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

526

527 changeContentY(-30);

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

529 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

540 }

541

542 void testChangeDelegateAtBottom()

543 {

544 scrollToBottom();

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

546 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

557

558 lvwph->setDelegate(otherDelegate);

559

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

561 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

575 }

576

577 void testSetEmptyHeaderAtTop()

578 {

579 lvwph->setHeader(nullptr);

580

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

582 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

593 }

594

595 void testSetEmptyHeaderAtBottom()

596 {

597 scrollToBottom();

598 lvwph->setHeader(nullptr);

599

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

601 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

611

612 scrollToTop();

613

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

615 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

626 }

627

628 void testSetEmptyHeaderWhenPartlyShownClipped()

629 {

630 scrollToBottom();

631 changeContentY(-30);

632 lvwph->setHeader(nullptr);

633

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

635 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

645 QTRY_VERIFY(lvwph->isAtYEnd());

646

647 scrollToTop();

648

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

650 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

661 }

662

663 void testSetEmptyHeaderWhenPartlyShownNotClipped()

664 {

665 changeContentY(30);

666 lvwph->setHeader(nullptr);

667

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

669 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

680 }

681

682 void testSetNullDelegate()

683 {

684 lvwph->setDelegate(nullptr);

685

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

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

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

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

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

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

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

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

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

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

696 QVERIFY(lvwph->isAtYBeginning());

697 QVERIFY(lvwph->isAtYEnd());

698 }

699

700 void testInsertItems()

701 {

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

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

704

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

706 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

719 }

720

721 void testInsertItemsOnNotShownPosition()

722 {

723 changeContentY(700);

724

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

726 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

738

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

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

741

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

743 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

755

756 scrollToTop();

757

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

759 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

772 }

773

774 void testInsertItemsAtEndOfViewport()

775 {

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

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

778

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

780 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

792 }

793

794 void testInsertItemsBeforeValidIndex()

795 {

796 changeContentY(520);

797

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

799 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

804 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

811

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

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

814

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

816 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

821 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

828 }

829

830 void testInsertItemsBeforeViewport()

831 {

832 changeContentY(375);

833

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

835 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

848

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

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

851

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

853 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

866

867 scrollToTop();

868

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

870 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

883 }

884

885 void testInsertItemsAtBottom()

886 {

887 scrollToBottom();

888

889 QVERIFY(lvwph->isAtYEnd());

890

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

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

893

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

895 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

909

910 scrollToBottom();

911

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

913 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

925 QVERIFY(lvwph->isAtYEnd());

926 }

927

928 void testInsertItemAtTop()

929 {

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

931

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

933 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

945 QVERIFY(lvwph->isAtYBeginning());

946 }

947

948 void testInsertItem10SmallItemsAtTopWhenAtBottom()

949 {

950 scrollToBottom();

951

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

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

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

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

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

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

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

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

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

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

962

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

964 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

975

976 changeContentY(-800);

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

978 changeContentY(-400);

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

980 changeContentY(-200);

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

982 changeContentY(-300);

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

984

985 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1005 }

1006

1007 void testInsertToEmpty()

1008 {

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

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

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

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

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

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

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

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

1017

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

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

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

1021 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1024 }

1025

1026 void testRemoveItemsAtTop()

1027 {

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

1029

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

1031 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1042 QVERIFY(lvwph->isAtYBeginning());

1043 }

1044

1045 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1046 {

1047 scrollToBottom();

1048

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

1050

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

1052 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1063 }

1064

1065 void testRemoveLastItemsAtBottom()

1066 {

1067 scrollToBottom();

1068

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

1070

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

1072 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1083 }

1084

1085 void testRemoveItemOutOfViewport()

1086 {

1087 changeContentY(520);

1088

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

1090 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1095 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1102

1103

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

1105

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

1107 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1119 }

1120

1121 void testMoveFirstItems()

1122 {

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

1124

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

1126 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1138

1139 }

1140

1141 void testMoveFirstOutOfVisibleItems()

1142 {

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

1144

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

1146 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1157

1158 }

1159

1160 void testMoveFirstToLastAtBottom()

1161 {

1162 scrollToBottom();

1163

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

1165 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1176

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

1178

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

1180 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1193 }

1194

1195 void testChangeSizeVisibleItemNotOnViewport()

1196 {

1197 changeContentY(440);

1198

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

1200 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1213

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

1215

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

1217 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1230 }

1231

1232 void testShowHeaderCloseToTheTop()

1233 {

1234 changeContentY(375);

1235

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

1237 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1250

1251 lvwph->showHeader();

1252

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

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

1255 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1258 verifyItem(2, -25, 350., false);

1259 verifyItem(3, 325, 350., false);

1260 verifyItem(4, 675, 350., true);

1261 QCOMPARE(lvwph->m_minYExtent, 50.);

1262 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1263 QCOMPARE(lvwph->m_clipItem->clip(), true);

1264 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1265 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1266 QCOMPARE(lvwph->contentY(), 325.);

1267 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;

1268

1269 scrollToTop();

1270

1271 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1272 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1273 verifyItem(0, 50., 150., false);

1274 verifyItem(1, 200., 200., false);

1275 verifyItem(2, 400., 350., false);

1276 verifyItem(3, 750., 350., true);

1277 QCOMPARE(lvwph->m_minYExtent, 50.);

1278 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1279 QCOMPARE(lvwph->m_clipItem->clip(), false);

1280 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1281 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1282 QCOMPARE(lvwph->contentY(), -50.);

1283 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1284 }

1285

1286 void testShowHeaderHalfShown()

1287 {

1288 changeContentY(20);

1289

1290 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1291 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1292 verifyItem(0, 30., 150., false);

1293 verifyItem(1, 180, 200., false);

1294 verifyItem(2, 380, 350., false);

1295 verifyItem(3, 730, 350., true);

1296 QCOMPARE(lvwph->m_minYExtent, 0.);

1297 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1298 QCOMPARE(lvwph->m_clipItem->clip(), false);

1299 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1300 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1301 QCOMPARE(lvwph->contentY(), 20.);

1302 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1303

1304 lvwph->showHeader();

1305

1306 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1307 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1308 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1309 verifyItem(0, -20., 150., false);

1310 verifyItem(1, 130, 200., false);

1311 verifyItem(2, 330, 350., false);

1312 verifyItem(3, 680, 350., true);

1313 QCOMPARE(lvwph->m_minYExtent, 20.);

1314 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1315 QCOMPARE(lvwph->m_clipItem->clip(), true);

1316 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1317 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1318 QCOMPARE(lvwph->contentY(), 0.);

1319 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1320

1321 scrollToTop();

1322

1323 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1324 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1325 verifyItem(0, 50., 150., false);

1326 verifyItem(1, 200., 200., false);

1327 verifyItem(2, 400., 350., false);

1328 verifyItem(3, 750, 350., true);

1329 QCOMPARE(lvwph->m_minYExtent, 20.);

1330 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1331 QCOMPARE(lvwph->m_clipItem->clip(), false);

1332 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1333 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1334 QCOMPARE(lvwph->contentY(), -20.);

1335 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1336 }

1337

1338 void testShowHeaderAtBottom()

1339 {

1340 scrollToBottom();

1341

1342 lvwph->showHeader();

1343

1344 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1345 QTRY_VERIFY (lvwph->isAtYEnd());

1346 }

1347

1348 void growWindow()

1349 {

1350 view->rootObject()->setHeight(850);

1351

1352 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1353 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1354 verifyItem(0, 50., 150., false);

1355 verifyItem(1, 200., 200., false);

1356 verifyItem(2, 400., 350., false);

1357 verifyItem(3, 750., 350., false);

1358 verifyItem(4, 1100., 350., true);

1359 QCOMPARE(lvwph->m_minYExtent, 0.);

1360 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1361 QCOMPARE(lvwph->m_clipItem->clip(), false);

1362 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1363 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1364 QCOMPARE(lvwph->contentY(), 0.);

1365 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1366 }

1367

1368 void growWindowAtBottom()

1369 {

1370 scrollToBottom();

1371

1372 view->rootObject()->setHeight(850);

1373

1374 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1375 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1376 verifyItem(0, -550., 350., true);

1377 verifyItem(1, -200., 350., false);

1378 verifyItem(2, 150, 350., false);

1379 verifyItem(3, 500, 350., false);

1380 QCOMPARE(lvwph->m_minYExtent, 350.);

1381 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1382 QCOMPARE(lvwph->m_clipItem->clip(), false);

1383 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1384 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1385 QCOMPARE(lvwph->contentY(), 950.);

1386 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1387 }

1388

1389 void testCrashShowHeaderWithNoHeader()

1390 {

1391 lvwph->setHeader(nullptr);

1392 lvwph->showHeader();

1393 }

1394

1395 void testCullOnBottomEdge()

1396 {

1397 changeContentY(200);

1398

1399 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1400 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1401 verifyItem(0, -150., 150., true);

1402 verifyItem(1, 0., 200., false);

1403 verifyItem(2, 200., 350., false);

1404 verifyItem(3, 550., 350., true);

1405 QCOMPARE(lvwph->m_minYExtent, 0.);

1406 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1407 QCOMPARE(lvwph->m_clipItem->clip(), false);

1408 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1409 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1410 QCOMPARE(lvwph->contentY(), 200.);

1411 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1412 }

1413

1414 void testMaximizeVisibleArea()

1415 {

1416 bool res = lvwph->maximizeVisibleArea(2);

1417 QVERIFY(res);

1418 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1419

1420 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1422 verifyItem(0, -158., 150., true);

1423 verifyItem(1, -8., 200., false);

1424 verifyItem(2, 192, 350., false);

1425 verifyItem(3, 542, 350., true);

1426 QCOMPARE(lvwph->m_minYExtent, 0.);

1427 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1428 QCOMPARE(lvwph->m_clipItem->clip(), false);

1429 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1430 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1431 QCOMPARE(lvwph->contentY(), 208.);

1432 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1433 }

1434

1435 void testMaximizeVisibleAreaVisibleItems()

1436 {

1437 bool res = lvwph->maximizeVisibleArea(0);

1438 QVERIFY(res);

1439 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1440

1441 verifyInitialTopPosition();

1442

1443 res = lvwph->maximizeVisibleArea(1);

1444 QVERIFY(res);

1445 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1446

1447 verifyInitialTopPosition();

1448 }

1449

1450 void testMaximizeVisibleAreaInvalidIndexes()

1451 {

1452 bool res = lvwph->maximizeVisibleArea(-1);

1453 QVERIFY(!res);

1454 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1455

1456 verifyInitialTopPosition();

1457

1458 res = lvwph->maximizeVisibleArea(1000);

1459 QVERIFY(!res);

1460 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1461

1462 verifyInitialTopPosition();

1463

1464 res = lvwph->maximizeVisibleArea(4);

1465 QVERIFY(!res);

1466 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1467

1468 verifyInitialTopPosition();

1469 }

1470

1471 void testMaximizeVisibleAreaBigElement()

1472 {

1473 model->setProperty(2, "size", 4000);

1474 bool res = lvwph->maximizeVisibleArea(2);

1475 QVERIFY(res);

1476 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1477

1478 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1479 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1480 verifyItem(0, -350., 150., true);

1481 verifyItem(1, -200., 200., true);

1482 verifyItem(2, 0, 4000., false);

1483 QCOMPARE(lvwph->m_minYExtent, 0.);

1484 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1485 QCOMPARE(lvwph->m_clipItem->clip(), false);

1486 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1487 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1488 QCOMPARE(lvwph->contentY(), 400.);

1489 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1490 }

1491

1492 void testMaximizeVisibleAreaScrollDown()

1493 {

1494 changeContentY(250);

1495 bool res = lvwph->maximizeVisibleArea(1);

1496 QVERIFY(res);

1497 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1498

1499 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1500 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1501 verifyItem(0, -150., 150., true);

1502 verifyItem(1, 0., 200., false);

1503 verifyItem(2, 200, 350., false);

1504 verifyItem(3, 550, 350., true);

1505 QCOMPARE(lvwph->m_minYExtent, 0.);

1506 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1507 QCOMPARE(lvwph->m_clipItem->clip(), false);

1508 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1509 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1510 QCOMPARE(lvwph->contentY(), 200.);

1511 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1512 }

1513

1514 void testMaximizeVisibleAreaScrollDownBigElement()

1515 {

1516 model->setProperty(1, "size", 1000);

1517 changeContentY(1150);

1518 bool res = lvwph->maximizeVisibleArea(1);

1519 QVERIFY(res);

1520 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1521

1522 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1523 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1524 verifyItem(0, -458., 1000., false);

1525 verifyItem(1, 542., 350., true);

1526 QCOMPARE(lvwph->m_minYExtent, 525.);

1527 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1528 QCOMPARE(lvwph->m_clipItem->clip(), false);

1529 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1530 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1531 QCOMPARE(lvwph->contentY(), 658.);

1532 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1533 }

1534

1535 void testMaximizeVisibleAreaBigElementInTheMiddle()

1536 {

1537 model->setProperty(1, "size", 1000);

1538 changeContentY(650);

1539

1540 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1541 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1542 verifyItem(0, -450., 1000., false);

1543 verifyItem(1, 550., 350., true);

1544 QCOMPARE(lvwph->m_minYExtent, 525.);

1545 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1546 QCOMPARE(lvwph->m_clipItem->clip(), false);

1547 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1548 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1549 QCOMPARE(lvwph->contentY(), 650.);

1550 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1551

1552 bool res = lvwph->maximizeVisibleArea(1);

1553 QVERIFY(res);

1554 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1555

1556 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1557 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1558 verifyItem(0, -450., 1000., false);

1559 verifyItem(1, 550., 350., true);

1560 QCOMPARE(lvwph->m_minYExtent, 525.);

1561 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1562 QCOMPARE(lvwph->m_clipItem->clip(), false);

1563 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1564 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1565 QCOMPARE(lvwph->contentY(), 650.);

1566 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1567 }

1568

1569 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1570 {

1571 changeContentY(430);

1572 changeContentY(-30);

1573

1574 bool res = lvwph->maximizeVisibleArea(1);

1575 QVERIFY(res);

1576 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1577

1578 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1579 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1580 verifyItem(0, -150., 150., true);

1581 verifyItem(1, 0., 200., false);

1582 verifyItem(2, 200, 350., false);

1583 verifyItem(3, 550, 350., true);

1584 QCOMPARE(lvwph->m_minYExtent, 0.);

1585 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1586 QCOMPARE(lvwph->m_clipItem->clip(), false);

1587 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1588 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1589 QCOMPARE(lvwph->contentY(), 200.);

1590 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1591 }

1592

1593 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1594 {

1595 testMaximizeVisibleAreaTopWithHalfPageHeader();

1596

1597 changeContentY(-60);

1598 changeContentY(15);

1599

1600 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1601 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1602 verifyItem(0, -140., 150., false);

1603 verifyItem(1, 10., 200., false);

1604 verifyItem(2, 210, 350., false);

1605 verifyItem(3, 560, 350., true);

1606 QCOMPARE(lvwph->m_minYExtent, 0.);

1607 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1608 QCOMPARE(lvwph->m_clipItem->clip(), true);

1609 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1610 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1611 QCOMPARE(lvwph->contentY(), 155.);

1612 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1613 }

1614

1615 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1616 {

1617 changeContentY(430);

1618 changeContentY(-30);

1619

1620 bool res = lvwph->maximizeVisibleArea(3);

1621 QVERIFY(res);

1622 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1623

1624 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1625 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1626 verifyItem(0, -358., 200., true);

1627 verifyItem(1, -158., 350., false);

1628 verifyItem(2, 192, 350., false);

1629 verifyItem(3, 542, 350., true);

1630 QCOMPARE(lvwph->m_minYExtent, 162.5);

1631 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1632 QCOMPARE(lvwph->m_clipItem->clip(), false);

1633 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1634 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1635 QCOMPARE(lvwph->contentY(), 558.);

1636 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1637 }

1638

1639 void testMaximizeVisibleAreaWithItemResize()

1640 {

1641 model->setProperty(0, "size", 1000);

1642

1643 bool res = lvwph->maximizeVisibleArea(1);

1644 QVERIFY(res);

1645 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1646

1647 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1648 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1649 verifyItem(0, -658., 1000., false);

1650 verifyItem(1, 342., 200., false);

1651 verifyItem(2, 542, 350., true);

1652 QCOMPARE(lvwph->m_minYExtent, 0.);

1653 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1654 QCOMPARE(lvwph->m_clipItem->clip(), false);

1655 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1656 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1657 QCOMPARE(lvwph->contentY(), 708.);

1658 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1659 }

1660

1661 void addingRemoveItemsShouldNotChangeContentY()

1662 {

1663 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

1664 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1665 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1666

1667 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1668 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1669 verifyItem(0, 50., 150., false);

1670 QCOMPARE(lvwph->m_minYExtent, 0.);

1671 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1672 QCOMPARE(lvwph->m_clipItem->clip(), false);

1673 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1674 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1675 QCOMPARE(lvwph->contentY(), 0.);

1676 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1677

1678 QCOMPARE(spy.count(), 0);

1679 }

1680

1681 void testOvershootOnSameSize()

1682 {

1683 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1684 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1685 QCOMPARE(lvwph->m_minYExtent, 0.);

1686 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1687 QCOMPARE(lvwph->m_clipItem->clip(), false);

1688 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1689 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1690 QCOMPARE(lvwph->contentY(), 0.);

1691

1692 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1693 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1694 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1695 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1696 verifyItem(0, 50., 392., false);

1697 verifyItem(1, 442., 100., false);

1698

1699 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1700

1701 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1702 QTest::qWait(100);

1703 QTest::mouseMove(view, QPoint(0, 5));

1704 QTest::qWait(100);

1705 QTest::mouseMove(view, QPoint(0, 10));

1706 QTest::qWait(100);

1707 QTest::mouseMove(view, QPoint(0, 15));

1708 QTest::qWait(100);

1709 QTest::mouseMove(view, QPoint(0, 20));

1710 QTest::qWait(100);

1711 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1712 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1713 verifyItem(0, 55., 392., false);

1714 verifyItem(1, 447., 100., false);

1715 QCOMPARE(lvwph->m_minYExtent, 0.);

1716 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1717

1718 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1719 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1720 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1721 verifyItem(0, 50., 392., false);

1722 verifyItem(1, 442., 100., false);

1723 }

1724

1725 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1726 {

1727 model->setProperty(0, "size", 800);

1728 verifyItem(0, 50., 800., false);

1729

1730 lvwph->maximizeVisibleArea(0);

1731 QTRY_COMPARE(lvwph->contentY(), 50.);

1732

1733 changeContentY(10);

1734 QTRY_COMPARE(lvwph->contentY(), 60.);

1735

1736 lvwph->showHeader();

1737 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1738 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1739 QCOMPARE(lvwph->m_minYExtent, 50.);

1740 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1741 QCOMPARE(lvwph->m_clipItem->clip(), true);

1742 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1743 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1744 QCOMPARE(lvwph->contentY(), 10.);

1745 verifyItem(0, -60., 800., false);

1746 }

1747

1748 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1749 {

1750 model->setProperty(0, "size", 800);

1751 verifyItem(0, 50., 800., false);

1752

1753 lvwph->maximizeVisibleArea(0);

1754 QTRY_COMPARE(lvwph->contentY(), 50.);

1755

1756 changeContentY(-10);

1757 QTRY_COMPARE(lvwph->contentY(), 40.);

1758

1759 lvwph->showHeader();

1760 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1761 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1762 QCOMPARE(lvwph->m_minYExtent, 40.);

1763 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1764 QCOMPARE(lvwph->m_clipItem->clip(), true);

1765 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1766 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1767 QCOMPARE(lvwph->contentY(), 0.);

1768 verifyItem(0, -40., 800., false);

1769 }

1770

1771 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1772 {

1773 model->setProperty(0, "size", 800);

1774 verifyItem(0, 50., 800., false);

1775

1776 lvwph->maximizeVisibleArea(0);

1777 QTRY_COMPARE(lvwph->contentY(), 50.);

1778

1779 changeContentY(-10);

1780 QTRY_COMPARE(lvwph->contentY(), 40.);

1781 changeContentY(10);

1782 QTRY_COMPARE(lvwph->contentY(), 50.);

1783

1784 lvwph->showHeader();

1785 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1786

1787 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1788 QCOMPARE(lvwph->m_minYExtent, 50.);

1789 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1790 QCOMPARE(lvwph->m_clipItem->clip(), true);

1791 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1792 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1793 QCOMPARE(lvwph->contentY(), 0.);

1794 verifyItem(0, -50., 800., false);

1795 }

1796

1797 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1798 {

1799 model->setProperty(0, "size", 800);

1800 verifyItem(0, 50., 800., false);

1801

1802 lvwph->maximizeVisibleArea(0);

1803 QTRY_COMPARE(lvwph->contentY(), 50.);

1804

1805 changeContentY(10);

1806 QTRY_COMPARE(lvwph->contentY(), 60.);

1807 changeContentY(-10);

1808 QTRY_COMPARE(lvwph->contentY(), 50.);

1809

1810 lvwph->showHeader();

1811 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1812 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1813 QCOMPARE(lvwph->m_minYExtent, 40.);

1814 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1815 QCOMPARE(lvwph->m_clipItem->clip(), true);

1816 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1817 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1818 QCOMPARE(lvwph->contentY(), 10.);

1819 verifyItem(0, -50., 800., false);

1820 }

1821

1822 void testMaximizeVisibleAreaAndShowHeader()

1823 {

1824 model->setProperty(0, "size", 800);

1825 verifyItem(0, 50., 800., false);

1826

1827 lvwph->maximizeVisibleArea(0);

1828 QTRY_COMPARE(lvwph->contentY(), 50.);

1829

1830 lvwph->showHeader();

1831 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1832 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1833 QCOMPARE(lvwph->m_minYExtent, 50.);

1834 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1835 QCOMPARE(lvwph->m_clipItem->clip(), true);

1836 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1837 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1838 QCOMPARE(lvwph->contentY(), 0.);

1839 verifyItem(0, -50., 800., false);

1840 }

1841

1842 void positionAtBeginningEmpty()

1843 {

1844 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1845 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1846

1847 lvwph->positionAtBeginning();

1848 }

1849

1850 void testHeaderPositionBug1240118()

1851 {

1852 scrollToBottom();

1853 lvwph->showHeader();

1854 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1855 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1856 model->setProperty(3, "size", 10);

1857 model->setProperty(4, "size", 10);

1858 model->setProperty(5, "size", 10);

1859 model->setProperty(6, "size", 10);

1860 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1861 }

1862

1863 void testResizeRemoveInsertBug1279434()

1864 {

1865 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1866 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1867

1868 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1869 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1870 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1871 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1872 verifyItem(0, 50., 125., false);

1873 verifyItem(1, 175., 100., false);

1874

1875 lvwph->setContentY(175);

1876

1877 model->setProperty(1, "size", 4);

1878 model->setProperty(0, "size", 4);

1879

1880 model->setProperty(0, "size", 6);

1881

1882 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1883 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1884 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1885

1886 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1887 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1888 }

1889

1890 void testResizeScrolledBigItem()

1891 {

1892 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1893 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1894

1895 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1896 changeContentY(8000);

1897

1898 // Pretend the list is busy requesting some other index

1899 lvwph->m_asyncRequestedIndex = 4;

1900

1901 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1902 // This resize makes the item go outside the viewport so its deleted

1903 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1904 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1905 // On the next polish the item will be readded

1906 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1907 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1908 }

1909

1910 void testNoCacheBuffer()

1911 {

1912 lvwph->setCacheBuffer(0);

1913 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1914 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1915 verifyItem(0, 50., 150., false);

1916 verifyItem(1, 200., 200., false);

1917 verifyItem(2, 400., 350., false);

1918 QCOMPARE(lvwph->m_minYExtent, 0.);

1919 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1920 QCOMPARE(lvwph->m_clipItem->clip(), false);

1921 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1922 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1923 QCOMPARE(lvwph->contentY(), 0.);

1924 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1925 }

1926

1927 void testAllCacheBuffer()

1928 {

1929 lvwph->setCacheBuffer(std::numeric_limits<int>::max());

1930 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

1931 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1932 verifyItem(0, 50., 150., false);

1933 verifyItem(1, 200., 200., false);

1934 verifyItem(2, 400., 350., false);

1935 verifyItem(3, 750., 350., true);

1936 verifyItem(4, 1100., 350., true);

1937 verifyItem(5, 1450., 350., true);

1938 QCOMPARE(lvwph->m_minYExtent, 0.);

1939 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1940 QCOMPARE(lvwph->m_clipItem->clip(), false);

1941 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1942 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1943 QCOMPARE(lvwph->contentY(), 0.);

1944 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1945 }

1946

1947 void testFirstVisibleIndexRemove()

1948 {

1949 changeContentY(520);

1950 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1951 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1952

1953 // Remove 0 and 1, the previously visible index 2 will be 0 and visible

1954 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1955 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1956 }

1957

1958private:

1959 QQuickView *view;

1960 ListViewWithPageHeader *lvwph;

1961 QQmlListModel *model;

1962 QQmlComponent *otherDelegate;

1963};

1964

1965QTEST_MAIN(ListViewWithPageHeaderTest)

1966

1967#include "listviewwithpageheadertest.moc"