tests/plugins/Dash/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 84006ee help sign in

unity8/tests/plugins/Dash/listviewwithpageheadertest.cpp

2036 lines 79 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QSignalSpy>

23#include <QtTestGui>

24#include <private/qqmllistmodel_p.h>

25#include <private/qquickanimation_p.h>

26#include <private/qquickitem_p.h>

28#include <limits>

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

31// particullary making sure that lost items are culled

32// and then removed in the next updatePolish cycle

34class ListViewWithPageHeaderTest : public QObject

35{

36 Q_OBJECT

38private:

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

40 {

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

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

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

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

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

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

47 } else {

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

49 }

50 }

52 void changeContentY(qreal change)

53 {

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

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

56 const qreal jump = 25;

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

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

59 QTest::qWait(1);

60 }

61 } else {

62 const qreal jump = -25;

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

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

65 QTest::qWait(1);

66 }

67 }

68 lvwph->setContentY(dest);

69 QTest::qWait(1);

70 }

72 void scrollToTop()

73 {

74 const qreal jump = -25;

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

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

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

78 } else {

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

80 }

81 QTest::qWait(1);

82 }

83 }

85 void scrollToBottom()

86 {

87 const qreal jump = 25;

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

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

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

91 } else {

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

93 }

94 QTest::qWait(1);

95 }

96 }

98 void verifyInitialTopPosition()

99 {

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

101 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

113 }

114

115private Q_SLOTS:

116

117 void initTestCase()

118 {

119 }

120

121 void init()

122 {

123 view = new QQuickView();

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

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

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

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

128 QVERIFY(lvwph);

129 QVERIFY(model);

130 QVERIFY(otherDelegate);

131 view->show();

132 QTest::qWaitForWindowExposed(view);

133

134 verifyInitialTopPosition();

135 }

136

137 void cleanup()

138 {

139 delete view;

140 }

141

142 void testCreationDeletion()

143 {

144 // Nothing, init/cleanup already tests this

145 }

146

147 void testDrag1PixelUp()

148 {

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

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

151 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

163 }

164

165 void testHeaderDetachDragDown()

166 {

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

168 QTest::qWait(100);

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

170 QTest::qWait(100);

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

172 QTest::qWait(100);

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

174 QTest::qWait(100);

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

176 QTest::qWait(100);

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

178 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

190

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

192

193 verifyInitialTopPosition();

194 }

195

196 void testDrag375PixelUp()

197 {

198 changeContentY(375);

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

200 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

213 }

214

215 void testDrag520PixelUp()

216 {

217 changeContentY(520);

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

219 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

230 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

237 }

238

239 void testDragHeaderUpThenShow()

240 {

241 changeContentY(120);

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

243 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

255

256 changeContentY(-30);

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

258 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

270 }

271

272 void testDragHeaderUpThenShowWithoutHidingTotally()

273 {

274 changeContentY(10);

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

276 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

288

289 changeContentY(-1);

290

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

292 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

304 }

305

306 void testPositionAtBeginningIndex0Visible()

307 {

308 changeContentY(375);

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

310 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

323

324 lvwph->positionAtBeginning();

325

326 verifyInitialTopPosition();

327 }

328

329 void testPositionAtBeginningIndex0NotVisible()

330 {

331 changeContentY(520);

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

333 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

338 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

345

346 lvwph->positionAtBeginning();

347

348 verifyInitialTopPosition();

349 }

350

351 void testIndex0GrowOnScreen()

352 {

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

354

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

356 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

367 }

368

369 void testIndex0GrowOffScreen()

370 {

371 changeContentY(375);

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

373 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

386

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

388

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

390 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

403

404 scrollToTop();

405

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

407 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

418

419 changeContentY(30);

420

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

422 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

433 }

434

435 void testIndex0GrowNotCreated()

436 {

437 changeContentY(520);

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

439 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

444 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

451

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

453

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

455 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

460 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

467

468 scrollToTop();

469

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

471 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

482 }

483

484 void testShowHideShowHeaderAtBottom()

485 {

486 scrollToBottom();

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

488 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

499

500 changeContentY(-30);

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

502 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

513

514 changeContentY(30);

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

516 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

527

528 changeContentY(-30);

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

530 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

541 }

542

543 void testChangeDelegateAtBottom()

544 {

545 scrollToBottom();

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

547 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

558

559 lvwph->setDelegate(otherDelegate);

560

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

562 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

576 }

577

578 void testSetEmptyHeaderAtTop()

579 {

580 lvwph->setHeader(nullptr);

581

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

583 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

594 }

595

596 void testSetEmptyHeaderAtBottom()

597 {

598 scrollToBottom();

599 lvwph->setHeader(nullptr);

600

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

602 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

612

613 scrollToTop();

614

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

616 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

627 }

628

629 void testSetEmptyHeaderWhenPartlyShownClipped()

630 {

631 scrollToBottom();

632 changeContentY(-30);

633 lvwph->setHeader(nullptr);

634

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

636 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

646 QTRY_VERIFY(lvwph->isAtYEnd());

647

648 scrollToTop();

649

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

651 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

662 }

663

664 void testSetEmptyHeaderWhenPartlyShownNotClipped()

665 {

666 changeContentY(30);

667 lvwph->setHeader(nullptr);

668

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

670 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

681 }

682

683 void testSetNullDelegate()

684 {

685 lvwph->setDelegate(nullptr);

686

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

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

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

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

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

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

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

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

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

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

697 QVERIFY(lvwph->isAtYBeginning());

698 QVERIFY(lvwph->isAtYEnd());

699 }

700

701 void testInsertItems()

702 {

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

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

705

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

707 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

720 }

721

722 void testInsertItemsOnNotShownPosition()

723 {

724 changeContentY(700);

725

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

727 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

739

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

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

742

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

744 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

756

757 scrollToTop();

758

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

760 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

773 }

774

775 void testInsertItemsAtEndOfViewport()

776 {

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

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

779

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

781 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

793 }

794

795 void testInsertItemsBeforeValidIndex()

796 {

797 changeContentY(520);

798

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

800 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

805 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

812

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

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

815

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

817 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

822 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

829 }

830

831 void testInsertItemsBeforeViewport()

832 {

833 changeContentY(375);

834

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

836 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

849

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

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

852

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

854 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

867

868 scrollToTop();

869

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

871 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

884 }

885

886 void testInsertItemsAtBottom()

887 {

888 scrollToBottom();

889

890 QVERIFY(lvwph->isAtYEnd());

891

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

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

894

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

896 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

910

911 scrollToBottom();

912

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

914 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

926 QVERIFY(lvwph->isAtYEnd());

927 }

928

929 void testInsertItemAtTop()

930 {

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

932

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

934 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

946 QVERIFY(lvwph->isAtYBeginning());

947 }

948

949 void testInsertItem10SmallItemsAtTopWhenAtBottom()

950 {

951 scrollToBottom();

952

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

963

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

965 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

976

977 changeContentY(-800);

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

979 changeContentY(-400);

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

981 changeContentY(-200);

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

983 changeContentY(-300);

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

985

986 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1006 }

1007

1008 void testInsertToEmpty()

1009 {

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

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

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

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

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

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

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

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

1018

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

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

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

1022 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1025 }

1026

1027 void testRemoveItemsAtTop()

1028 {

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

1030

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

1032 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1043 QVERIFY(lvwph->isAtYBeginning());

1044 }

1045

1046 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1047 {

1048 scrollToBottom();

1049

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

1051

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

1053 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1064 }

1065

1066 void testRemoveLastItemsAtBottom()

1067 {

1068 scrollToBottom();

1069

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

1071

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

1073 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1084 }

1085

1086 void testRemoveItemOutOfViewport()

1087 {

1088 changeContentY(520);

1089

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

1091 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1096 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1103

1104

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

1106

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

1108 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1120 }

1121

1122 void testMoveFirstItems()

1123 {

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

1125

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

1127 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1139

1140 }

1141

1142 void testMoveFirstOutOfVisibleItems()

1143 {

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

1145

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

1147 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1158

1159 }

1160

1161 void testMoveFirstToLastAtBottom()

1162 {

1163 scrollToBottom();

1164

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

1166 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1177

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

1179

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

1181 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1194 }

1195

1196 void testChangeSizeVisibleItemNotOnViewport()

1197 {

1198 changeContentY(440);

1199

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

1201 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1214

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

1216

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

1218 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1231 }

1232

1233 void testShowHeaderCloseToTheTop()

1234 {

1235 changeContentY(375);

1236

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

1238 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1251

1252 lvwph->showHeader();

1253

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

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

1256 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1269

1270 scrollToTop();

1271

1272 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1273 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1274 verifyItem(0, 50., 150., false);

1275 verifyItem(1, 200., 200., false);

1276 verifyItem(2, 400., 350., false);

1277 verifyItem(3, 750., 350., true);

1278 QCOMPARE(lvwph->m_minYExtent, 50.);

1279 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1280 QCOMPARE(lvwph->m_clipItem->clip(), false);

1281 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1282 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1283 QCOMPARE(lvwph->contentY(), -50.);

1284 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1285 }

1286

1287 void testShowHeaderHalfShown()

1288 {

1289 changeContentY(20);

1290

1291 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1292 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1293 verifyItem(0, 30., 150., false);

1294 verifyItem(1, 180, 200., false);

1295 verifyItem(2, 380, 350., false);

1296 verifyItem(3, 730, 350., true);

1297 QCOMPARE(lvwph->m_minYExtent, 0.);

1298 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1299 QCOMPARE(lvwph->m_clipItem->clip(), false);

1300 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1301 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1302 QCOMPARE(lvwph->contentY(), 20.);

1303 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1304

1305 lvwph->showHeader();

1306

1307 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1308 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1309 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1310 verifyItem(0, -20., 150., false);

1311 verifyItem(1, 130, 200., false);

1312 verifyItem(2, 330, 350., false);

1313 verifyItem(3, 680, 350., true);

1314 QCOMPARE(lvwph->m_minYExtent, 20.);

1315 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1316 QCOMPARE(lvwph->m_clipItem->clip(), true);

1317 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1318 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1319 QCOMPARE(lvwph->contentY(), 0.);

1320 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1321

1322 scrollToTop();

1323

1324 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1325 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1326 verifyItem(0, 50., 150., false);

1327 verifyItem(1, 200., 200., false);

1328 verifyItem(2, 400., 350., false);

1329 verifyItem(3, 750, 350., true);

1330 QCOMPARE(lvwph->m_minYExtent, 20.);

1331 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1332 QCOMPARE(lvwph->m_clipItem->clip(), false);

1333 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1334 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1335 QCOMPARE(lvwph->contentY(), -20.);

1336 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1337 }

1338

1339 void testShowHeaderAtBottom()

1340 {

1341 scrollToBottom();

1342

1343 lvwph->showHeader();

1344

1345 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1346 QTRY_VERIFY (lvwph->isAtYEnd());

1347 }

1348

1349 void growWindow()

1350 {

1351 view->rootObject()->setHeight(850);

1352

1353 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1354 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1355 verifyItem(0, 50., 150., false);

1356 verifyItem(1, 200., 200., false);

1357 verifyItem(2, 400., 350., false);

1358 verifyItem(3, 750., 350., false);

1359 verifyItem(4, 1100., 350., true);

1360 QCOMPARE(lvwph->m_minYExtent, 0.);

1361 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1362 QCOMPARE(lvwph->m_clipItem->clip(), false);

1363 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1364 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1365 QCOMPARE(lvwph->contentY(), 0.);

1366 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1367 }

1368

1369 void growWindowAtBottom()

1370 {

1371 scrollToBottom();

1372

1373 view->rootObject()->setHeight(850);

1374

1375 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1376 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1377 verifyItem(0, -550., 350., true);

1378 verifyItem(1, -200., 350., false);

1379 verifyItem(2, 150, 350., false);

1380 verifyItem(3, 500, 350., false);

1381 QCOMPARE(lvwph->m_minYExtent, 350.);

1382 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1383 QCOMPARE(lvwph->m_clipItem->clip(), false);

1384 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1385 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1386 QCOMPARE(lvwph->contentY(), 950.);

1387 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1388 }

1389

1390 void testCrashShowHeaderWithNoHeader()

1391 {

1392 lvwph->setHeader(nullptr);

1393 lvwph->showHeader();

1394 }

1395

1396 void testCullOnBottomEdge()

1397 {

1398 changeContentY(200);

1399

1400 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1401 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1402 verifyItem(0, -150., 150., true);

1403 verifyItem(1, 0., 200., false);

1404 verifyItem(2, 200., 350., false);

1405 verifyItem(3, 550., 350., true);

1406 QCOMPARE(lvwph->m_minYExtent, 0.);

1407 QCOMPARE(lvwph->m_clipItem->y(), 200.);

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(), 200.);

1412 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1413 }

1414

1415 void testMaximizeVisibleArea()

1416 {

1417 bool res = lvwph->maximizeVisibleArea(2);

1418 QVERIFY(res);

1419 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1420

1421 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1422 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1423 verifyItem(0, -158., 150., true);

1424 verifyItem(1, -8., 200., false);

1425 verifyItem(2, 192, 350., false);

1426 verifyItem(3, 542, 350., true);

1427 QCOMPARE(lvwph->m_minYExtent, 0.);

1428 QCOMPARE(lvwph->m_clipItem->y(), 208.);

1429 QCOMPARE(lvwph->m_clipItem->clip(), false);

1430 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1431 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1432 QCOMPARE(lvwph->contentY(), 208.);

1433 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1434 }

1435

1436 void testMaximizeVisibleAreaVisibleItems()

1437 {

1438 bool res = lvwph->maximizeVisibleArea(0);

1439 QVERIFY(res);

1440 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1441

1442 verifyInitialTopPosition();

1443

1444 res = lvwph->maximizeVisibleArea(1);

1445 QVERIFY(res);

1446 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1447

1448 verifyInitialTopPosition();

1449 }

1450

1451 void testMaximizeVisibleAreaInvalidIndexes()

1452 {

1453 bool res = lvwph->maximizeVisibleArea(-1);

1454 QVERIFY(!res);

1455 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1456

1457 verifyInitialTopPosition();

1458

1459 res = lvwph->maximizeVisibleArea(1000);

1460 QVERIFY(!res);

1461 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1462

1463 verifyInitialTopPosition();

1464

1465 res = lvwph->maximizeVisibleArea(4);

1466 QVERIFY(!res);

1467 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1468

1469 verifyInitialTopPosition();

1470 }

1471

1472 void testMaximizeVisibleAreaBigElement()

1473 {

1474 model->setProperty(2, "size", 4000);

1475 bool res = lvwph->maximizeVisibleArea(2);

1476 QVERIFY(res);

1477 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1478

1479 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1480 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1481 verifyItem(0, -350., 150., true);

1482 verifyItem(1, -200., 200., true);

1483 verifyItem(2, 0, 4000., false);

1484 QCOMPARE(lvwph->m_minYExtent, 0.);

1485 QCOMPARE(lvwph->m_clipItem->y(), 400.);

1486 QCOMPARE(lvwph->m_clipItem->clip(), false);

1487 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1488 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1489 QCOMPARE(lvwph->contentY(), 400.);

1490 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1491 }

1492

1493 void testMaximizeVisibleAreaScrollDown()

1494 {

1495 changeContentY(250);

1496 bool res = lvwph->maximizeVisibleArea(1);

1497 QVERIFY(res);

1498 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1499

1500 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1501 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1502 verifyItem(0, -150., 150., true);

1503 verifyItem(1, 0., 200., false);

1504 verifyItem(2, 200, 350., false);

1505 verifyItem(3, 550, 350., true);

1506 QCOMPARE(lvwph->m_minYExtent, 0.);

1507 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1508 QCOMPARE(lvwph->m_clipItem->clip(), false);

1509 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1510 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1511 QCOMPARE(lvwph->contentY(), 200.);

1512 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1513 }

1514

1515 void testMaximizeVisibleAreaScrollDownBigElement()

1516 {

1517 model->setProperty(1, "size", 1000);

1518 changeContentY(1150);

1519 bool res = lvwph->maximizeVisibleArea(1);

1520 QVERIFY(res);

1521 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1522

1523 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1524 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1525 verifyItem(0, -458., 1000., false);

1526 verifyItem(1, 542., 350., true);

1527 QCOMPARE(lvwph->m_minYExtent, 525.);

1528 QCOMPARE(lvwph->m_clipItem->y(), 658.);

1529 QCOMPARE(lvwph->m_clipItem->clip(), false);

1530 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1531 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1532 QCOMPARE(lvwph->contentY(), 658.);

1533 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1534 }

1535

1536 void testMaximizeVisibleAreaBigElementInTheMiddle()

1537 {

1538 model->setProperty(1, "size", 1000);

1539 changeContentY(650);

1540

1541 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1542 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1543 verifyItem(0, -450., 1000., false);

1544 verifyItem(1, 550., 350., true);

1545 QCOMPARE(lvwph->m_minYExtent, 525.);

1546 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1547 QCOMPARE(lvwph->m_clipItem->clip(), false);

1548 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1549 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1550 QCOMPARE(lvwph->contentY(), 650.);

1551 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1552

1553 bool res = lvwph->maximizeVisibleArea(1);

1554 QVERIFY(res);

1555 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1556

1557 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1558 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1559 verifyItem(0, -450., 1000., false);

1560 verifyItem(1, 550., 350., true);

1561 QCOMPARE(lvwph->m_minYExtent, 525.);

1562 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1563 QCOMPARE(lvwph->m_clipItem->clip(), false);

1564 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1565 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1566 QCOMPARE(lvwph->contentY(), 650.);

1567 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1568 }

1569

1570 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1571 {

1572 changeContentY(430);

1573 changeContentY(-30);

1574

1575 bool res = lvwph->maximizeVisibleArea(1);

1576 QVERIFY(res);

1577 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1578

1579 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1580 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1581 verifyItem(0, -150., 150., true);

1582 verifyItem(1, 0., 200., false);

1583 verifyItem(2, 200, 350., false);

1584 verifyItem(3, 550, 350., true);

1585 QCOMPARE(lvwph->m_minYExtent, 0.);

1586 QCOMPARE(lvwph->m_clipItem->y(), 200.);

1587 QCOMPARE(lvwph->m_clipItem->clip(), false);

1588 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1589 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1590 QCOMPARE(lvwph->contentY(), 200.);

1591 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1592 }

1593

1594 void testMaximizeVisibleAreaTopWithHalfPageHeaderUpDown()

1595 {

1596 testMaximizeVisibleAreaTopWithHalfPageHeader();

1597

1598 changeContentY(-60);

1599 changeContentY(15);

1600

1601 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1602 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1603 verifyItem(0, -140., 150., false);

1604 verifyItem(1, 10., 200., false);

1605 verifyItem(2, 210, 350., false);

1606 verifyItem(3, 560, 350., true);

1607 QCOMPARE(lvwph->m_minYExtent, 0.);

1608 QCOMPARE(lvwph->m_clipItem->y(), 190.);

1609 QCOMPARE(lvwph->m_clipItem->clip(), true);

1610 QCOMPARE(lvwph->m_headerItem->y(), 140.);

1611 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1612 QCOMPARE(lvwph->contentY(), 155.);

1613 QCOMPARE(lvwph->m_headerItemShownHeight, 35.);

1614 }

1615

1616 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1617 {

1618 changeContentY(430);

1619 changeContentY(-30);

1620

1621 bool res = lvwph->maximizeVisibleArea(3);

1622 QVERIFY(res);

1623 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1624

1625 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1626 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1627 verifyItem(0, -358., 200., true);

1628 verifyItem(1, -158., 350., false);

1629 verifyItem(2, 192, 350., false);

1630 verifyItem(3, 542, 350., true);

1631 QCOMPARE(lvwph->m_minYExtent, 162.5);

1632 QCOMPARE(lvwph->m_clipItem->y(), 558.);

1633 QCOMPARE(lvwph->m_clipItem->clip(), false);

1634 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1635 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1636 QCOMPARE(lvwph->contentY(), 558.);

1637 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1638 }

1639

1640 void testMaximizeVisibleAreaWithItemResize()

1641 {

1642 model->setProperty(0, "size", 1000);

1643

1644 bool res = lvwph->maximizeVisibleArea(1);

1645 QVERIFY(res);

1646 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1647

1648 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1649 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1650 verifyItem(0, -658., 1000., false);

1651 verifyItem(1, 342., 200., false);

1652 verifyItem(2, 542, 350., true);

1653 QCOMPARE(lvwph->m_minYExtent, 0.);

1654 QCOMPARE(lvwph->m_clipItem->y(), 708.);

1655 QCOMPARE(lvwph->m_clipItem->clip(), false);

1656 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1657 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1658 QCOMPARE(lvwph->contentY(), 708.);

1659 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1660 }

1661

1662 void addingRemoveItemsShouldNotChangeContentY()

1663 {

1664 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

1665 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150));

1666 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

1667

1668 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1669 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1670 verifyItem(0, 50., 150., false);

1671 QCOMPARE(lvwph->m_minYExtent, 0.);

1672 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1673 QCOMPARE(lvwph->m_clipItem->clip(), false);

1674 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1675 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1676 QCOMPARE(lvwph->contentY(), 0.);

1677 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1678

1679 QCOMPARE(spy.count(), 0);

1680 }

1681

1682 void testOvershootOnSameSize()

1683 {

1684 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1685 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1686 QCOMPARE(lvwph->m_minYExtent, 0.);

1687 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1688 QCOMPARE(lvwph->m_clipItem->clip(), false);

1689 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1690 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1691 QCOMPARE(lvwph->contentY(), 0.);

1692

1693 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1694 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 392));

1695 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1696 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1697 verifyItem(0, 50., 392., false);

1698 verifyItem(1, 442., 100., false);

1699

1700 QCOMPARE(lvwph->contentHeight(), lvwph->height());

1701

1702 QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

1703 QTest::qWait(100);

1704 QTest::mouseMove(view, QPoint(0, 5));

1705 QTest::qWait(100);

1706 QTest::mouseMove(view, QPoint(0, 10));

1707 QTest::qWait(100);

1708 QTest::mouseMove(view, QPoint(0, 15));

1709 QTest::qWait(100);

1710 QTest::mouseMove(view, QPoint(0, 20));

1711 QTest::qWait(100);

1712 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1713 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1714 verifyItem(0, 55., 392., false);

1715 verifyItem(1, 447., 100., false);

1716 QCOMPARE(lvwph->m_minYExtent, 0.);

1717 QCOMPARE(lvwph->m_clipItem->y(), -5.);

1718

1719 QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));

1720 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1721 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1722 verifyItem(0, 50., 392., false);

1723 verifyItem(1, 442., 100., false);

1724 }

1725

1726 void testMaximizeVisibleAreaMoveDownAndShowHeader()

1727 {

1728 model->setProperty(0, "size", 800);

1729 verifyItem(0, 50., 800., false);

1730

1731 lvwph->maximizeVisibleArea(0);

1732 QTRY_COMPARE(lvwph->contentY(), 50.);

1733

1734 changeContentY(10);

1735 QTRY_COMPARE(lvwph->contentY(), 60.);

1736

1737 lvwph->showHeader();

1738 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1739 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1740 QCOMPARE(lvwph->m_minYExtent, 50.);

1741 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1742 QCOMPARE(lvwph->m_clipItem->clip(), true);

1743 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1744 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1745 QCOMPARE(lvwph->contentY(), 10.);

1746 verifyItem(0, -60., 800., false);

1747 }

1748

1749 void testMaximizeVisibleAreaMoveUpAndShowHeader()

1750 {

1751 model->setProperty(0, "size", 800);

1752 verifyItem(0, 50., 800., false);

1753

1754 lvwph->maximizeVisibleArea(0);

1755 QTRY_COMPARE(lvwph->contentY(), 50.);

1756

1757 changeContentY(-10);

1758 QTRY_COMPARE(lvwph->contentY(), 40.);

1759

1760 lvwph->showHeader();

1761 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1762 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1763 QCOMPARE(lvwph->m_minYExtent, 40.);

1764 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1765 QCOMPARE(lvwph->m_clipItem->clip(), true);

1766 QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);

1767 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1768 QCOMPARE(lvwph->contentY(), 0.);

1769 verifyItem(0, -40., 800., false);

1770 }

1771

1772 void testMaximizeVisibleAreaMoveDownAndUpAndShowHeader()

1773 {

1774 model->setProperty(0, "size", 800);

1775 verifyItem(0, 50., 800., false);

1776

1777 lvwph->maximizeVisibleArea(0);

1778 QTRY_COMPARE(lvwph->contentY(), 50.);

1779

1780 changeContentY(-10);

1781 QTRY_COMPARE(lvwph->contentY(), 40.);

1782 changeContentY(10);

1783 QTRY_COMPARE(lvwph->contentY(), 50.);

1784

1785 lvwph->showHeader();

1786 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1787

1788 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1789 QCOMPARE(lvwph->m_minYExtent, 50.);

1790 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1791 QCOMPARE(lvwph->m_clipItem->clip(), true);

1792 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1793 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1794 QCOMPARE(lvwph->contentY(), 0.);

1795 verifyItem(0, -50., 800., false);

1796 }

1797

1798 void testMaximizeVisibleAreaMoveUpAndDownAndShowHeader()

1799 {

1800 model->setProperty(0, "size", 800);

1801 verifyItem(0, 50., 800., false);

1802

1803 lvwph->maximizeVisibleArea(0);

1804 QTRY_COMPARE(lvwph->contentY(), 50.);

1805

1806 changeContentY(10);

1807 QTRY_COMPARE(lvwph->contentY(), 60.);

1808 changeContentY(-10);

1809 QTRY_COMPARE(lvwph->contentY(), 50.);

1810

1811 lvwph->showHeader();

1812 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1813 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1814 QCOMPARE(lvwph->m_minYExtent, 40.);

1815 QCOMPARE(lvwph->m_clipItem->y(), 60.);

1816 QCOMPARE(lvwph->m_clipItem->clip(), true);

1817 QCOMPARE(lvwph->m_headerItem->y(), 10.);

1818 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1819 QCOMPARE(lvwph->contentY(), 10.);

1820 verifyItem(0, -50., 800., false);

1821 }

1822

1823 void testMaximizeVisibleAreaAndShowHeader()

1824 {

1825 model->setProperty(0, "size", 800);

1826 verifyItem(0, 50., 800., false);

1827

1828 lvwph->maximizeVisibleArea(0);

1829 QTRY_COMPARE(lvwph->contentY(), 50.);

1830

1831 lvwph->showHeader();

1832 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1833 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1834 QCOMPARE(lvwph->m_minYExtent, 50.);

1835 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1836 QCOMPARE(lvwph->m_clipItem->clip(), true);

1837 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1838 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1839 QCOMPARE(lvwph->contentY(), 0.);

1840 verifyItem(0, -50., 800., false);

1841 }

1842

1843 void positionAtBeginningEmpty()

1844 {

1845 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1846 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1847

1848 lvwph->positionAtBeginning();

1849 }

1850

1851 void testHeaderPositionBug1240118()

1852 {

1853 scrollToBottom();

1854 lvwph->showHeader();

1855 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1856 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1857 model->setProperty(3, "size", 10);

1858 model->setProperty(4, "size", 10);

1859 model->setProperty(5, "size", 10);

1860 model->setProperty(6, "size", 10);

1861 QTRY_COMPARE(lvwph->m_headerItem->y(), -lvwph->m_minYExtent);

1862 }

1863

1864 void testResizeRemoveInsertBug1279434()

1865 {

1866 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1867 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1868

1869 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1870 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 125));

1871 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1872 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1873 verifyItem(0, 50., 125., false);

1874 verifyItem(1, 175., 100., false);

1875

1876 lvwph->setContentY(175);

1877

1878 model->setProperty(1, "size", 4);

1879 model->setProperty(0, "size", 4);

1880

1881 model->setProperty(0, "size", 6);

1882

1883 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1884 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1885 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1886

1887 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100));

1888 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1889 }

1890

1891 void testResizeScrolledBigItem()

1892 {

1893 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

1894 QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);

1895

1896 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 10000));

1897 changeContentY(8000);

1898

1899 // Pretend the list is busy requesting some other index

1900 lvwph->m_asyncRequestedIndex = 4;

1901

1902 lvwph->m_visibleItems[0]->m_item->setHeight(100);

1903 // This resize makes the item go outside the viewport so its deleted

1904 QCOMPARE(lvwph->m_visibleItems.count(), 0);

1905 QCOMPARE(lvwph->m_firstVisibleIndex, -1);

1906 // On the next polish the item will be readded

1907 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1908 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 0);

1909 }

1910

1911 void testNoCacheBuffer()

1912 {

1913 lvwph->setCacheBuffer(0);

1914 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1915 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1916 verifyItem(0, 50., 150., false);

1917 verifyItem(1, 200., 200., false);

1918 verifyItem(2, 400., 350., false);

1919 QCOMPARE(lvwph->m_minYExtent, 0.);

1920 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1921 QCOMPARE(lvwph->m_clipItem->clip(), false);

1922 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1923 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1924 QCOMPARE(lvwph->contentY(), 0.);

1925 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1926 }

1927

1928 void testAllCacheBuffer()

1929 {

1930 lvwph->setCacheBuffer(std::numeric_limits<int>::max());

1931 QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);

1932 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1933 verifyItem(0, 50., 150., false);

1934 verifyItem(1, 200., 200., false);

1935 verifyItem(2, 400., 350., false);

1936 verifyItem(3, 750., 350., true);

1937 verifyItem(4, 1100., 350., true);

1938 verifyItem(5, 1450., 350., true);

1939 QCOMPARE(lvwph->m_minYExtent, 0.);

1940 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1941 QCOMPARE(lvwph->m_clipItem->clip(), false);

1942 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1943 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1944 QCOMPARE(lvwph->contentY(), 0.);

1945 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1946 }

1947

1948 void testFirstVisibleIndexRemove()

1949 {

1950 changeContentY(520);

1951 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1952 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1953

1954 // Remove 0 and 1, the previously visible index 2 will be 0 and visible

1955 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));

1956 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1957 }

1958

1959 void testBug1540490()

1960 {

1961 lvwph->header()->setImplicitHeight(150);

1962 verifyItem(0, 150., 150., false);

1963

1964 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1965 model->setProperty(0, "size", 400);

1966 model->setProperty(1, "size", 600);

1967 model->setProperty(2, "size", 300);

1968

1969 scrollToBottom();

1970 changeContentY(-200);

1971

1972 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 2));

1973 model->setProperty(0, "size", 100);

1974 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1));

1975 lvwph->header()->setImplicitHeight(50);

1976 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 200));

1977

1978 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

1979 verifyItem(0, 50., 200., false);

1980 }

1981

1982 void testBug1569976()

1983 {

1984 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 3));

1985

1986 for (int i = 0; i < 10; ++i) {

1987 scrollToBottom();

1988 lvwph->showHeader();

1989 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1990 scrollToTop();

1991 }

1992 verifyItem(0, 50., 150., false);

1993 verifyItem(1, 200., 200., false);

1994 verifyItem(2, 400., 350., false);

1995 }

1996

1997 void testRemoveItemNotShowHeader()

1998 {

1999 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

2000 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 90));

2001 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 600));

2002 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

2003 scrollToBottom();

2004 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 2000));

2005 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2006 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 2), Q_ARG(QVariant, 1));

2007 QTRY_COMPARE(lvwph->m_headerItem->y(), -610.);

2008 QTRY_COMPARE(lvwph->m_minYExtent, 610.);

2009 }

2010

2011 void testRemoveItemCutContents()

2012 {

2013 view->rootObject()->setHeight(921);

2014 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 6));

2015 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1000));

2016 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2017 QTRY_COMPARE(lvwph->contentHeight(), 1050.);

2018 scrollToBottom();

2019 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 530));

2020 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

2021 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

2022 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2023 verifyItem(0, 50., 530., false);

2024 QTRY_COMPARE(lvwph->m_minYExtent, 530.);

2025 }

2026

2027private:

2028 QQuickView *view;

2029 ListViewWithPageHeader *lvwph;

2030 QQmlListModel *model;

2031 QQmlComponent *otherDelegate;

2032};

2033

2034QTEST_MAIN(ListViewWithPageHeaderTest)

2035

2036#include "listviewwithpageheadertest.moc"