tests/plugins/Dash/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on af9cb05 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadersectiontest.cpp

2163 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#include <private/qqmllistmodel_p.h>

27#include <private/qquickanimation_p.h>

28#include <private/qquickitem_p.h>

29#pragma GCC diagnostic pop

31class ListViewWithPageHeaderTestSection : public QObject

32{

33 Q_OBJECT

35private:

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

37 {

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

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

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

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

42 QCOMPARE(section(lvwph->m_visibleItems[visibleIndex]->sectionItem()), sectionHeader);

43 QTRY_COMPARE(hasSectionHeaderProperty(lvwph->m_visibleItems[visibleIndex]->m_item), !sectionHeader.isNull());

44 if (!sectionHeader.isNull()) {

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

46 QCOMPARE(sectionDelegateIndex(lvwph->m_visibleItems[visibleIndex]->sectionItem()), lvwph->m_firstVisibleIndex + visibleIndex);

47 }

48 }

50 void changeContentY(qreal change)

51 {

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

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

54 const qreal jump = 25;

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

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

57 QTest::qWait(1);

58 }

59 } else {

60 const qreal jump = -25;

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

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

63 QTest::qWait(1);

64 }

65 }

66 lvwph->setContentY(dest);

67 QTest::qWait(1);

68 }

70 void scrollToTop()

71 {

72 const qreal jump = -25;

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

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

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

76 } else {

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

78 }

79 QTest::qWait(1);

80 }

81 }

83 void scrollToBottom()

84 {

85 const qreal jump = 25;

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

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

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

89 } else {

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

91 }

92 QTest::qWait(1);

93 }

94 }

96 void verifyInitialTopPosition()

97 {

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

99 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

111 }

112

113 bool hasSectionHeaderProperty(QQuickItem *item) const

114 {

115 return item ? QQmlEngine::contextForObject(item)->parentContext()->contextProperty(QLatin1String("hasSectionHeader")).toBool() : false;

116 }

117

118 QString section(QQuickItem *item) const

119 {

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

121 }

122

123 int sectionDelegateIndex(QQuickItem *item) const

124 {

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

126 }

127

128private Q_SLOTS:

129

130 void initTestCase()

131 {

132 }

133

134 void init()

135 {

136 view = new QQuickView();

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

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

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

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

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

142 QVERIFY(lvwph);

143 QVERIFY(model);

144 QVERIFY(otherDelegate);

145 view->show();

146 QTest::qWaitForWindowExposed(view);

147

148 verifyInitialTopPosition();

149 }

150

151 void cleanup()

152 {

153 delete view;

154 }

155

156 void testCreationDeletion()

157 {

158 // Nothing, init/cleanup already tests this

159 }

160

161 void testDrag1PixelUp()

162 {

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

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

165 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

177 }

178

179 void testHeaderDetachDragDown()

180 {

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

182 QTest::qWait(100);

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

184 QTest::qWait(100);

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

186 QTest::qWait(100);

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

188 QTest::qWait(100);

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

190 QTest::qWait(100);

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

192 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

204

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

206

207 verifyInitialTopPosition();

208 }

209

210 void testDrag375PixelUp()

211 {

212 changeContentY(375);

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

214 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

230 }

231

232 void testDrag520PixelUp()

233 {

234 changeContentY(520);

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

236 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

241 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

252 }

253

254 void testDragHeaderUpThenShow()

255 {

256 changeContentY(120);

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

258 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

274

275 changeContentY(-30);

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

277 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

293 }

294

295 void testDragHeaderUpThenShowWithoutHidingTotally()

296 {

297 changeContentY(10);

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

299 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

311

312 changeContentY(-1);

313

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

315 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

327 }

328

329 void testPositionAtBeginningIndex0Visible()

330 {

331 changeContentY(375);

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

333 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

349

350 lvwph->positionAtBeginning();

351

352 verifyInitialTopPosition();

353 }

354

355 void testPositionAtBeginningIndex0NotVisible()

356 {

357 changeContentY(520);

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

359 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

364 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

375

376 lvwph->positionAtBeginning();

377

378 verifyInitialTopPosition();

379 }

380

381 void testIndex0GrowOnScreen()

382 {

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

384

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

386 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

398 }

399

400 void testIndex0GrowOffScreen()

401 {

402 changeContentY(375);

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

404 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

420

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

422

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

424 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

440

441 scrollToTop();

442

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

444 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

456

457 changeContentY(30);

458

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

460 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

472 }

473

474 void testIndex0GrowNotCreated()

475 {

476 changeContentY(520);

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

478 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

483 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

494

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

496

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

498 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

503 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

514

515 scrollToTop();

516

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

518 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

530 }

531

532 void testShowHideShowHeaderAtBottom()

533 {

534 scrollToBottom();

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

536 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

551

552 changeContentY(-30);

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

554 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

569

570 changeContentY(30);

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

572 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

587

588 changeContentY(-30);

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

590 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

605 }

606

607 void testChangeDelegateAtBottom()

608 {

609 scrollToBottom();

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

611 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

626

627 lvwph->setDelegate(otherDelegate);

628

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

630 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

645 }

646

647 void testSetEmptyHeaderAtTop()

648 {

649 lvwph->setHeader(nullptr);

650

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

652 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

663 }

664

665 void testSetEmptyHeaderAtBottom()

666 {

667 scrollToBottom();

668 lvwph->setHeader(nullptr);

669

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

671 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

685

686 scrollToTop();

687

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

689 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

700 }

701

702 void testSetEmptyHeaderWhenPartlyShownClipped()

703 {

704 scrollToBottom();

705 changeContentY(-30);

706 lvwph->setHeader(nullptr);

707

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

709 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

719 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

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

724

725 scrollToTop();

726

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

728 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

739 }

740

741 void testSetEmptyHeaderWhenPartlyShownNotClipped()

742 {

743 changeContentY(30);

744 lvwph->setHeader(nullptr);

745

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

747 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

761 }

762

763 void testSetNullDelegate()

764 {

765 lvwph->setDelegate(nullptr);

766

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

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

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

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

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

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

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

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

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

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

777 QVERIFY(lvwph->isAtYBeginning());

778 QVERIFY(lvwph->isAtYEnd());

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

780 }

781

782 void testInsertItems()

783 {

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

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

786

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

788 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

802 }

803

804 void testInsertItemsStealSectionItem()

805 {

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

807

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

809 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

822 }

823

824

825 void testInsertItemsOnNotShownPosition()

826 {

827 changeContentY(800);

828

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

830 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

846

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

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

849

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

851 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

867

868 scrollToTop();

869

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

871 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

885 }

886

887 void testInsertItemsAtEndOfViewport()

888 {

889 changeContentY(60);

890

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

892 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

908

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

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

911

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

913 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

929 }

930

931 void testInsertItemsBeforeValidIndex()

932 {

933 changeContentY(520);

934

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

936 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

941 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

952

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

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

955

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

957 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

962 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

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

973 }

974

975 void testInsertItemsBeforeViewport()

976 {

977 changeContentY(375);

978

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

980 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

996

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

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

999

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

1001 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1017

1018 scrollToTop();

1019

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

1021 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1035 }

1036

1037 void testInsertItemsAtBottom()

1038 {

1039 scrollToBottom();

1040

1041 QVERIFY(lvwph->isAtYEnd());

1042

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

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

1045

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

1047 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1065

1066 scrollToBottom();

1067

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

1069 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1081 QVERIFY(lvwph->isAtYEnd());

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

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

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

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

1086 }

1087

1088 void testInsertItemAtTop()

1089 {

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

1091

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

1093 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1105 QVERIFY(lvwph->isAtYBeginning());

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

1107 }

1108

1109 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1110 {

1111 scrollToBottom();

1112

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

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

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

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

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

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

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

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

1123

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

1125 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1140

1141 changeContentY(-1700);

1142

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

1144 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1154 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

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

1165 }

1166

1167 void testInsertToEmpty()

1168 {

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

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

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

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

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

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

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

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

1177

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

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

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

1181 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1184 }

1185

1186 void testRemoveItemsAtTop()

1187 {

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

1189

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

1191 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1201 QVERIFY(lvwph->isAtYBeginning());

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

1203 }

1204

1205 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1206 {

1207 scrollToBottom();

1208

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

1210

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

1212 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

1216 QCOMPARE(lvwph->m_minYExtent, -1330./3.);

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

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

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

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

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

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

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

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

1225 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1226 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1227 }

1228

1229 void testRemoveLastItemsAtBottom()

1230 {

1231 scrollToBottom();

1232

1233 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));

1234

1235 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1236 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1237 verifyItem(0, -478., 240., true, "Regular", true);

1238 verifyItem(1, -238, 390., false, "Mild", true);

1239 verifyItem(2, 152, 390., false, "Bold", false);

1240 QCOMPARE(lvwph->m_minYExtent, 150.);

1241 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1242 QCOMPARE(lvwph->m_clipItem->clip(), false);

1243 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1244 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1245 QCOMPARE(lvwph->contentY(), 718.);

1246 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1247 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1248 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1249 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1250 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1251 }

1252

1253 void testRemoveItemOutOfViewport()

1254 {

1255 changeContentY(520);

1256

1257 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1258 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1259 verifyItem(0, -280., 240., true, "Regular", true);

1260 verifyItem(1, -40, 390., false, "Mild", true);

1261 verifyItem(2, 350, 390., false, "Bold", false);

1262 verifyItem(3, 740, 350., true, QString(), true);

1263 QCOMPARE(lvwph->m_minYExtent, 152.5);

1264 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1265 QCOMPARE(lvwph->m_clipItem->clip(), false);

1266 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1267 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1268 QCOMPARE(lvwph->contentY(), 520.);

1269 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1270 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1271 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1272 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1273 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1274

1275 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1276

1277 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1278 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1279 verifyItem(0, -230., 190., true, "Agressive", true);

1280 verifyItem(1, -40, 390., false, "Mild", true);

1281 verifyItem(2, 350, 390., false, "Bold", false);

1282 verifyItem(3, 740, 350., true, QString(), true);

1283 QCOMPARE(lvwph->m_minYExtent, -240.);

1284 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1285 QCOMPARE(lvwph->m_clipItem->clip(), false);

1286 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1287 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1288 QCOMPARE(lvwph->contentY(), 520.);

1289 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1290 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1291 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1292 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1293 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1294 }

1295

1296 void testRemoveFirstOfCategory()

1297 {

1298 changeContentY(520);

1299

1300 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1301 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1302 verifyItem(0, -280., 240., true, "Regular", true);

1303 verifyItem(1, -40, 390., false, "Mild", true);

1304 verifyItem(2, 350, 390., false, "Bold", false);

1305 verifyItem(3, 740, 350., true, QString(), true);

1306 QCOMPARE(lvwph->m_minYExtent, 152.5);

1307 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1308 QCOMPARE(lvwph->m_clipItem->clip(), false);

1309 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1310 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1311 QCOMPARE(lvwph->contentY(), 520.);

1312 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1313 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1314 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1315 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1316 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1317

1318 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1319

1320 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1321 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1322 verifyItem(0, -280., 240., true, "Regular", true);

1323 verifyItem(1, -40, 390., false, "Mild", true);

1324 verifyItem(2, 350, 390., false, "Bold", false);

1325 verifyItem(3, 740, 390., true, "Lazy", true);

1326 QCOMPARE(lvwph->m_minYExtent, 162.5);

1327 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1328 QCOMPARE(lvwph->m_clipItem->clip(), false);

1329 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1330 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1331 QCOMPARE(lvwph->contentY(), 520.);

1332 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1333 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1334 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1335 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1336 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1337 }

1338

1339 void testAddSecondToCulledCategoryOfTwo()

1340 {

1341 // Do some setup

1342 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1343 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1344

1345 changeContentY(200);

1346

1347 // Very the items are culled

1348 verifyItem(0, -150., 65., true, "Agressive", true);

1349 verifyItem(1, -85, 25., true, QString(), true);

1350

1351 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1352

1353 // Very the new item is there correctly

1354 verifyItem(0, -175., 65., true, "Agressive", true);

1355 verifyItem(1, -110, 25., true, QString(), true);

1356 verifyItem(2, -85, 25., true, QString(), true);

1357 }

1358

1359 void testMoveFirstItems()

1360 {

1361 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1362

1363 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1364 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1365 verifyItem(0, 50., 240., false, "Regular", false);

1366 verifyItem(1, 290., 190., false, "Agressive", false);

1367 verifyItem(2, 480., 390., false, "Mild", false);

1368 QCOMPARE(lvwph->m_minYExtent, 0.);

1369 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1370 QCOMPARE(lvwph->m_clipItem->clip(), false);

1371 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1372 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1373 QCOMPARE(lvwph->contentY(), 0.);

1374 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1375 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1376 }

1377

1378 void testMoveFirstOutOfVisibleItems()

1379 {

1380 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1381

1382 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1383 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1384 verifyItem(0, 50., 240., false, "Regular", false);

1385 verifyItem(1, 290., 390., false, "Mild", false);

1386 verifyItem(2, 680., 390., true, "Bold", true);

1387 QCOMPARE(lvwph->m_minYExtent, 0.);

1388 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1389 QCOMPARE(lvwph->m_clipItem->clip(), false);

1390 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1391 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1392 QCOMPARE(lvwph->contentY(), 0.);

1393 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1394 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1395 }

1396

1397 void testMoveFirstToLastAtBottom()

1398 {

1399 scrollToBottom();

1400

1401 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1402 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1403 verifyItem(0, -588., 390., true, "Bold", true);

1404 verifyItem(1, -198, 350., false, QString(), true);

1405 verifyItem(2, 152, 390., false, "Lazy", false);

1406 QCOMPARE(lvwph->m_minYExtent, 310.);

1407 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1408 QCOMPARE(lvwph->m_clipItem->clip(), false);

1409 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1410 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1411 QCOMPARE(lvwph->contentY(), 1458.);

1412 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1413 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1414 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1415 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1416 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1417

1418 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1419

1420 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1421 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1422 verifyItem(0, -588., 390., true, "Bold", true);

1423 verifyItem(1, -198, 350., false, QString(), true);

1424 verifyItem(2, 152, 390., false, "Lazy", false);

1425 verifyItem(3, 542, 190., true, "Agressive", true);

1426 QCOMPARE(lvwph->m_minYExtent, -160.);

1427 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1428 QCOMPARE(lvwph->m_clipItem->clip(), false);

1429 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1430 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1431 QCOMPARE(lvwph->contentY(), 1458.);

1432 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1433 QVERIFY(!lvwph->isAtYEnd());

1434 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1435 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1436 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1437 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1438 }

1439

1440 void testChangeSizeVisibleItemNotOnViewport()

1441 {

1442 changeContentY(490);

1443

1444 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1445 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1446 verifyItem(0, -440., 190., true, "Agressive", true);

1447 verifyItem(1, -250., 240., true, "Regular", true);

1448 verifyItem(2, -10, 390., false, "Mild", true);

1449 verifyItem(3, 380, 390., false, "Bold", false);

1450 verifyItem(4, 770, 350., true, QString(), true);

1451 QCOMPARE(lvwph->m_minYExtent, 0.);

1452 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1453 QCOMPARE(lvwph->m_clipItem->clip(), false);

1454 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1455 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1456 QCOMPARE(lvwph->contentY(), 490.);

1457 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1458 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1459 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1460 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1461 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1462

1463 model->setProperty(1, "size", 100);

1464

1465 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1466 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1467 verifyItem(0, -340., 190., true, "Agressive", true);

1468 verifyItem(1, -150., 140., true, "Regular", true);

1469 verifyItem(2, -10, 390., false, "Mild", true);

1470 verifyItem(3, 380, 390., false, "Bold", false);

1471 verifyItem(4, 770, 350., true, QString(), true);

1472 QCOMPARE(lvwph->m_minYExtent, -100.);

1473 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1474 QCOMPARE(lvwph->m_clipItem->clip(), false);

1475 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1476 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1477 QCOMPARE(lvwph->contentY(), 490.);

1478 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1479 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1480 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1481 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1482 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1483 }

1484

1485 void testShowHeaderHalfShown()

1486 {

1487 changeContentY(20);

1488

1489 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1490 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1491 verifyItem(0, 30., 190., false, "Agressive", false);

1492 verifyItem(1, 220, 240., false, "Regular", false);

1493 verifyItem(2, 460, 390., false, "Mild", false);

1494 QCOMPARE(lvwph->m_minYExtent, 0.);

1495 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1496 QCOMPARE(lvwph->m_clipItem->clip(), false);

1497 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1498 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1499 QCOMPARE(lvwph->contentY(), 20.);

1500 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1501 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1502

1503 lvwph->showHeader();

1504

1505 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1506 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1507 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1508 verifyItem(0, -20., 190., false, "Agressive", true);

1509 verifyItem(1, 170, 240., false, "Regular", false);

1510 verifyItem(2, 410, 390., false, "Mild", false);

1511 QCOMPARE(lvwph->m_minYExtent, 20.);

1512 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1513 QCOMPARE(lvwph->m_clipItem->clip(), true);

1514 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1515 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1516 QCOMPARE(lvwph->contentY(), 0.);

1517 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1518 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1519 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1520 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1521 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1522

1523 scrollToTop();

1524

1525 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1526 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1527 verifyItem(0, 50., 190., false, "Agressive", false);

1528 verifyItem(1, 240., 240., false, "Regular", false);

1529 verifyItem(2, 480., 390., false, "Mild", false);

1530 QCOMPARE(lvwph->m_minYExtent, 20.);

1531 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1532 QCOMPARE(lvwph->m_clipItem->clip(), false);

1533 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1534 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1535 QCOMPARE(lvwph->contentY(), -20.);

1536 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1537 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1538 }

1539

1540 void testShowHeaderCloseToTheTop()

1541 {

1542 changeContentY(375);

1543

1544 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1545 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1546 verifyItem(0, -325., 190., true, "Agressive", true);

1547 verifyItem(1, -135, 240., false, "Regular", true);

1548 verifyItem(2, 105, 390., false, "Mild", false);

1549 verifyItem(3, 495, 390., false, "Bold", false);

1550 QCOMPARE(lvwph->m_minYExtent, 0.);

1551 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1552 QCOMPARE(lvwph->m_clipItem->clip(), false);

1553 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1554 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1555 QCOMPARE(lvwph->contentY(), 375.);

1556 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1557 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1558 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1559 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1560 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1561

1562 lvwph->showHeader();

1563

1564 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1565 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1566 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1567 verifyItem(0, -375., 190., true, "Agressive", true);

1568 verifyItem(1, -185, 240., false, "Regular", true);

1569 verifyItem(2, 55, 390., false, "Mild", false);

1570 verifyItem(3, 445, 390., false, "Bold", false);

1571 QCOMPARE(lvwph->m_minYExtent, 50.);

1572 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1573 QCOMPARE(lvwph->m_clipItem->clip(), true);

1574 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1575 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1576 QCOMPARE(lvwph->contentY(), 325.);

1577 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1578 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1579 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1580 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1581 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1582

1583 scrollToTop();

1584

1585 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1586 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1587 verifyItem(0, 50., 190., false, "Agressive", false);

1588 verifyItem(1, 240., 240., false, "Regular", false);

1589 verifyItem(2, 480., 390., false, "Mild", false);

1590 QCOMPARE(lvwph->m_minYExtent, 50.);

1591 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1592 QCOMPARE(lvwph->m_clipItem->clip(), false);

1593 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1594 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1595 QCOMPARE(lvwph->contentY(), -50.);

1596 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1597 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1598 }

1599

1600 void testShowHeaderAtBottom()

1601 {

1602 scrollToBottom();

1603

1604 lvwph->showHeader();

1605

1606 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1607 QTRY_VERIFY (lvwph->isAtYEnd());

1608 }

1609

1610 void growWindow()

1611 {

1612 view->rootObject()->setHeight(850);

1613

1614 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1615 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1616 verifyItem(0, 50., 190., false, "Agressive", false);

1617 verifyItem(1, 240., 240., false, "Regular", false);

1618 verifyItem(2, 480., 390., false, "Mild", false);

1619 verifyItem(3, 870., 390., true, "Bold", true);

1620 verifyItem(4, 1260., 350., true, QString(), true);

1621 QCOMPARE(lvwph->m_minYExtent, 0.);

1622 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1623 QCOMPARE(lvwph->m_clipItem->clip(), false);

1624 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1625 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1626 QCOMPARE(lvwph->contentY(), 0.);

1627 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1628 }

1629

1630 void growWindowAtBottom()

1631 {

1632 // Need a bunch small items at the bottom to trigger the problem

1633 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1634 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1635 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1636 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1637 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1638 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1639 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1640 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1643 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1644 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1645 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1646 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1647 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1648 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1649 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1650 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1651 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1652 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1653

1654 scrollToBottom();

1655

1656 view->rootObject()->setHeight(850);

1657

1658 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1659 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1660 verifyItem(0, -660., 390., true, "Lazy", true);

1661 verifyItem(1, -270., 90., true, "Agressive", true);

1662 verifyItem(2, -180, 50., true, QString(), true);

1663 verifyItem(3, -130, 50., true, QString(), true);

1664 verifyItem(4, -80, 50., true, QString(), true);

1665 verifyItem(5, -30, 50., false, QString(), true);

1666 verifyItem(6, 20, 50., false, QString(), true);

1667 verifyItem(7, 70, 50., false, QString(), true);

1668 verifyItem(8, 120, 50., false, QString(), true);

1669 verifyItem(9, 170, 90., false, "Regular", false);

1670 verifyItem(10, 260, 50., false, QString(), true);

1671 verifyItem(11, 310, 50., false, QString(), true);

1672 verifyItem(12, 360, 50., false, QString(), true);

1673 verifyItem(13, 410, 50., false, QString(), true);

1674 verifyItem(14, 460, 50., false, QString(), true);

1675 verifyItem(15, 510, 90., false, "Agressive", false);

1676 verifyItem(16, 600, 50., false, QString(), true);

1677 verifyItem(17, 650, 50., false, QString(), true);

1678 verifyItem(18, 700, 50., false, QString(), true);

1679 verifyItem(19, 750, 50., false, QString(), true);

1680 verifyItem(20, 800, 50., false, QString(), true);

1681 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1682 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

1683 QCOMPARE(lvwph->m_clipItem->clip(), false);

1684 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1685 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1686 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1687 }

1688

1689 void testCullOnBottomEdge()

1690 {

1691 changeContentY(240);

1692

1693 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1694 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1695 verifyItem(0, -190., 190., true, "Agressive", true);

1696 verifyItem(1, 0., 240., false, "Regular", false);

1697 verifyItem(2, 240., 390., false, "Mild", false);

1698 verifyItem(3, 630., 390., true, "Bold", true);

1699 QCOMPARE(lvwph->m_minYExtent, 0.);

1700 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1701 QCOMPARE(lvwph->m_clipItem->clip(), false);

1702 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1703 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1704 QCOMPARE(lvwph->contentY(), 240.);

1705 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1706 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1707 }

1708

1709 void testSectionItemCullOnFirstSectionItemTopEdge()

1710 {

1711 changeContentY(50);

1712

1713 verifyItem(0, 0., 190., false, "Agressive", false);

1714 verifyItem(1, 190., 240., false, "Regular", false);

1715 verifyItem(2, 430., 390., false, "Mild", false);

1716 QCOMPARE(lvwph->m_minYExtent, 0.);

1717 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1718 QCOMPARE(lvwph->m_clipItem->clip(), false);

1719 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1720 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1721 QCOMPARE(lvwph->contentY(), 50.);

1722 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1723 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1724 }

1725

1726 void testSectionItemCullOnSecondSectionItemTopEdge()

1727 {

1728 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1729 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1730

1731 changeContentY(5);

1732

1733 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1734 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1735 verifyItem(0, 45., 90., false, "Agressive", false);

1736 verifyItem(1, 135., 50., false, QString(), false);

1737 verifyItem(2, 185., 150., false, QString(), false);

1738 verifyItem(3, 335., 240., false, "Regular", false);

1739 verifyItem(4, 575., 390., true, "Mild", true);

1740 QCOMPARE(lvwph->m_minYExtent, 0.);

1741 QCOMPARE(lvwph->m_clipItem->y(), 5.);

1742 QCOMPARE(lvwph->m_clipItem->clip(), false);

1743 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1744 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1745 QCOMPARE(lvwph->contentY(), 5.);

1746 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1747 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1748

1749 changeContentY(135);

1750

1751 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1752 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1753 verifyItem(0, -90., 90., true, "Agressive", true);

1754 verifyItem(1, 0., 50., false, QString(), false);

1755 verifyItem(2, 50., 150., false, QString(), false);

1756 verifyItem(3, 200., 240., false, "Regular", false);

1757 verifyItem(4, 440., 390., false, "Mild", false);

1758 QCOMPARE(lvwph->m_minYExtent, 0.);

1759 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1760 QCOMPARE(lvwph->m_clipItem->clip(), false);

1761 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1762 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1763 QCOMPARE(lvwph->contentY(), 140.);

1764 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1765 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1766 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1767 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1768 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1769 }

1770

1771 void testMaximizeVisibleArea()

1772 {

1773 bool res = lvwph->maximizeVisibleArea(2);

1774 QVERIFY(res);

1775 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1776

1777 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1778 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1779 verifyItem(0, -278., 190., true, "Agressive", true);

1780 verifyItem(1, -88., 240., false, "Regular", true);

1781 verifyItem(2, 152, 390., false, "Mild", false);

1782 verifyItem(3, 542, 390., true, "Bold", true);

1783 QCOMPARE(lvwph->m_minYExtent, 0.);

1784 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1785 QCOMPARE(lvwph->m_clipItem->clip(), false);

1786 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1787 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1788 QCOMPARE(lvwph->contentY(), 328.);

1789 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1790 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1791 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1792 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1793 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1794 }

1795

1796 void testMaximizeVisibleAreaVisibleItems()

1797 {

1798 bool res = lvwph->maximizeVisibleArea(0);

1799 QVERIFY(res);

1800 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1801

1802 verifyInitialTopPosition();

1803

1804 res = lvwph->maximizeVisibleArea(1);

1805 QVERIFY(res);

1806 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1807

1808 verifyInitialTopPosition();

1809 }

1810

1811 void testMaximizeVisibleAreaInvalidIndexes()

1812 {

1813 bool res = lvwph->maximizeVisibleArea(-1);

1814 QVERIFY(!res);

1815 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1816

1817 verifyInitialTopPosition();

1818

1819 res = lvwph->maximizeVisibleArea(1000);

1820 QVERIFY(!res);

1821 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1822

1823 verifyInitialTopPosition();

1824

1825 res = lvwph->maximizeVisibleArea(3);

1826 QVERIFY(!res);

1827 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1828

1829 verifyInitialTopPosition();

1830 }

1831

1832 void testMaximizeVisibleAreaBigElement()

1833 {

1834 model->setProperty(2, "size", 4000);

1835 verifyItem(2, 480, 4040., false, "Mild", false);

1836

1837 bool res = lvwph->maximizeVisibleArea(2);

1838 QVERIFY(res);

1839 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1840

1841 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1842 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1843 verifyItem(0, -430., 190., true, "Agressive", true);

1844 verifyItem(1, -240., 240., true, "Regular", true);

1845 verifyItem(2, 0, 4040., false, "Mild", false);

1846 QCOMPARE(lvwph->m_minYExtent, 0.);

1847 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1848 QCOMPARE(lvwph->m_clipItem->clip(), false);

1849 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1850 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1851 QCOMPARE(lvwph->contentY(), 480.);

1852 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1853 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1854 }

1855

1856 void testMaximizeVisibleAreaScrollDown()

1857 {

1858 changeContentY(350);

1859 bool res = lvwph->maximizeVisibleArea(1);

1860 QVERIFY(res);

1861 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1862

1863 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1864 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1865 verifyItem(0, -190., 190., true, "Agressive", true);

1866 verifyItem(1, 0., 240., false, "Regular", false);

1867 verifyItem(2, 240, 390., false, "Mild", false);

1868 verifyItem(3, 630, 390., true, "Bold", true);

1869 QCOMPARE(lvwph->m_minYExtent, 0.);

1870 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1871 QCOMPARE(lvwph->m_clipItem->clip(), false);

1872 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1873 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1874 QCOMPARE(lvwph->contentY(), 240.);

1875 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1876 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1877 }

1878

1879 void testMaximizeVisibleAreaScrollDownBigElement()

1880 {

1881 model->setProperty(1, "size", 1000);

1882 changeContentY(1150);

1883 bool res = lvwph->maximizeVisibleArea(1);

1884 QVERIFY(res);

1885 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1886

1887 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1888 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1889 verifyItem(0, -498., 1040., false, "Regular", true);

1890 verifyItem(1, 542., 390., true, "Mild", true);

1891 QCOMPARE(lvwph->m_minYExtent, 525.);

1892 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1893 QCOMPARE(lvwph->m_clipItem->clip(), false);

1894 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1895 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1896 QCOMPARE(lvwph->contentY(), 738.);

1897 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1898 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1899 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1900 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1901 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1902 }

1903

1904 void testMaximizeVisibleAreaBigElementInTheMiddle()

1905 {

1906 model->setProperty(1, "size", 1000);

1907 changeContentY(650);

1908

1909 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1910 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1911 verifyItem(0, -410., 1040., false, "Regular", true);

1912 verifyItem(1, 630., 390., true, "Mild", true);

1913 QCOMPARE(lvwph->m_minYExtent, 525.);

1914 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1915 QCOMPARE(lvwph->m_clipItem->clip(), false);

1916 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1917 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1918 QCOMPARE(lvwph->contentY(), 650.);

1919 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1920 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1921 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1922 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1923 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1924

1925 bool res = lvwph->maximizeVisibleArea(1);

1926 QVERIFY(res);

1927 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1928

1929 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1930 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1931 verifyItem(0, -410., 1040., false, "Regular", true);

1932 verifyItem(1, 630., 390., true, "Mild", true);

1933 QCOMPARE(lvwph->m_minYExtent, 525.);

1934 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1935 QCOMPARE(lvwph->m_clipItem->clip(), false);

1936 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1937 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1938 QCOMPARE(lvwph->contentY(), 650.);

1939 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1940 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1941 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1942 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1943 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1944 }

1945

1946 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1947 {

1948 changeContentY(430);

1949 changeContentY(-30);

1950

1951 bool res = lvwph->maximizeVisibleArea(1);

1952 QVERIFY(res);

1953 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1954

1955 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1956 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1957 verifyItem(0, -190., 190., true, "Agressive", true);

1958 verifyItem(1, 0., 240., false, "Regular", false);

1959 verifyItem(2, 240, 390., false, "Mild", false);

1960 verifyItem(3, 630, 390., true, "Bold", true);

1961 QCOMPARE(lvwph->m_minYExtent, 0.);

1962 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1963 QCOMPARE(lvwph->m_clipItem->clip(), false);

1964 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1965 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1966 QCOMPARE(lvwph->contentY(), 240.);

1967 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1968 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1969 }

1970

1971 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1972 {

1973 changeContentY(430);

1974 changeContentY(-30);

1975

1976 bool res = lvwph->maximizeVisibleArea(3);

1977 QVERIFY(res);

1978 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1979

1980 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1981 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1982 verifyItem(0, -478., 240., true, "Regular", true);

1983 verifyItem(1, -238., 390., false, "Mild", true);

1984 verifyItem(2, 152, 390., false, "Bold", false);

1985 verifyItem(3, 542, 350., true, QString(), true);

1986 QCOMPARE(lvwph->m_minYExtent, 152.5);

1987 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1988 QCOMPARE(lvwph->m_clipItem->clip(), false);

1989 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1990 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1991 QCOMPARE(lvwph->contentY(), 718.);

1992 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1993 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1994 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1995 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1996 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1997 }

1998

1999 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

2000 {

2001 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

2002 changeContentY(250);

2003 bool res = lvwph->maximizeVisibleArea(1);

2004 QVERIFY(res);

2005 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2006

2007 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2008 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2009 verifyItem(0, -100., 140., false, "Agressive", true);

2010 verifyItem(1, 40., 150., false, QString(), true);

2011 verifyItem(2, 190, 240., false, "Regular", false);

2012 verifyItem(3, 430, 390., false, "Mild", false);

2013 QCOMPARE(lvwph->m_minYExtent, 0.);

2014 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2015 QCOMPARE(lvwph->m_clipItem->clip(), false);

2016 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2017 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2018 QCOMPARE(lvwph->contentY(), 150.);

2019 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2020 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2021 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2022 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2023 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2024

2025 changeContentY(20);

2026 res = lvwph->maximizeVisibleArea(1);

2027 QVERIFY(res);

2028 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2029

2030 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2031 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2032 verifyItem(0, -100., 140., false, "Agressive", true);

2033 verifyItem(1, 40., 150., false, QString(), true);

2034 verifyItem(2, 190, 240., false, "Regular", false);

2035 verifyItem(3, 430, 390., false, "Mild", false);

2036 QCOMPARE(lvwph->m_minYExtent, 0.);

2037 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2038 QCOMPARE(lvwph->m_clipItem->clip(), false);

2039 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2040 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2041 QCOMPARE(lvwph->contentY(), 150.);

2042 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2043 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2044 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2045 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2046 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2047 }

2048

2049 void testMaximizeVisibleAreaWithItemResize()

2050 {

2051 model->setProperty(0, "size", 1000);

2052

2053 bool res = lvwph->maximizeVisibleArea(1);

2054 QVERIFY(res);

2055 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2056

2057 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2058 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2059 verifyItem(0, -738., 1040., false, "Agressive", true);

2060 verifyItem(1, 302., 240., false, "Regular", false);

2061 verifyItem(2, 542, 390., true, "Mild", true);

2062 QCOMPARE(lvwph->m_minYExtent, 0.);

2063 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2064 QCOMPARE(lvwph->m_clipItem->clip(), false);

2065 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2066 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2067 QCOMPARE(lvwph->contentY(), 788.);

2068 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2069 }

2070

2071 void addingRemoveItemsShouldNotChangeContentY()

2072 {

2073 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

2074 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

2075 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

2076

2077 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2078 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2079 verifyItem(0, 50., 190., false, "Agressive", false);

2080 QCOMPARE(lvwph->m_minYExtent, 0.);

2081 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2082 QCOMPARE(lvwph->m_clipItem->clip(), false);

2083 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2084 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2085 QCOMPARE(lvwph->contentY(), 0.);

2086 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2087

2088 QCOMPARE(spy.count(), 0);

2089 }

2090

2091 void testDownAndUp()

2092 {

2093 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2094

2095 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2096 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2097 verifyItem(0, 50., 190., false, "Agressive", false);

2098 QCOMPARE(lvwph->m_minYExtent, 0.);

2099 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2100 QCOMPARE(lvwph->m_clipItem->clip(), false);

2101 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2102 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2103 QCOMPARE(lvwph->contentY(), 0.);

2104 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2105 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2106

2107 QTest::qWait(1);

2108 QCoreApplication::instance()->processEvents();

2109

2110 changeContentY(-15);

2111

2112 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2113 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2114 verifyItem(0, 65., 190., false, "Agressive", false);

2115 QCOMPARE(lvwph->m_minYExtent, 0.);

2116 QCOMPARE(lvwph->m_clipItem->y(), -15.);

2117 QCOMPARE(lvwph->m_clipItem->clip(), false);

2118 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2119 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2120 QCOMPARE(lvwph->contentY(), -15.);

2121 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2122 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2123

2124 changeContentY(25);

2125

2126 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2127 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2128 verifyItem(0, 40., 190., false, "Agressive", false);

2129 QCOMPARE(lvwph->m_minYExtent, 0.);

2130 QCOMPARE(lvwph->m_clipItem->y(), 10.);

2131 QCOMPARE(lvwph->m_clipItem->clip(), false);

2132 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2133 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2134 QCOMPARE(lvwph->contentY(), 10.);

2135 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2136 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2137

2138

2139 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2140

2141 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2142 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2143 verifyItem(0, 50., 190., false, "Agressive", false);

2144 QCOMPARE(lvwph->m_minYExtent, 0.);

2145 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2146 QCOMPARE(lvwph->m_clipItem->clip(), false);

2147 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2148 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2149 QCOMPARE(lvwph->contentY(), 0.);

2150 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2151 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2152 }

2153

2154private:

2155 QQuickView *view;

2156 ListViewWithPageHeader *lvwph;

2157 QQmlListModel *model;

2158 QQmlComponent *otherDelegate;

2159};

2160

2161QTEST_MAIN(ListViewWithPageHeaderTestSection)

2162

2163#include "listviewwithpageheadersectiontest.moc"