tests/plugins/DashViews/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on a14b4bb help sign in

unity8/tests/plugins/DashViews/listviewwithpageheadersectiontest.cpp

2169 lines 99 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QSignalSpy>

23#include <QtTestGui>

24#pragma GCC diagnostic push

25#pragma GCC diagnostic ignored "-pedantic"

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

27#include <private/qquicklistmodel_p.h>

28#else

29#include <private/qqmllistmodel_p.h>

30#endif

31#include <private/qquickanimation_p.h>

32#include <private/qquickitem_p.h>

33#pragma GCC diagnostic pop

35class ListViewWithPageHeaderTestSection : public QObject

36{

37 Q_OBJECT

39private:

40 void verifyItem(int visibleIndex, qreal pos, qreal height, bool culled, const QString &sectionHeader, bool sectionHeaderCulled)

41 {

42 QTRY_VERIFY(visibleIndex < lvwph->m_visibleItems.count());

43 QTRY_COMPARE(lvwph->m_visibleItems[visibleIndex]->y(), pos);

44 QTRY_COMPARE(lvwph->m_visibleItems[visibleIndex]->height(), height);

45 QCOMPARE(QQuickItemPrivate::get(lvwph->m_visibleItems[visibleIndex]->m_item)->culled, culled);

46 QCOMPARE(section(lvwph->m_visibleItems[visibleIndex]->m_sectionItem), sectionHeader);

47 if (!sectionHeader.isNull()) {

48 QCOMPARE(QQuickItemPrivate::get(lvwph->m_visibleItems[visibleIndex]->m_sectionItem)->culled, sectionHeaderCulled);

49 QCOMPARE(sectionDelegateIndex(lvwph->m_visibleItems[visibleIndex]->m_sectionItem), lvwph->m_firstVisibleIndex + visibleIndex);

50 }

51 }

53 void changeContentY(qreal change)

54 {

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

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

57 const qreal jump = 25;

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

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

60 QTest::qWait(1);

61 }

62 } else {

63 const qreal jump = -25;

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

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

66 QTest::qWait(1);

67 }

68 }

69 lvwph->setContentY(dest);

70 QTest::qWait(1);

71 }

73 void scrollToTop()

74 {

75 const qreal jump = -25;

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

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

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

79 } else {

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

81 }

82 QTest::qWait(1);

83 }

84 }

86 void scrollToBottom()

87 {

88 const qreal jump = 25;

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

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

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

92 } else {

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

94 }

95 QTest::qWait(1);

96 }

97 }

99 void verifyInitialTopPosition()

100 {

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

102 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

103 verifyItem(0, 50., 190., false, "Agressive", false);

104 verifyItem(1, 240., 240., false, "Regular", false);

105 verifyItem(2, 480., 390., false, "Mild", false);

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

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

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

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

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

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

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

113 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

114 }

115

116 QString section(QQuickItem *item)

117 {

118 return item ? QQmlEngine::contextForObject(item)->parentContext()->contextProperty(QLatin1String("section")).toString() : QString();

119 }

120

121 int sectionDelegateIndex(QQuickItem *item)

122 {

123 return item ? QQmlEngine::contextForObject(item)->parentContext()->contextProperty(QLatin1String("delegateIndex")).toInt() : -1;

124 }

125

126private Q_SLOTS:

127

128 void initTestCase()

129 {

130 }

131

132 void init()

133 {

134 view = new QQuickView();

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

136 view->setSource(QUrl::fromLocalFile(DASHVIEWSTEST_FOLDER "/listviewwithpageheadertestsection.qml"));

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

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

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

140#else

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

142#endif

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

144 QVERIFY(lvwph);

145 QVERIFY(model);

146 QVERIFY(otherDelegate);

147 view->show();

148 QTest::qWaitForWindowExposed(view);

149

150 verifyInitialTopPosition();

151 }

152

153 void cleanup()

154 {

155 delete view;

156 }

157

158 void testCreationDeletion()

159 {

160 // Nothing, init/cleanup already tests this

161 }

162

163 void testDrag1PixelUp()

164 {

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

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

167 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

168 verifyItem(0, 49., 190., false, "Agressive", false);

169 verifyItem(1, 239., 240., false, "Regular", false);

170 verifyItem(2, 479., 390., false, "Mild", false);

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

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

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

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

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

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

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

178 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

179 }

180

181 void testHeaderDetachDragDown()

182 {

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

184 QTest::qWait(100);

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

186 QTest::qWait(100);

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

188 QTest::qWait(100);

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

190 QTest::qWait(100);

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

192 QTest::qWait(100);

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

194 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

195 verifyItem(0, 55., 190., false, "Agressive", false);

196 verifyItem(1, 245., 240., false, "Regular", false);

197 verifyItem(2, 485., 390., false, "Mild", false);

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

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

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

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

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

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

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

205 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

206

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

208

209 verifyInitialTopPosition();

210 }

211

212 void testDrag375PixelUp()

213 {

214 changeContentY(375);

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

216 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

217 verifyItem(0, -325., 190., true, "Agressive", true);

218 verifyItem(1, -135, 240., false, "Regular", true);

219 verifyItem(2, 105, 390., false, "Mild", false);

220 verifyItem(3, 495, 390., false, "Bold", false);

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

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

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

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

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

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

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

228 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

229 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

230 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

231 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

232 }

233

234 void testDrag520PixelUp()

235 {

236 changeContentY(520);

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

238 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

239 verifyItem(0, -280., 240., true, "Regular", true);

240 verifyItem(1, -40, 390., false, "Mild", true);

241 verifyItem(2, 350, 390., false, "Bold", false);

242 verifyItem(3, 740, 350., true, QString(), true);

243 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

250 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

251 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

252 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

253 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

254 }

255

256 void testDragHeaderUpThenShow()

257 {

258 changeContentY(120);

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

260 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

261 verifyItem(0, -70., 190., false, "Agressive", true);

262 verifyItem(1, 120., 240., false, "Regular", false);

263 verifyItem(2, 360., 390., false, "Mild", false);

264 verifyItem(3, 750., 390., true, "Bold", true);

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

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

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

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

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

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

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

272 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

273 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

274 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

275 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

276

277 changeContentY(-30);

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

279 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

280 verifyItem(0, -70., 190., false, "Agressive", true);

281 verifyItem(1, 120., 240., false, "Regular", false);

282 verifyItem(2, 360., 390., false, "Mild", false);

283 verifyItem(3, 750., 390., true, "Bold", true);

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

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

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

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

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

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

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

291 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

292 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

293 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

294 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

295 }

296

297 void testDragHeaderUpThenShowWithoutHidingTotally()

298 {

299 changeContentY(10);

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

301 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

302 verifyItem(0, 40., 190., false, "Agressive", false);

303 verifyItem(1, 230., 240., false, "Regular", false);

304 verifyItem(2, 470., 390., false, "Mild", false);

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

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

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

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

312 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

313

314 changeContentY(-1);

315

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

317 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

318 verifyItem(0, 41., 190., false, "Agressive", false);

319 verifyItem(1, 231., 240., false, "Regular", false);

320 verifyItem(2, 471., 390., false, "Mild", false);

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

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

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

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

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

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

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

328 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

329 }

330

331 void testPositionAtBeginningIndex0Visible()

332 {

333 changeContentY(375);

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

335 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

336 verifyItem(0, -325., 190., true, "Agressive", true);

337 verifyItem(1, -135, 240., false, "Regular", true);

338 verifyItem(2, 105, 390., false, "Mild", false);

339 verifyItem(3, 495, 390., false, "Bold", false);

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

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

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

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

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

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

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

347 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

348 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

349 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

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

351

352 lvwph->positionAtBeginning();

353

354 verifyInitialTopPosition();

355 }

356

357 void testPositionAtBeginningIndex0NotVisible()

358 {

359 changeContentY(520);

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

361 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

362 verifyItem(0, -280., 240., true, "Regular", true);

363 verifyItem(1, -40, 390., false, "Mild", true);

364 verifyItem(2, 350, 390., false, "Bold", false);

365 verifyItem(3, 740, 350., true, QString(), true);

366 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

373 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

374 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

375 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

376 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

377

378 lvwph->positionAtBeginning();

379

380 verifyInitialTopPosition();

381 }

382

383 void testIndex0GrowOnScreen()

384 {

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

386

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

388 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

389 verifyItem(0, 50., 440., false, "Agressive", false);

390 verifyItem(1, 490., 240., false, "Regular", false);

391 verifyItem(2, 730., 390., true, "Mild", true);

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

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

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

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

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

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

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

399 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

400 }

401

402 void testIndex0GrowOffScreen()

403 {

404 changeContentY(375);

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

406 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

407 verifyItem(0, -325., 190., true, "Agressive", true);

408 verifyItem(1, -135, 240., false, "Regular", true);

409 verifyItem(2, 105, 390., false, "Mild", false);

410 verifyItem(3, 495, 390., false, "Bold", false);

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

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

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

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

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

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

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

418 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

419 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

420 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

421 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

422

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

424

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

426 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

427 verifyItem(0, -575., 440., true, "Agressive", true);

428 verifyItem(1, -135, 240., false, "Regular", true);

429 verifyItem(2, 105, 390., false, "Mild", false);

430 verifyItem(3, 495, 390., false, "Bold", false);

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

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

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

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

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

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

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

438 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

439 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

440 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

441 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

442

443 scrollToTop();

444

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

446 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

447 verifyItem(0, 50., 440., false, "Agressive", false);

448 verifyItem(1, 490, 240., false, "Regular", false);

449 verifyItem(2, 730, 390., true, "Mild", true);

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

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

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

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

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

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

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

457 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

458

459 changeContentY(30);

460

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

462 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

463 verifyItem(0, 20., 440., false, "Agressive", false);

464 verifyItem(1, 460, 240., false, "Regular", false);

465 verifyItem(2, 700, 390., true, "Mild", true);

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

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

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

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

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

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

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

473 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

474 }

475

476 void testIndex0GrowNotCreated()

477 {

478 changeContentY(520);

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

480 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

481 verifyItem(0, -280., 240., true, "Regular", true);

482 verifyItem(1, -40, 390., false, "Mild", true);

483 verifyItem(2, 350, 390., false, "Bold", false);

484 verifyItem(3, 740, 350., true, QString(), true);

485 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

492 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

493 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

494 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

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

496

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

498

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

500 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

501 verifyItem(0, -280., 240., true, "Regular", true);

502 verifyItem(1, -40, 390., false, "Mild", true);

503 verifyItem(2, 350, 390., false, "Bold", false);

504 verifyItem(3, 740, 350., true, QString(), true);

505 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

512 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

513 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

514 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

515 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

516

517 scrollToTop();

518

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

520 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

521 verifyItem(0, 50., 440., false, "Agressive", false);

522 verifyItem(1, 490, 240., false, "Regular", false);

523 verifyItem(2, 730, 390., true, "Mild", true);

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

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

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

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

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

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

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

531 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

532 }

533

534 void testShowHideShowHeaderAtBottom()

535 {

536 scrollToBottom();

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

538 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

539 verifyItem(0, -588., 390., true, "Bold", true);

540 verifyItem(1, -198, 350., false, QString(), true);

541 verifyItem(2, 152, 390., false, "Lazy", false);

542 QCOMPARE(lvwph->m_minYExtent, 310.);

543 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

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

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

547 QCOMPARE(lvwph->contentY(), 1458.);

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

549 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

550 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

551 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

552 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

553

554 changeContentY(-30);

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

556 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

557 verifyItem(0, -588., 390., true, "Bold", true);

558 verifyItem(1, -198, 350., false, QString(), true);

559 verifyItem(2, 152, 390., false, "Lazy", false);

560 QCOMPARE(lvwph->m_minYExtent, 310.);

561 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

563 QCOMPARE(lvwph->m_headerItem->y(), 1408.);

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

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

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

567 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

568 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

569 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

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

571

572 changeContentY(30);

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

574 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

575 verifyItem(0, -588., 390., true, "Bold", true);

576 verifyItem(1, -198, 350., false, QString(), true);

577 verifyItem(2, 152, 390., false, "Lazy", false);

578 QCOMPARE(lvwph->m_minYExtent, 310.);

579 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

581 QCOMPARE(lvwph->m_headerItem->y(), -310.);

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

583 QCOMPARE(lvwph->contentY(), 1458.);

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

585 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

586 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

587 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

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

589

590 changeContentY(-30);

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

592 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

593 verifyItem(0, -588., 390., true, "Bold", true);

594 verifyItem(1, -198, 350., false, QString(), true);

595 verifyItem(2, 152, 390., false, "Lazy", false);

596 QCOMPARE(lvwph->m_minYExtent, 310.);

597 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

599 QCOMPARE(lvwph->m_headerItem->y(), 1408.);

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

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

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

603 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

604 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

605 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

606 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

607 }

608

609 void testChangeDelegateAtBottom()

610 {

611 scrollToBottom();

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

613 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

614 verifyItem(0, -588., 390., true, "Bold", true);

615 verifyItem(1, -198, 350., false, QString(), true);

616 verifyItem(2, 152, 390., false, "Lazy", false);

617 QCOMPARE(lvwph->m_minYExtent, 310.);

618 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

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

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

622 QCOMPARE(lvwph->contentY(), 1458.);

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

624 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

625 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

626 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

627 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

628

629 lvwph->setDelegate(otherDelegate);

630

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

632 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

633 verifyItem(0, 50., 75., false, "Agressive", false);

634 verifyItem(1, 125, 75., false, "Regular", false);

635 verifyItem(2, 200, 75., false, "Mild", false);

636 verifyItem(3, 275, 75., false, "Bold", false);

637 verifyItem(4, 350, 35., false, QString(), true);

638 verifyItem(5, 385, 75., false, "Lazy", false);

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

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

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

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

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

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

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

646 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

647 }

648

649 void testSetEmptyHeaderAtTop()

650 {

651 lvwph->setHeader(nullptr);

652

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

654 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

655 verifyItem(0, 0., 190., false, "Agressive", false);

656 verifyItem(1, 190., 240., false, "Regular", false);

657 verifyItem(2, 430., 390., false, "Mild", false);

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

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

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

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

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

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

664 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

665 }

666

667 void testSetEmptyHeaderAtBottom()

668 {

669 scrollToBottom();

670 lvwph->setHeader(nullptr);

671

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

673 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

674 verifyItem(0, -588., 390., true, "Bold", true);

675 verifyItem(1, -198, 350., false, QString(), true);

676 verifyItem(2, 152, 390., false, "Lazy", false);

677 QCOMPARE(lvwph->m_minYExtent, 260.);

678 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

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

681 QCOMPARE(lvwph->contentY(), 1458.);

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

683 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

684 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

685 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

686 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

687

688 scrollToTop();

689

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

691 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

692 verifyItem(0, 0., 190., false, "Agressive", false);

693 verifyItem(1, 190., 240., false, "Regular", false);

694 verifyItem(2, 430., 390., false, "Mild", false);

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

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

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

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

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

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

701 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

702 }

703

704 void testSetEmptyHeaderWhenPartlyShownClipped()

705 {

706 scrollToBottom();

707 changeContentY(-30);

708 lvwph->setHeader(nullptr);

709

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

711 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

712 verifyItem(0, -588., 390., true, "Bold", true);

713 verifyItem(1, -198, 350., false, QString(), true);

714 verifyItem(2, 152, 390., false, "Lazy", false);

715 QCOMPARE(lvwph->m_minYExtent, 290.);

716 QCOMPARE(lvwph->m_clipItem->y(), 1428.);

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

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

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

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

721 QTRY_VERIFY(lvwph->isAtYEnd());

722 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

723 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

724 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

725 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

726

727 scrollToTop();

728

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

730 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

731 verifyItem(0, 0., 190., false, "Agressive", false);

732 verifyItem(1, 190., 240., false, "Regular", false);

733 verifyItem(2, 430., 390., false, "Mild", false);

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

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

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

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

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

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

740 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

741 }

742

743 void testSetEmptyHeaderWhenPartlyShownNotClipped()

744 {

745 changeContentY(30);

746 lvwph->setHeader(nullptr);

747

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

749 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

750 verifyItem(0, -30., 190., false, "Agressive", true);

751 verifyItem(1, 160., 240., false, "Regular", false);

752 verifyItem(2, 400., 390., false, "Mild", false);

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

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

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

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

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

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

759 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

760 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

761 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

762 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

763 }

764

765 void testSetNullDelegate()

766 {

767 lvwph->setDelegate(nullptr);

768

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

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

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

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

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

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

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

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

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

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

779 QVERIFY(lvwph->isAtYBeginning());

780 QVERIFY(lvwph->isAtYEnd());

781 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

782 }

783

784 void testInsertItems()

785 {

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

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

788

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

790 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

791 verifyItem(0, 50., 190., false, "Agressive", false);

792 verifyItem(1, 240., 165., false, "Regular", false);

793 verifyItem(2, 405., 140., false, "Agressive", false);

794 verifyItem(3, 545., 240., true, "Regular", true);

795 verifyItem(4, 785., 390., true, "Mild", true);

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

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

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

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

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

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

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

803 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

804 }

805

806 void testInsertItemsStealSectionItem()

807 {

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

809

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

811 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

812 verifyItem(0, 50., 190., false, "Agressive", false);

813 verifyItem(1, 240., 165., false, "Regular", false);

814 verifyItem(2, 405., 200., false, QString(), true);

815 verifyItem(3, 605., 390., true, "Mild", true);

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

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

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

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

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

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

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

823 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

824 }

825

826

827 void testInsertItemsOnNotShownPosition()

828 {

829 changeContentY(800);

830

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

832 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

833 verifyItem(0, -320., 390., false, "Mild", true);

834 verifyItem(1, 70, 390., false, "Bold", false);

835 verifyItem(2, 460, 350., false, QString(), false);

836 verifyItem(3, 810, 390., true, "Lazy", true);

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

838 QCOMPARE(lvwph->m_clipItem->y(), 800.);

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

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

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

842 QCOMPARE(lvwph->contentY(), 800.);

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

844 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

845 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

846 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

847 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

848

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

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

851

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

853 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

854 verifyItem(0, -320., 390., false, "Mild", true);

855 verifyItem(1, 70, 390., false, "Bold", false);

856 verifyItem(2, 460, 350., false, QString(), false);

857 verifyItem(3, 810, 390., true, "Lazy", true);

858 QCOMPARE(lvwph->m_minYExtent, 1090.);

859 QCOMPARE(lvwph->m_clipItem->y(), 800.);

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

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

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

863 QCOMPARE(lvwph->contentY(), 800.);

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

865 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

866 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

867 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 4);

868 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

869

870 scrollToTop();

871

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

873 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

874 verifyItem(0, 50., 190., false, "Agressive", false);

875 verifyItem(1, 240., 165., false, "Regular", false);

876 verifyItem(2, 405., 140., false, "Agressive", false);

877 verifyItem(3, 545., 240., true, "Regular", true);

878 verifyItem(4, 785., 390., true, "Mild", true);

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

880 QCOMPARE(lvwph->m_clipItem->y(), -305.);

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

882 QCOMPARE(lvwph->m_headerItem->y(), -305.);

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

884 QCOMPARE(lvwph->contentY(), -305.);

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

886 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

887 }

888

889 void testInsertItemsAtEndOfViewport()

890 {

891 changeContentY(60);

892

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

894 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

895 verifyItem(0, -10., 190., false, "Agressive", true);

896 verifyItem(1, 180., 240., false, "Regular", false);

897 verifyItem(2, 420., 390., false, "Mild", false);

898 verifyItem(3, 810., 390., true, "Bold", true);

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

900 QCOMPARE(lvwph->m_clipItem->y(), 60.);

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

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

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

904 QCOMPARE(lvwph->contentY(), 60.);

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

906 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

907 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

908 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

909 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

910

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

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

913

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

915 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

916 verifyItem(0, -10., 190., false, "Agressive", true);

917 verifyItem(1, 180., 240., false, "Regular", false);

918 verifyItem(2, 420., 390., false, "Mild", false);

919 verifyItem(3, 810., 165., true, "Regular", true);

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

921 QCOMPARE(lvwph->m_clipItem->y(), 60.);

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

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

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

925 QCOMPARE(lvwph->contentY(), 60.);

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

927 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

928 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

929 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

930 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

931 }

932

933 void testInsertItemsBeforeValidIndex()

934 {

935 changeContentY(520);

936

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

938 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

939 verifyItem(0, -280., 240., true, "Regular", true);

940 verifyItem(1, -40, 390., false, "Mild", true);

941 verifyItem(2, 350, 390., false, "Bold", false);

942 verifyItem(3, 740, 350., true, QString(), true);

943 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

950 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

951 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

952 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

953 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

954

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

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

957

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

959 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

960 verifyItem(0, -280., 240., true, "Regular", true);

961 verifyItem(1, -40, 390., false, "Mild", true);

962 verifyItem(2, 350, 390., false, "Bold", false);

963 verifyItem(3, 740, 350., true, QString(), true);

964 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

971 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

972 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

973 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 4);

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

975 }

976

977 void testInsertItemsBeforeViewport()

978 {

979 changeContentY(375);

980

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

982 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

983 verifyItem(0, -325., 190., true, "Agressive", true);

984 verifyItem(1, -135, 240., false, "Regular", true);

985 verifyItem(2, 105, 390., false, "Mild", false);

986 verifyItem(3, 495, 390., false, "Bold", false);

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

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

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

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

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

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

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

994 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

995 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

996 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

997 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

998

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

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

1001

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

1003 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1004 verifyItem(0, -275., 140., true, "Agressive", true);

1005 verifyItem(1, -135., 240., false, "Regular", true);

1006 verifyItem(2, 105, 390., false, "Mild", false);

1007 verifyItem(3, 495, 390., false, "Bold", false);

1008 QCOMPARE(lvwph->m_minYExtent, 530.);

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

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

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

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

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

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

1015 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1016 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1017 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1018 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1019

1020 scrollToTop();

1021

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

1023 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1024 verifyItem(0, 50., 190., false, "Agressive", false);

1025 verifyItem(1, 240., 165., false, "Regular", false);

1026 verifyItem(2, 405., 140., false, "Agressive", false);

1027 verifyItem(3, 545., 240., true, "Regular", true);

1028 verifyItem(4, 785., 390., true, "Mild", true);

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

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

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

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

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

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

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

1036 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1037 }

1038

1039 void testInsertItemsAtBottom()

1040 {

1041 scrollToBottom();

1042

1043 QVERIFY(lvwph->isAtYEnd());

1044

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

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

1047

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

1049 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1050 verifyItem(0, -588., 390., true, "Bold", true);

1051 verifyItem(1, -198, 350., false, QString(), true);

1052 verifyItem(2, 152, 390., false, "Lazy", false);

1053 verifyItem(3, 542, 165., true, "Regular", true);

1054 verifyItem(4, 707, 140., true, "Agressive", true);

1055 QCOMPARE(lvwph->m_minYExtent, 41.);

1056 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

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

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

1060 QCOMPARE(lvwph->contentY(), 1458.);

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

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

1063 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1064 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1065 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1066 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1067

1068 scrollToBottom();

1069

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

1071 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

1072 verifyItem(0, -503., 350., true, QString(), true);

1073 verifyItem(1, -153, 390., false, "Lazy", true);

1074 verifyItem(2, 237, 165., false, "Regular", false);

1075 verifyItem(3, 402, 140., false, "Agressive", false);

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

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

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

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

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

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

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

1083 QVERIFY(lvwph->isAtYEnd());

1084 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1085 QCOMPARE(section(lvwph->m_topSectionItem), QString("Lazy"));

1086 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 5);

1087 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1088 }

1089

1090 void testInsertItemAtTop()

1091 {

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

1093

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

1095 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1096 verifyItem(0, 50., 115., false, "Agressive", false);

1097 verifyItem(1, 165., 150., false, QString(), false);

1098 verifyItem(2, 315., 240., false, "Regular", false);

1099 verifyItem(3, 555., 390., true, "Mild", true);

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

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

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

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

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

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

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

1107 QVERIFY(lvwph->isAtYBeginning());

1108 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1109 }

1110

1111 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1112 {

1113 scrollToBottom();

1114

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

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

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

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

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

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

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

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

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

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

1125

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

1127 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

1128 verifyItem(0, -588., 390., true, "Bold", true);

1129 verifyItem(1, -198, 350., false, QString(), true);

1130 verifyItem(2, 152, 390., false, "Lazy", false);

1131 QCOMPARE(lvwph->m_minYExtent, 12230./3.);

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

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

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

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

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

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

1138 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1139 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1140 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 13);

1141 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1142

1143 changeContentY(-1700);

1144

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

1146 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1147 verifyItem(0, -323., 75., true, QString(), true);

1148 verifyItem(1, -248., 115., true, "Regular", true);

1149 verifyItem(2, -133., 75., true, QString(), true);

1150 verifyItem(3, -58., 75., false, QString(), true);

1151 verifyItem(4, 17., 115., false, "Agressive", false);

1152 verifyItem(5, 132., 75., false, QString(), true);

1153 verifyItem(6, 207., 75., false, QString(), true);

1154 verifyItem(7, 282., 150., false, QString(), true);

1155 verifyItem(8, 432., 240., false, "Regular", false);

1156 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

1163 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1164 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1165 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 4);

1166 QCOMPARE(lvwph->m_topSectionItem->y(), -23.);

1167 }

1168

1169 void testInsertToEmpty()

1170 {

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

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

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

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

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

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

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

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

1179

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

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

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

1183 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1184 verifyItem(0, 50., 140., false, "Agressive", false);

1185 verifyItem(1, 190., 165., false, "Regular", false);

1186 }

1187

1188 void testRemoveItemsAtTop()

1189 {

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

1191

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

1193 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1194 verifyItem(0, 50., 390., false, "Mild", false);

1195 verifyItem(1, 440., 390., false, "Bold", false);

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

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

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

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

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

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

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

1203 QVERIFY(lvwph->isAtYBeginning());

1204 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1205 }

1206

1207 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1208 {

1209 scrollToBottom();

1210

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

1212

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

1214 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1215 verifyItem(0, -588., 390., true, "Bold", true);

1216 verifyItem(1, -198, 350., false, QString(), true);

1217 verifyItem(2, 152, 390., false, "Lazy", false);

1218 QCOMPARE(lvwph->m_minYExtent, -1330./3.);

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

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

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

1225 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1226 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1227 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1228 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1229 }

1230

1231 void testRemoveLastItemsAtBottom()

1232 {

1233 scrollToBottom();

1234

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

1236

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

1238 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1239 verifyItem(0, -478., 240., true, "Regular", true);

1240 verifyItem(1, -238, 390., false, "Mild", true);

1241 verifyItem(2, 152, 390., false, "Bold", false);

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

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

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

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

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

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

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

1249 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1250 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1251 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1252 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1253 }

1254

1255 void testRemoveItemOutOfViewport()

1256 {

1257 changeContentY(520);

1258

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

1260 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1261 verifyItem(0, -280., 240., true, "Regular", true);

1262 verifyItem(1, -40, 390., false, "Mild", true);

1263 verifyItem(2, 350, 390., false, "Bold", false);

1264 verifyItem(3, 740, 350., true, QString(), true);

1265 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

1272 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1273 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1274 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1275 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1276

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

1278

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

1280 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1281 verifyItem(0, -230., 190., true, "Agressive", true);

1282 verifyItem(1, -40, 390., false, "Mild", true);

1283 verifyItem(2, 350, 390., false, "Bold", false);

1284 verifyItem(3, 740, 350., true, QString(), true);

1285 QCOMPARE(lvwph->m_minYExtent, -240.);

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

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

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

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

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

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

1292 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1293 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1294 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1295 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1296 }

1297

1298 void testRemoveFirstOfCategory()

1299 {

1300 changeContentY(520);

1301

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

1303 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1304 verifyItem(0, -280., 240., true, "Regular", true);

1305 verifyItem(1, -40, 390., false, "Mild", true);

1306 verifyItem(2, 350, 390., false, "Bold", false);

1307 verifyItem(3, 740, 350., true, QString(), true);

1308 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

1315 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1316 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1317 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1318 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1319

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

1321

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

1323 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1324 verifyItem(0, -280., 240., true, "Regular", true);

1325 verifyItem(1, -40, 390., false, "Mild", true);

1326 verifyItem(2, 350, 390., false, "Bold", false);

1327 verifyItem(3, 740, 390., true, "Lazy", true);

1328 QCOMPARE(lvwph->m_minYExtent, 162.5);

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

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

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

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

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

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

1335 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1336 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1337 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1338 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1339 }

1340

1341 void testAddSecondToCulledCategoryOfTwo()

1342 {

1343 // Do some setup

1344 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1345 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1346

1347 changeContentY(200);

1348

1349 // Very the items are culled

1350 verifyItem(0, -150., 65., true, "Agressive", true);

1351 verifyItem(1, -85, 25., true, QString(), true);

1352

1353 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1354

1355 // Very the new item is there correctly

1356 verifyItem(0, -175., 65., true, "Agressive", true);

1357 verifyItem(1, -110, 25., true, QString(), true);

1358 verifyItem(2, -85, 25., true, QString(), true);

1359 }

1360

1361 void testMoveFirstItems()

1362 {

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

1364

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

1366 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1367 verifyItem(0, 50., 240., false, "Regular", false);

1368 verifyItem(1, 290., 190., false, "Agressive", false);

1369 verifyItem(2, 480., 390., false, "Mild", false);

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

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

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

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

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

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

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

1377 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1378 }

1379

1380 void testMoveFirstOutOfVisibleItems()

1381 {

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

1383

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

1385 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1386 verifyItem(0, 50., 240., false, "Regular", false);

1387 verifyItem(1, 290., 390., false, "Mild", false);

1388 verifyItem(2, 680., 390., true, "Bold", true);

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

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

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

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

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

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

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

1396 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1397 }

1398

1399 void testMoveFirstToLastAtBottom()

1400 {

1401 scrollToBottom();

1402

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

1404 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1405 verifyItem(0, -588., 390., true, "Bold", true);

1406 verifyItem(1, -198, 350., false, QString(), true);

1407 verifyItem(2, 152, 390., false, "Lazy", false);

1408 QCOMPARE(lvwph->m_minYExtent, 310.);

1409 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

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

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

1413 QCOMPARE(lvwph->contentY(), 1458.);

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

1415 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1416 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1417 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1418 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1419

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

1421

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

1423 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1424 verifyItem(0, -588., 390., true, "Bold", true);

1425 verifyItem(1, -198, 350., false, QString(), true);

1426 verifyItem(2, 152, 390., false, "Lazy", false);

1427 verifyItem(3, 542, 190., true, "Agressive", true);

1428 QCOMPARE(lvwph->m_minYExtent, -160.);

1429 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

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

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

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

1433 QCOMPARE(lvwph->contentY(), 1458.);

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

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

1436 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1437 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1438 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1439 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1440 }

1441

1442 void testChangeSizeVisibleItemNotOnViewport()

1443 {

1444 changeContentY(490);

1445

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

1447 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1448 verifyItem(0, -440., 190., true, "Agressive", true);

1449 verifyItem(1, -250., 240., true, "Regular", true);

1450 verifyItem(2, -10, 390., false, "Mild", true);

1451 verifyItem(3, 380, 390., false, "Bold", false);

1452 verifyItem(4, 770, 350., true, QString(), true);

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

1454 QCOMPARE(lvwph->m_clipItem->y(), 490.);

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

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

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

1458 QCOMPARE(lvwph->contentY(), 490.);

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

1460 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1461 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1462 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1463 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1464

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

1466

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

1468 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1469 verifyItem(0, -340., 190., true, "Agressive", true);

1470 verifyItem(1, -150., 140., true, "Regular", true);

1471 verifyItem(2, -10, 390., false, "Mild", true);

1472 verifyItem(3, 380, 390., false, "Bold", false);

1473 verifyItem(4, 770, 350., true, QString(), true);

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

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

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

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

1481 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1482 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1483 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1484 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1485 }

1486

1487 void testShowHeaderHalfShown()

1488 {

1489 changeContentY(20);

1490

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

1492 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1493 verifyItem(0, 30., 190., false, "Agressive", false);

1494 verifyItem(1, 220, 240., false, "Regular", false);

1495 verifyItem(2, 460, 390., false, "Mild", false);

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

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

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

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

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

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

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

1503 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1504

1505 lvwph->showHeader();

1506

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

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

1509 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1510 verifyItem(0, -20., 190., false, "Agressive", true);

1511 verifyItem(1, 170, 240., false, "Regular", false);

1512 verifyItem(2, 410, 390., false, "Mild", false);

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

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

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

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

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

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

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

1520 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1521 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1522 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1523 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1524

1525 scrollToTop();

1526

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

1528 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1529 verifyItem(0, 50., 190., false, "Agressive", false);

1530 verifyItem(1, 240., 240., false, "Regular", false);

1531 verifyItem(2, 480., 390., false, "Mild", false);

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

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

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

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

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

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

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

1539 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1540 }

1541

1542 void testShowHeaderCloseToTheTop()

1543 {

1544 changeContentY(375);

1545

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

1547 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1548 verifyItem(0, -325., 190., true, "Agressive", true);

1549 verifyItem(1, -135, 240., false, "Regular", true);

1550 verifyItem(2, 105, 390., false, "Mild", false);

1551 verifyItem(3, 495, 390., false, "Bold", false);

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

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

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

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

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

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

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

1559 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1560 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1561 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1562 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1563

1564 lvwph->showHeader();

1565

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

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

1568 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1569 verifyItem(0, -375., 190., true, "Agressive", true);

1570 verifyItem(1, -185, 240., false, "Regular", true);

1571 verifyItem(2, 55, 390., false, "Mild", false);

1572 verifyItem(3, 445, 390., false, "Bold", false);

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

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

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

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

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

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

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

1580 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1581 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1582 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1583 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1584

1585 scrollToTop();

1586

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

1588 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1589 verifyItem(0, 50., 190., false, "Agressive", false);

1590 verifyItem(1, 240., 240., false, "Regular", false);

1591 verifyItem(2, 480., 390., false, "Mild", false);

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

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

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

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

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

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

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

1599 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1600 }

1601

1602 void testShowHeaderAtBottom()

1603 {

1604 scrollToBottom();

1605

1606 lvwph->showHeader();

1607

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

1609 QTRY_VERIFY (lvwph->isAtYEnd());

1610 }

1611

1612 void growWindow()

1613 {

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

1615

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

1617 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1618 verifyItem(0, 50., 190., false, "Agressive", false);

1619 verifyItem(1, 240., 240., false, "Regular", false);

1620 verifyItem(2, 480., 390., false, "Mild", false);

1621 verifyItem(3, 870., 390., true, "Bold", true);

1622 verifyItem(4, 1260., 350., true, QString(), true);

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

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

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

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

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

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

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

1630 }

1631

1632 void growWindowAtBottom()

1633 {

1634 // Need a bunch small items at the bottom to trigger the problem

1635 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1636 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1637 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1638 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1639 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1640 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1643 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1644 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1645 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1646 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1647 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1648 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1649 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1650 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1651 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1652 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1653 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1654 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1655

1656 scrollToBottom();

1657

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

1659

1660 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1661 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1662 verifyItem(0, -660., 390., true, "Lazy", true);

1663 verifyItem(1, -270., 90., true, "Agressive", true);

1664 verifyItem(2, -180, 50., true, QString(), true);

1665 verifyItem(3, -130, 50., true, QString(), true);

1666 verifyItem(4, -80, 50., true, QString(), true);

1667 verifyItem(5, -30, 50., false, QString(), true);

1668 verifyItem(6, 20, 50., false, QString(), true);

1669 verifyItem(7, 70, 50., false, QString(), true);

1670 verifyItem(8, 120, 50., false, QString(), true);

1671 verifyItem(9, 170, 90., false, "Regular", false);

1672 verifyItem(10, 260, 50., false, QString(), true);

1673 verifyItem(11, 310, 50., false, QString(), true);

1674 verifyItem(12, 360, 50., false, QString(), true);

1675 verifyItem(13, 410, 50., false, QString(), true);

1676 verifyItem(14, 460, 50., false, QString(), true);

1677 verifyItem(15, 510, 90., false, "Agressive", false);

1678 verifyItem(16, 600, 50., false, QString(), true);

1679 verifyItem(17, 650, 50., false, QString(), true);

1680 verifyItem(18, 700, 50., false, QString(), true);

1681 verifyItem(19, 750, 50., false, QString(), true);

1682 verifyItem(20, 800, 50., false, QString(), true);

1683 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1684 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

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

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

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

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

1689 }

1690

1691 void testCullOnBottomEdge()

1692 {

1693 changeContentY(240);

1694

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

1696 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1697 verifyItem(0, -190., 190., true, "Agressive", true);

1698 verifyItem(1, 0., 240., false, "Regular", false);

1699 verifyItem(2, 240., 390., false, "Mild", false);

1700 verifyItem(3, 630., 390., true, "Bold", true);

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

1702 QCOMPARE(lvwph->m_clipItem->y(), 240.);

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

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

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

1706 QCOMPARE(lvwph->contentY(), 240.);

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

1708 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1709 }

1710

1711 void testSectionItemCullOnFirstSectionItemTopEdge()

1712 {

1713 changeContentY(50);

1714

1715 verifyItem(0, 0., 190., false, "Agressive", false);

1716 verifyItem(1, 190., 240., false, "Regular", false);

1717 verifyItem(2, 430., 390., false, "Mild", false);

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

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

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

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

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

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

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

1725 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1726 }

1727

1728 void testSectionItemCullOnSecondSectionItemTopEdge()

1729 {

1730 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1731 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1732

1733 changeContentY(5);

1734

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

1736 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1737 verifyItem(0, 45., 90., false, "Agressive", false);

1738 verifyItem(1, 135., 50., false, QString(), false);

1739 verifyItem(2, 185., 150., false, QString(), false);

1740 verifyItem(3, 335., 240., false, "Regular", false);

1741 verifyItem(4, 575., 390., true, "Mild", true);

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

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

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

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

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

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

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

1749 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1750

1751 changeContentY(135);

1752

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

1754 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1755 verifyItem(0, -90., 90., true, "Agressive", true);

1756 verifyItem(1, 0., 50., false, QString(), false);

1757 verifyItem(2, 50., 150., false, QString(), false);

1758 verifyItem(3, 200., 240., false, "Regular", false);

1759 verifyItem(4, 440., 390., false, "Mild", false);

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

1761 QCOMPARE(lvwph->m_clipItem->y(), 140.);

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

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

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

1765 QCOMPARE(lvwph->contentY(), 140.);

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

1767 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1768 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1769 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1770 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1771 }

1772

1773 void testMaximizeVisibleArea()

1774 {

1775 bool res = lvwph->maximizeVisibleArea(2);

1776 QVERIFY(res);

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

1778

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

1780 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1781 verifyItem(0, -278., 190., true, "Agressive", true);

1782 verifyItem(1, -88., 240., false, "Regular", true);

1783 verifyItem(2, 152, 390., false, "Mild", false);

1784 verifyItem(3, 542, 390., true, "Bold", true);

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

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

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

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

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

1790 QCOMPARE(lvwph->contentY(), 328.);

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

1792 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1793 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1794 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1795 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1796 }

1797

1798 void testMaximizeVisibleAreaVisibleItems()

1799 {

1800 bool res = lvwph->maximizeVisibleArea(0);

1801 QVERIFY(res);

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

1803

1804 verifyInitialTopPosition();

1805

1806 res = lvwph->maximizeVisibleArea(1);

1807 QVERIFY(res);

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

1809

1810 verifyInitialTopPosition();

1811 }

1812

1813 void testMaximizeVisibleAreaInvalidIndexes()

1814 {

1815 bool res = lvwph->maximizeVisibleArea(-1);

1816 QVERIFY(!res);

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

1818

1819 verifyInitialTopPosition();

1820

1821 res = lvwph->maximizeVisibleArea(1000);

1822 QVERIFY(!res);

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

1824

1825 verifyInitialTopPosition();

1826

1827 res = lvwph->maximizeVisibleArea(3);

1828 QVERIFY(!res);

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

1830

1831 verifyInitialTopPosition();

1832 }

1833

1834 void testMaximizeVisibleAreaBigElement()

1835 {

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

1837 verifyItem(2, 480, 4040., false, "Mild", false);

1838

1839 bool res = lvwph->maximizeVisibleArea(2);

1840 QVERIFY(res);

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

1842

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

1844 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1845 verifyItem(0, -430., 190., true, "Agressive", true);

1846 verifyItem(1, -240., 240., true, "Regular", true);

1847 verifyItem(2, 0, 4040., false, "Mild", false);

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

1849 QCOMPARE(lvwph->m_clipItem->y(), 480.);

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

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

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

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

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

1855 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1856 }

1857

1858 void testMaximizeVisibleAreaScrollDown()

1859 {

1860 changeContentY(350);

1861 bool res = lvwph->maximizeVisibleArea(1);

1862 QVERIFY(res);

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

1864

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

1866 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1867 verifyItem(0, -190., 190., true, "Agressive", true);

1868 verifyItem(1, 0., 240., false, "Regular", false);

1869 verifyItem(2, 240, 390., false, "Mild", false);

1870 verifyItem(3, 630, 390., true, "Bold", true);

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

1872 QCOMPARE(lvwph->m_clipItem->y(), 240.);

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

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

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

1876 QCOMPARE(lvwph->contentY(), 240.);

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

1878 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1879 }

1880

1881 void testMaximizeVisibleAreaScrollDownBigElement()

1882 {

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

1884 changeContentY(1150);

1885 bool res = lvwph->maximizeVisibleArea(1);

1886 QVERIFY(res);

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

1888

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

1890 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1891 verifyItem(0, -498., 1040., false, "Regular", true);

1892 verifyItem(1, 542., 390., true, "Mild", true);

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

1894 QCOMPARE(lvwph->m_clipItem->y(), 738.);

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

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

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

1898 QCOMPARE(lvwph->contentY(), 738.);

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

1900 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1901 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1902 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1903 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1904 }

1905

1906 void testMaximizeVisibleAreaBigElementInTheMiddle()

1907 {

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

1909 changeContentY(650);

1910

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

1912 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1913 verifyItem(0, -410., 1040., false, "Regular", true);

1914 verifyItem(1, 630., 390., true, "Mild", true);

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

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

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

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

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

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

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

1922 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1923 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1924 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1925 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1926

1927 bool res = lvwph->maximizeVisibleArea(1);

1928 QVERIFY(res);

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

1930

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

1932 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1933 verifyItem(0, -410., 1040., false, "Regular", true);

1934 verifyItem(1, 630., 390., true, "Mild", true);

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

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

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

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

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

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

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

1942 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1943 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1944 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1945 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1946 }

1947

1948 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1949 {

1950 changeContentY(430);

1951 changeContentY(-30);

1952

1953 bool res = lvwph->maximizeVisibleArea(1);

1954 QVERIFY(res);

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

1956

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

1958 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1959 verifyItem(0, -190., 190., true, "Agressive", true);

1960 verifyItem(1, 0., 240., false, "Regular", false);

1961 verifyItem(2, 240, 390., false, "Mild", false);

1962 verifyItem(3, 630, 390., true, "Bold", true);

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

1964 QCOMPARE(lvwph->m_clipItem->y(), 240.);

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

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

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

1968 QCOMPARE(lvwph->contentY(), 240.);

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

1970 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1971 }

1972

1973 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1974 {

1975 changeContentY(430);

1976 changeContentY(-30);

1977

1978 bool res = lvwph->maximizeVisibleArea(3);

1979 QVERIFY(res);

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

1981

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

1983 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1984 verifyItem(0, -478., 240., true, "Regular", true);

1985 verifyItem(1, -238., 390., false, "Mild", true);

1986 verifyItem(2, 152, 390., false, "Bold", false);

1987 verifyItem(3, 542, 350., true, QString(), true);

1988 QCOMPARE(lvwph->m_minYExtent, 152.5);

1989 QCOMPARE(lvwph->m_clipItem->y(), 718.);

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

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

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

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

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

1995 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1996 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1997 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1998 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1999 }

2000

2001 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

2002 {

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

2004 changeContentY(250);

2005 bool res = lvwph->maximizeVisibleArea(1);

2006 QVERIFY(res);

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

2008

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

2010 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2011 verifyItem(0, -100., 140., false, "Agressive", true);

2012 verifyItem(1, 40., 150., false, QString(), true);

2013 verifyItem(2, 190, 240., false, "Regular", false);

2014 verifyItem(3, 430, 390., false, "Mild", false);

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

2016 QCOMPARE(lvwph->m_clipItem->y(), 150.);

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

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

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

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

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

2022 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2023 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2024 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2025 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2026

2027 changeContentY(20);

2028 res = lvwph->maximizeVisibleArea(1);

2029 QVERIFY(res);

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

2031

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

2033 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2034 verifyItem(0, -100., 140., false, "Agressive", true);

2035 verifyItem(1, 40., 150., false, QString(), true);

2036 verifyItem(2, 190, 240., false, "Regular", false);

2037 verifyItem(3, 430, 390., false, "Mild", false);

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

2039 QCOMPARE(lvwph->m_clipItem->y(), 150.);

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

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

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

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

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

2045 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2046 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2047 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2048 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2049 }

2050

2051 void testMaximizeVisibleAreaWithItemResize()

2052 {

2053 model->setProperty(0, "size", 1000);

2054

2055 bool res = lvwph->maximizeVisibleArea(1);

2056 QVERIFY(res);

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

2058

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

2060 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2061 verifyItem(0, -738., 1040., false, "Agressive", true);

2062 verifyItem(1, 302., 240., false, "Regular", false);

2063 verifyItem(2, 542, 390., true, "Mild", true);

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

2065 QCOMPARE(lvwph->m_clipItem->y(), 788.);

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

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

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

2069 QCOMPARE(lvwph->contentY(), 788.);

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

2071 }

2072

2073 void addingRemoveItemsShouldNotChangeContentY()

2074 {

2075 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

2076 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

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

2078

2079 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2080 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2081 verifyItem(0, 50., 190., false, "Agressive", false);

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

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

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

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

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

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

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

2089

2090 QCOMPARE(spy.count(), 0);

2091 }

2092

2093 void testDownAndUp()

2094 {

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

2096

2097 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2098 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2099 verifyItem(0, 50., 190., false, "Agressive", false);

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

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

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

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

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

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

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

2107 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2108

2109 QTest::qWait(1);

2110 QCoreApplication::instance()->processEvents();

2111

2112 changeContentY(-15);

2113

2114 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2115 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2116 verifyItem(0, 65., 190., false, "Agressive", false);

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

2118 QCOMPARE(lvwph->m_clipItem->y(), -15.);

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

2120 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2121 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2122 QCOMPARE(lvwph->contentY(), -15.);

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

2124 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2125

2126 changeContentY(25);

2127

2128 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2129 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2130 verifyItem(0, 40., 190., false, "Agressive", false);

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

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

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

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

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

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

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

2138 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2139

2140

2141 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2142

2143 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2144 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2145 verifyItem(0, 50., 190., false, "Agressive", false);

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

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

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

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

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

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

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

2153 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2154 }

2155

2156private:

2157 QQuickView *view;

2158 ListViewWithPageHeader *lvwph;

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

2160 QQuickListModel *model;

2161#else

2162 QQmlListModel *model;

2163#endif

2164 QQmlComponent *otherDelegate;

2165};

2166

2167QTEST_MAIN(ListViewWithPageHeaderTestSection)

2168

2169#include "listviewwithpageheadersectiontest.moc"