tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 68669d9 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp

1311 lines 51 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QtTestGui>

23#include <private/qquicklistmodel_p.h>

24#include <private/qquickanimation_p.h>

25#include <private/qquickitem_p.h>

27class ListViewWithPageHeaderTest : public QObject

28{

29 Q_OBJECT

31private:

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

33 {

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

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

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

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

38 }

40 void changeContentY(qreal change)

41 {

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

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

44 const qreal jump = 25;

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

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

47 QTest::qWait(1);

48 }

49 } else {

50 const qreal jump = -25;

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

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

53 QTest::qWait(1);

54 }

55 }

56 lvwph->setContentY(dest);

57 QTest::qWait(1);

58 }

60 void scrollToTop()

61 {

62 const qreal jump = -25;

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

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

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

66 } else {

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

68 }

69 QTest::qWait(1);

70 }

71 }

73 void scrollToBottom()

74 {

75 const qreal jump = 25;

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

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

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

79 } else {

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

81 }

82 QTest::qWait(1);

83 }

84 }

86 void verifyInitialTopPosition()

87 {

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

89 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

101 }

102

103private Q_SLOTS:

104

105 void initTestCase()

106 {

107 }

108

109 void init()

110 {

111 view = new QQuickView();

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

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

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

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

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

117 QVERIFY(lvwph);

118 QVERIFY(model);

119 QVERIFY(otherDelegate);

120 view->show();

121 QTest::qWaitForWindowExposed(view);

122

123 verifyInitialTopPosition();

124 }

125

126 void cleanup()

127 {

128 delete view;

129 }

130

131 void testCreationDeletion()

132 {

133 // Nothing, init/cleanup already tests this

134 }

135

136 void testDrag1PixelUp()

137 {

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

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

140 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

152 }

153

154 void testHeaderDetachDragDown()

155 {

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

157 QTest::qWait(100);

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

159 QTest::qWait(100);

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

161 QTest::qWait(100);

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

163 QTest::qWait(100);

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

165 QTest::qWait(100);

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

167 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

179

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

181

182 verifyInitialTopPosition();

183 }

184

185 void testDrag375PixelUp()

186 {

187 changeContentY(375);

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

189 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

202 }

203

204 void testDrag520PixelUp()

205 {

206 changeContentY(520);

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

208 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

219 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

226 }

227

228 void testDragHeaderUpThenShow()

229 {

230 changeContentY(120);

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

232 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

244

245 changeContentY(-30);

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

247 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

259 }

260

261 void testDragHeaderUpThenShowWithoutHidingTotally()

262 {

263 changeContentY(10);

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

265 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

277

278 changeContentY(-1);

279

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

281 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

293 }

294

295 void testPositionAtBeginningIndex0Visible()

296 {

297 changeContentY(375);

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

299 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

312

313 lvwph->positionAtBeginning();

314

315 verifyInitialTopPosition();

316 }

317

318 void testPositionAtBeginningIndex0NotVisible()

319 {

320 changeContentY(520);

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

322 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

327 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

334

335 lvwph->positionAtBeginning();

336

337 verifyInitialTopPosition();

338 }

339

340 void testIndex0GrowOnScreen()

341 {

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

343

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

345 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

356 }

357

358 void testIndex0GrowOffScreen()

359 {

360 changeContentY(375);

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

362 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

375

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

377

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

379 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

392

393 scrollToTop();

394

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

396 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

407

408 changeContentY(30);

409

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

411 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

422 }

423

424 void testIndex0GrowNotCreated()

425 {

426 changeContentY(520);

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

428 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

433 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

440

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

442

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

444 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

449 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

456

457 scrollToTop();

458

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

460 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

471 }

472

473 void testShowHideShowHeaderAtBottom()

474 {

475 scrollToBottom();

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

477 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

488

489 changeContentY(-30);

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

491 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

502

503 changeContentY(30);

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

505 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

516

517 changeContentY(-30);

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

519 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

530 }

531

532 void testChangeDelegateAtBottom()

533 {

534 scrollToBottom();

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

536 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

547

548 lvwph->setDelegate(otherDelegate);

549

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

551 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

565 }

566

567 void testSetEmptyHeaderAtTop()

568 {

569 lvwph->setHeader(nullptr);

570

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

572 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

583 }

584

585 void testSetEmptyHeaderAtBottom()

586 {

587 scrollToBottom();

588 lvwph->setHeader(nullptr);

589

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

591 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

601

602 scrollToTop();

603

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

605 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

616 }

617

618 void testSetEmptyHeaderWhenPartlyShownClipped()

619 {

620 scrollToBottom();

621 changeContentY(-30);

622 lvwph->setHeader(nullptr);

623

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

625 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

635 QTRY_VERIFY(lvwph->isAtYEnd());

636

637 scrollToTop();

638

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

640 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

651 }

652

653 void testSetEmptyHeaderWhenPartlyShownNotClipped()

654 {

655 changeContentY(30);

656 lvwph->setHeader(nullptr);

657

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

659 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

670 }

671

672 void testSetNullDelegate()

673 {

674 lvwph->setDelegate(nullptr);

675

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

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

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

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

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

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

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

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

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

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

686 QVERIFY(lvwph->isAtYBeginning());

687 QVERIFY(lvwph->isAtYEnd());

688 }

689

690 void testInsertItems()

691 {

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

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

694

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

696 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

709 }

710

711 void testInsertItemsOnNotShownPosition()

712 {

713 changeContentY(700);

714

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

716 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

728

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

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

731

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

733 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

745

746 scrollToTop();

747

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

749 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

762 }

763

764 void testInsertItemsAtEndOfViewport()

765 {

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

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

768

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

770 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

782 }

783

784 void testInsertItemsBeforeValidIndex()

785 {

786 changeContentY(520);

787

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

789 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

794 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

801

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

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

804

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

806 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

811 QCOMPARE(lvwph->m_minYExtent, 787.5);

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

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

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

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

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

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

818 }

819

820 void testInsertItemsBeforeViewport()

821 {

822 changeContentY(375);

823

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

825 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

838

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

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

841

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

843 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

856

857 scrollToTop();

858

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

860 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

873 }

874

875 void testInsertItemsAtBottom()

876 {

877 scrollToBottom();

878

879 QVERIFY(lvwph->isAtYEnd());

880

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

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

883

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

885 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

899

900 scrollToBottom();

901

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

903 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

915 QVERIFY(lvwph->isAtYEnd());

916 }

917

918 void testInsertItemAtTop()

919 {

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

921

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

923 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

935 QVERIFY(lvwph->isAtYBeginning());

936 }

937

938 void testInsertItem10SmallItemsAtTopWhenAtBottom()

939 {

940 scrollToBottom();

941

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

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

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

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

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

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

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

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

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

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

952

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

954 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

965

966 changeContentY(-1700);

967

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

969 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

989 }

990

991 void testRemoveItemsAtTop()

992 {

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

994

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

996 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1007 QVERIFY(lvwph->isAtYBeginning());

1008 }

1009

1010 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1011 {

1012 scrollToBottom();

1013

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

1015

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

1017 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1028 }

1029

1030 void testRemoveLastItemsAtBottom()

1031 {

1032 scrollToBottom();

1033

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

1035

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

1037 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1048 }

1049

1050 void testRemoveItemOutOfViewport()

1051 {

1052 changeContentY(520);

1053

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

1055 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1060 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1067

1068

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

1070

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

1072 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

1084 }

1085

1086 void testMoveFirstItems()

1087 {

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

1089

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

1091 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

1103

1104 }

1105

1106 void testMoveFirstOutOfVisibleItems()

1107 {

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

1109

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

1111 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1122

1123 }

1124

1125 void testMoveFirstToLastAtBottom()

1126 {

1127 scrollToBottom();

1128

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

1130 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1141

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

1143

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

1145 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

1158 }

1159

1160 void testChangeSizeVisibleItemNotOnViewport()

1161 {

1162 changeContentY(440);

1163

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

1165 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1178

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

1180

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

1182 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1195 }

1196

1197 void testShowHeaderCloseToTheTop()

1198 {

1199 changeContentY(375);

1200

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

1202 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1215

1216 lvwph->showHeader();

1217

1218 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

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

1220 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1233

1234 scrollToTop();

1235

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

1237 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1249 }

1250

1251 void testShowHeaderAtBottom()

1252 {

1253 scrollToBottom();

1254

1255 lvwph->showHeader();

1256

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

1258 QTRY_VERIFY (lvwph->isAtYEnd());

1259 }

1260

1261 void growWindow()

1262 {

1263 view->rootObject()->setHeight(850);

1264

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

1266 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

1270 verifyItem(3, 750., 350., false);

1271 verifyItem(4, 1100., 350., true);

1272 QCOMPARE(lvwph->m_minYExtent, 0.);

1273 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1274 QCOMPARE(lvwph->m_clipItem->clip(), false);

1275 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1276 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1277 QCOMPARE(lvwph->contentY(), 0.);

1278 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1279 }

1280

1281 void growWindowAtBottom()

1282 {

1283 scrollToBottom();

1284

1285 view->rootObject()->setHeight(850);

1286

1287 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1288 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1289 verifyItem(0, -550., 350., true);

1290 verifyItem(1, -200., 350., false);

1291 verifyItem(2, 150, 350., false);

1292 verifyItem(3, 500, 350., false);

1293 QCOMPARE(lvwph->m_minYExtent, 350.);

1294 QCOMPARE(lvwph->m_clipItem->y(), 950.);

1295 QCOMPARE(lvwph->m_clipItem->clip(), false);

1296 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1297 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1298 QCOMPARE(lvwph->contentY(), 950.);

1299 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1300 }

1301

1302private:

1303 QQuickView *view;

1304 ListViewWithPageHeader *lvwph;

1305 QQuickListModel *model;

1306 QQmlComponent *otherDelegate;

1307};

1308

1309QTEST_MAIN(ListViewWithPageHeaderTest)

1310

1311#include "listviewwithpageheadertest.moc"