tests/plugins/DashViews/listviewwithpageheadertestsection.cpp · unity8

git.iko.soy/unity8

on 551c708 help sign in

unity8/tests/plugins/DashViews/listviewwithpageheadertestsection.cpp

2172 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#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

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

1491#endif

1492 changeContentY(20);

1493

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

1495 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1496 verifyItem(0, 30., 190., false, "Agressive", false);

1497 verifyItem(1, 220, 240., false, "Regular", false);

1498 verifyItem(2, 460, 390., false, "Mild", false);

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

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

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

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

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

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

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

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

1507

1508 lvwph->showHeader();

1509

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

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

1512 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1513 verifyItem(0, -20., 190., false, "Agressive", true);

1514 verifyItem(1, 170, 240., false, "Regular", false);

1515 verifyItem(2, 410, 390., false, "Mild", false);

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

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

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

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

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

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

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

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

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

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

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

1527

1528 scrollToTop();

1529

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

1531 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1543 }

1544

1545 void testShowHeaderCloseToTheTop()

1546 {

1547 changeContentY(375);

1548

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

1550 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1566

1567 lvwph->showHeader();

1568

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

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

1571 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1572 verifyItem(0, -375., 190., true, "Agressive", true);

1573 verifyItem(1, -185, 240., false, "Regular", true);

1574 verifyItem(2, 55, 390., false, "Mild", false);

1575 verifyItem(3, 445, 390., false, "Bold", false);

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

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

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

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

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

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

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

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

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

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

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

1587

1588 scrollToTop();

1589

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

1591 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1603 }

1604

1605 void testShowHeaderAtBottom()

1606 {

1607 scrollToBottom();

1608

1609 lvwph->showHeader();

1610

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

1612 QTRY_VERIFY (lvwph->isAtYEnd());

1613 }

1614

1615 void growWindow()

1616 {

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

1618

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

1620 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

1624 verifyItem(3, 870., 390., true, "Bold", true);

1625 verifyItem(4, 1260., 350., true, QString(), true);

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

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

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

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

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

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

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

1633 }

1634

1635 void growWindowAtBottom()

1636 {

1637 // Need a bunch small items at the bottom to trigger the problem

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, "Agressive"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1643 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

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, "Regular"));

1648 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1649 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

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

1656 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1657 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1658

1659 scrollToBottom();

1660

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

1662

1663 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1664 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1665 verifyItem(0, -660., 390., true, "Lazy", true);

1666 verifyItem(1, -270., 90., true, "Agressive", true);

1667 verifyItem(2, -180, 50., true, QString(), true);

1668 verifyItem(3, -130, 50., true, QString(), true);

1669 verifyItem(4, -80, 50., true, QString(), true);

1670 verifyItem(5, -30, 50., false, QString(), true);

1671 verifyItem(6, 20, 50., false, QString(), true);

1672 verifyItem(7, 70, 50., false, QString(), true);

1673 verifyItem(8, 120, 50., false, QString(), true);

1674 verifyItem(9, 170, 90., false, "Regular", false);

1675 verifyItem(10, 260, 50., false, QString(), true);

1676 verifyItem(11, 310, 50., false, QString(), true);

1677 verifyItem(12, 360, 50., false, QString(), true);

1678 verifyItem(13, 410, 50., false, QString(), true);

1679 verifyItem(14, 460, 50., false, QString(), true);

1680 verifyItem(15, 510, 90., false, "Agressive", false);

1681 verifyItem(16, 600, 50., false, QString(), true);

1682 verifyItem(17, 650, 50., false, QString(), true);

1683 verifyItem(18, 700, 50., false, QString(), true);

1684 verifyItem(19, 750, 50., false, QString(), true);

1685 verifyItem(20, 800, 50., false, QString(), true);

1686 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - 1970 + 50);

1687 QCOMPARE(lvwph->m_clipItem->y(), 1970.);

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

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

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

1691 QCOMPARE(lvwph->contentY(), 1970.);

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

1693 }

1694

1695 void testCullOnBottomEdge()

1696 {

1697 changeContentY(240);

1698

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

1700 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

1702 verifyItem(1, 0., 240., false, "Regular", false);

1703 verifyItem(2, 240., 390., false, "Mild", false);

1704 verifyItem(3, 630., 390., true, "Bold", true);

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

1706 QCOMPARE(lvwph->m_clipItem->y(), 240.);

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

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

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

1710 QCOMPARE(lvwph->contentY(), 240.);

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

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

1713 }

1714

1715 void testSectionItemCullOnFirstSectionItemTopEdge()

1716 {

1717 changeContentY(50);

1718

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

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

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

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

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

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

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

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

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

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

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

1730 }

1731

1732 void testSectionItemCullOnSecondSectionItemTopEdge()

1733 {

1734 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1735 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1736

1737 changeContentY(5);

1738

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

1740 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1741 verifyItem(0, 45., 90., false, "Agressive", false);

1742 verifyItem(1, 135., 50., false, QString(), false);

1743 verifyItem(2, 185., 150., false, QString(), false);

1744 verifyItem(3, 335., 240., false, "Regular", false);

1745 verifyItem(4, 575., 390., true, "Mild", true);

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

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

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

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

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

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

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

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

1754

1755 changeContentY(135);

1756

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

1758 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1759 verifyItem(0, -90., 90., true, "Agressive", true);

1760 verifyItem(1, 0., 50., false, QString(), false);

1761 verifyItem(2, 50., 150., false, QString(), false);

1762 verifyItem(3, 200., 240., false, "Regular", false);

1763 verifyItem(4, 440., 390., false, "Mild", false);

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

1765 QCOMPARE(lvwph->m_clipItem->y(), 140.);

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

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

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

1769 QCOMPARE(lvwph->contentY(), 140.);

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

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

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

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

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

1775 }

1776

1777 void testMaximizeVisibleArea()

1778 {

1779 bool res = lvwph->maximizeVisibleArea(2);

1780 QVERIFY(res);

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

1782

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

1784 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1785 verifyItem(0, -278., 190., true, "Agressive", true);

1786 verifyItem(1, -88., 240., false, "Regular", true);

1787 verifyItem(2, 152, 390., false, "Mild", false);

1788 verifyItem(3, 542, 390., true, "Bold", true);

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

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

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

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

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

1794 QCOMPARE(lvwph->contentY(), 328.);

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

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

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

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

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

1800 }

1801

1802 void testMaximizeVisibleAreaVisibleItems()

1803 {

1804 bool res = lvwph->maximizeVisibleArea(0);

1805 QVERIFY(res);

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

1807

1808 verifyInitialTopPosition();

1809

1810 res = lvwph->maximizeVisibleArea(1);

1811 QVERIFY(res);

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

1813

1814 verifyInitialTopPosition();

1815 }

1816

1817 void testMaximizeVisibleAreaInvalidIndexes()

1818 {

1819 bool res = lvwph->maximizeVisibleArea(-1);

1820 QVERIFY(!res);

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

1822

1823 verifyInitialTopPosition();

1824

1825 res = lvwph->maximizeVisibleArea(1000);

1826 QVERIFY(!res);

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

1828

1829 verifyInitialTopPosition();

1830

1831 res = lvwph->maximizeVisibleArea(3);

1832 QVERIFY(!res);

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

1834

1835 verifyInitialTopPosition();

1836 }

1837

1838 void testMaximizeVisibleAreaBigElement()

1839 {

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

1841 verifyItem(2, 480, 4040., false, "Mild", false);

1842

1843 bool res = lvwph->maximizeVisibleArea(2);

1844 QVERIFY(res);

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

1846

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

1848 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1849 verifyItem(0, -430., 190., true, "Agressive", true);

1850 verifyItem(1, -240., 240., true, "Regular", true);

1851 verifyItem(2, 0, 4040., false, "Mild", false);

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

1853 QCOMPARE(lvwph->m_clipItem->y(), 480.);

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

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

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

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

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

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

1860 }

1861

1862 void testMaximizeVisibleAreaScrollDown()

1863 {

1864 changeContentY(350);

1865 bool res = lvwph->maximizeVisibleArea(1);

1866 QVERIFY(res);

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

1868

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

1870 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

1872 verifyItem(1, 0., 240., false, "Regular", false);

1873 verifyItem(2, 240, 390., false, "Mild", false);

1874 verifyItem(3, 630, 390., true, "Bold", true);

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

1876 QCOMPARE(lvwph->m_clipItem->y(), 240.);

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

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

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

1880 QCOMPARE(lvwph->contentY(), 240.);

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

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

1883 }

1884

1885 void testMaximizeVisibleAreaScrollDownBigElement()

1886 {

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

1888 changeContentY(1150);

1889 bool res = lvwph->maximizeVisibleArea(1);

1890 QVERIFY(res);

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

1892

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

1894 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1895 verifyItem(0, -498., 1040., false, "Regular", true);

1896 verifyItem(1, 542., 390., true, "Mild", true);

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

1898 QCOMPARE(lvwph->m_clipItem->y(), 738.);

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

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

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

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

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

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

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

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

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

1908 }

1909

1910 void testMaximizeVisibleAreaBigElementInTheMiddle()

1911 {

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

1913 changeContentY(650);

1914

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

1916 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1917 verifyItem(0, -410., 1040., false, "Regular", true);

1918 verifyItem(1, 630., 390., true, "Mild", true);

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

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

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

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

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

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

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

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

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

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

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

1930

1931 bool res = lvwph->maximizeVisibleArea(1);

1932 QVERIFY(res);

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

1934

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

1936 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1937 verifyItem(0, -410., 1040., false, "Regular", true);

1938 verifyItem(1, 630., 390., true, "Mild", true);

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

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

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

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

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

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

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

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

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

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

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

1950 }

1951

1952 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1953 {

1954 changeContentY(430);

1955 changeContentY(-30);

1956

1957 bool res = lvwph->maximizeVisibleArea(1);

1958 QVERIFY(res);

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

1960

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

1962 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

1964 verifyItem(1, 0., 240., false, "Regular", false);

1965 verifyItem(2, 240, 390., false, "Mild", false);

1966 verifyItem(3, 630, 390., true, "Bold", true);

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

1968 QCOMPARE(lvwph->m_clipItem->y(), 240.);

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

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

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

1972 QCOMPARE(lvwph->contentY(), 240.);

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

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

1975 }

1976

1977 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1978 {

1979 changeContentY(430);

1980 changeContentY(-30);

1981

1982 bool res = lvwph->maximizeVisibleArea(3);

1983 QVERIFY(res);

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

1985

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

1987 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1988 verifyItem(0, -478., 240., true, "Regular", true);

1989 verifyItem(1, -238., 390., false, "Mild", true);

1990 verifyItem(2, 152, 390., false, "Bold", false);

1991 verifyItem(3, 542, 350., true, QString(), true);

1992 QCOMPARE(lvwph->m_minYExtent, 152.5);

1993 QCOMPARE(lvwph->m_clipItem->y(), 718.);

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

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

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

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

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

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

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

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

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

2003 }

2004

2005 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

2006 {

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

2008 changeContentY(250);

2009 bool res = lvwph->maximizeVisibleArea(1);

2010 QVERIFY(res);

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

2012

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

2014 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2015 verifyItem(0, -100., 140., false, "Agressive", true);

2016 verifyItem(1, 40., 150., false, QString(), true);

2017 verifyItem(2, 190, 240., false, "Regular", false);

2018 verifyItem(3, 430, 390., false, "Mild", false);

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

2020 QCOMPARE(lvwph->m_clipItem->y(), 150.);

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

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

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

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

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

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

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

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

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

2030

2031 changeContentY(20);

2032 res = lvwph->maximizeVisibleArea(1);

2033 QVERIFY(res);

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

2035

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

2037 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2038 verifyItem(0, -100., 140., false, "Agressive", true);

2039 verifyItem(1, 40., 150., false, QString(), true);

2040 verifyItem(2, 190, 240., false, "Regular", false);

2041 verifyItem(3, 430, 390., false, "Mild", false);

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

2043 QCOMPARE(lvwph->m_clipItem->y(), 150.);

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

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

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

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

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

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

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

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

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

2053 }

2054

2055 void testMaximizeVisibleAreaWithItemResize()

2056 {

2057 model->setProperty(0, "size", 1000);

2058

2059 bool res = lvwph->maximizeVisibleArea(1);

2060 QVERIFY(res);

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

2062

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

2064 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2065 verifyItem(0, -738., 1040., false, "Agressive", true);

2066 verifyItem(1, 302., 240., false, "Regular", false);

2067 verifyItem(2, 542, 390., true, "Mild", true);

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

2069 QCOMPARE(lvwph->m_clipItem->y(), 788.);

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

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

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

2073 QCOMPARE(lvwph->contentY(), 788.);

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

2075 }

2076

2077 void addingRemoveItemsShouldNotChangeContentY()

2078 {

2079 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

2080 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

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

2082

2083 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2084 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

2093

2094 QCOMPARE(spy.count(), 0);

2095 }

2096

2097 void testDownAndUp()

2098 {

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

2100

2101 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2102 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

2112

2113 QTest::qWait(1);

2114

2115 changeContentY(-15);

2116

2117 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2118 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2119 verifyItem(0, 65., 190., false, "Agressive", false);

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

2121 QCOMPARE(lvwph->m_clipItem->y(), -15.);

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

2123 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2124 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2125 QCOMPARE(lvwph->contentY(), -15.);

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

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

2128

2129 changeContentY(25);

2130

2131 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2132 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

2142

2143

2144 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2145

2146 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2147 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

2157 }

2158

2159private:

2160 QQuickView *view;

2161 ListViewWithPageHeader *lvwph;

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

2163 QQuickListModel *model;

2164#else

2165 QQmlListModel *model;

2166#endif

2167 QQmlComponent *otherDelegate;

2168};

2169

2170QTEST_MAIN(ListViewWithPageHeaderTestSection)

2171

2172#include "listviewwithpageheadertestsection.moc"