tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on a3e77fa help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp

1570 lines 60 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#pragma GCC diagnostic push

24#pragma GCC diagnostic ignored "-pedantic"

25#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

26#include <private/qquicklistmodel_p.h>

27#else

28#include <private/qqmllistmodel_p.h>

29#endif

30#include <private/qquickanimation_p.h>

31#include <private/qquickitem_p.h>

32#pragma GCC diagnostic pop

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 }

47 void changeContentY(qreal change)

48 {

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

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

51 const qreal jump = 25;

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

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

54 QTest::qWait(1);

55 }

56 } else {

57 const qreal jump = -25;

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

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

60 QTest::qWait(1);

61 }

62 }

63 lvwph->setContentY(dest);

64 QTest::qWait(1);

65 }

67 void scrollToTop()

68 {

69 const qreal jump = -25;

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

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

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

73 } else {

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

75 }

76 QTest::qWait(1);

77 }

78 }

80 void scrollToBottom()

81 {

82 const qreal jump = 25;

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

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

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

86 } else {

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

88 }

89 QTest::qWait(1);

90 }

91 }

93 void verifyInitialTopPosition()

94 {

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

96 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

108 }

109

110private Q_SLOTS:

111

112 void initTestCase()

113 {

114 }

115

116 void init()

117 {

118 view = new QQuickView();

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

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

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

122#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

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

124#else

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

126#endif

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(-1700);

978

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

980 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1000 }

1001

1002 void testInsertToEmpty()

1003 {

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

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

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

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

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

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

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

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

1012

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

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

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

1016 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1019 }

1020

1021 void testRemoveItemsAtTop()

1022 {

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

1024

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

1026 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1037 QVERIFY(lvwph->isAtYBeginning());

1038 }

1039

1040 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1041 {

1042 scrollToBottom();

1043

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

1045

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

1047 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1058 }

1059

1060 void testRemoveLastItemsAtBottom()

1061 {

1062 scrollToBottom();

1063

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

1065

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

1067 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

1078 }

1079

1080 void testRemoveItemOutOfViewport()

1081 {

1082 changeContentY(520);

1083

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

1085 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1090 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1097

1098

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

1100

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

1102 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1114 }

1115

1116 void testMoveFirstItems()

1117 {

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

1119

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

1121 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1133

1134 }

1135

1136 void testMoveFirstOutOfVisibleItems()

1137 {

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

1139

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

1141 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

1152

1153 }

1154

1155 void testMoveFirstToLastAtBottom()

1156 {

1157 scrollToBottom();

1158

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

1160 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

1171

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

1173

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

1175 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

1188 }

1189

1190 void testChangeSizeVisibleItemNotOnViewport()

1191 {

1192 changeContentY(440);

1193

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

1195 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1208

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

1210

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

1212 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1225 }

1226

1227 void testShowHeaderCloseToTheTop()

1228 {

1229 changeContentY(375);

1230

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

1232 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1245

1246 lvwph->showHeader();

1247

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

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

1250 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

1263

1264 scrollToTop();

1265

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

1267 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1279 }

1280

1281 void testShowHeaderHalfShown()

1282 {

1283#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1284 QSKIP("This test is extremely unstable in 5.0.x");

1285#endif

1286 changeContentY(20);

1287

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

1289 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1290 verifyItem(0, 30., 150., false);

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

1292 verifyItem(2, 380, 350., false);

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

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

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

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

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

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

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

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

1301

1302 lvwph->showHeader();

1303

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

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

1306 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1307 verifyItem(0, -20., 150., false);

1308 verifyItem(1, 130, 200., false);

1309 verifyItem(2, 330, 350., false);

1310 verifyItem(3, 680, 350., true);

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

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

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

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

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

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

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

1318

1319 scrollToTop();

1320

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

1322 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

1330 QCOMPARE(lvwph->m_headerItem->y(), -20.);

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

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

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

1334 }

1335

1336 void testShowHeaderAtBottom()

1337 {

1338 scrollToBottom();

1339

1340 lvwph->showHeader();

1341

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

1343 QTRY_VERIFY (lvwph->isAtYEnd());

1344 }

1345

1346 void growWindow()

1347 {

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

1349

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

1351 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

1355 verifyItem(3, 750., 350., false);

1356 verifyItem(4, 1100., 350., true);

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

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

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

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

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

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

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

1364 }

1365

1366 void growWindowAtBottom()

1367 {

1368 scrollToBottom();

1369

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

1371

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

1373 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1374 verifyItem(0, -550., 350., true);

1375 verifyItem(1, -200., 350., false);

1376 verifyItem(2, 150, 350., false);

1377 verifyItem(3, 500, 350., false);

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

1379 QCOMPARE(lvwph->m_clipItem->y(), 950.);

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

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

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

1383 QCOMPARE(lvwph->contentY(), 950.);

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

1385 }

1386

1387 void testCrashShowHeaderWithNoHeader()

1388 {

1389 lvwph->setHeader(nullptr);

1390 lvwph->showHeader();

1391 }

1392

1393 void testCullOnBottomEdge()

1394 {

1395 changeContentY(200);

1396

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

1398 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1399 verifyItem(0, -150., 150., true);

1400 verifyItem(1, 0., 200., false);

1401 verifyItem(2, 200., 350., false);

1402 verifyItem(3, 550., 350., true);

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

1404 QCOMPARE(lvwph->m_clipItem->y(), 200.);

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

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

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

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

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

1410 }

1411

1412 void testMaximizeVisibleArea()

1413 {

1414 lvwph->maximizeVisibleArea(2);

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

1416

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

1418 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1419 verifyItem(0, -158., 150., true);

1420 verifyItem(1, -8., 200., false);

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

1422 verifyItem(3, 542, 350., true);

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

1424 QCOMPARE(lvwph->m_clipItem->y(), 208.);

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

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

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

1428 QCOMPARE(lvwph->contentY(), 208.);

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

1430 }

1431

1432 void testMaximizeVisibleAreaVisibleItems()

1433 {

1434 lvwph->maximizeVisibleArea(0);

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

1436

1437 verifyInitialTopPosition();

1438

1439 lvwph->maximizeVisibleArea(1);

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

1441

1442 verifyInitialTopPosition();

1443 }

1444

1445 void testMaximizeVisibleAreaInvalidIndexes()

1446 {

1447 lvwph->maximizeVisibleArea(-1);

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

1449

1450 verifyInitialTopPosition();

1451

1452 lvwph->maximizeVisibleArea(1000);

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

1454

1455 verifyInitialTopPosition();

1456

1457 lvwph->maximizeVisibleArea(4);

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

1459

1460 verifyInitialTopPosition();

1461 }

1462

1463 void testMaximizeVisibleAreaBigElement()

1464 {

1465 model->setProperty(2, "size", 4000);

1466 lvwph->maximizeVisibleArea(2);

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

1468

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

1470 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1471 verifyItem(0, -350., 150., true);

1472 verifyItem(1, -200., 200., true);

1473 verifyItem(2, 0, 4000., false);

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

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

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

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

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

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

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

1481 }

1482

1483 void testMaximizeVisibleAreaScrollDown()

1484 {

1485 changeContentY(250);

1486 lvwph->maximizeVisibleArea(1);

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

1488

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

1490 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1491 verifyItem(0, -150., 150., true);

1492 verifyItem(1, 0., 200., false);

1493 verifyItem(2, 200, 350., false);

1494 verifyItem(3, 550, 350., true);

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

1496 QCOMPARE(lvwph->m_clipItem->y(), 200.);

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

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

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

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

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

1502 }

1503

1504 void testMaximizeVisibleAreaScrollDownBigElement()

1505 {

1506 model->setProperty(1, "size", 1000);

1507 changeContentY(1150);

1508 lvwph->maximizeVisibleArea(1);

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

1510

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

1512 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1513 verifyItem(0, -458., 1000., false);

1514 verifyItem(1, 542., 350., true);

1515 QCOMPARE(lvwph->m_minYExtent, 362.5);

1516 QCOMPARE(lvwph->m_clipItem->y(), 658.);

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

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

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

1520 QCOMPARE(lvwph->contentY(), 658.);

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

1522 }

1523

1524 void testMaximizeVisibleAreaBigElementInTheMiddle()

1525 {

1526 model->setProperty(1, "size", 1000);

1527 changeContentY(650);

1528

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

1530 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1531 verifyItem(0, -450., 1000., false);

1532 verifyItem(1, 550., 350., true);

1533 QCOMPARE(lvwph->m_minYExtent, 525.);

1534 QCOMPARE(lvwph->m_clipItem->y(), 650.);

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

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

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

1538 QCOMPARE(lvwph->contentY(), 650.);

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

1540

1541 lvwph->maximizeVisibleArea(1);

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

1543

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

1545 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1546 verifyItem(0, -450., 1000., false);

1547 verifyItem(1, 550., 350., true);

1548 QCOMPARE(lvwph->m_minYExtent, 525.);

1549 QCOMPARE(lvwph->m_clipItem->y(), 650.);

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

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

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

1553 QCOMPARE(lvwph->contentY(), 650.);

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

1555 }

1556

1557private:

1558 QQuickView *view;

1559 ListViewWithPageHeader *lvwph;

1560#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1561 QQuickListModel *model;

1562#else

1563 QQmlListModel *model;

1564#endif

1565 QQmlComponent *otherDelegate;

1566};

1567

1568QTEST_MAIN(ListViewWithPageHeaderTest)

1569

1570#include "listviewwithpageheadertest.moc"