tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp · unity8

git.iko.soy/unity8

on 084ae64 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp

1627 lines 75 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QtTestGui>

23#pragma GCC diagnostic push

24#pragma GCC diagnostic ignored "-pedantic"

25#include <private/qquicklistmodel_p.h>

26#include <private/qquickanimation_p.h>

27#include <private/qquickitem_p.h>

28#pragma GCC diagnostic pop

30class ListViewWithPageHeaderTestSection : public QObject

31{

32 Q_OBJECT

34private:

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

36 {

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

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

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

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

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

42 if (!sectionHeader.isNull()) {

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

44 }

45 }

47 void changeContentY(qreal change)

48 {

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

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

51 const qreal jump = 25;

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

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

54 QTest::qWait(1);

55 }

56 } else {

57 const qreal jump = -25;

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

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

60 QTest::qWait(1);

61 }

62 }

63 lvwph->setContentY(dest);

64 QTest::qWait(1);

65 }

67 void scrollToTop()

68 {

69 const qreal jump = -25;

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

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

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

73 } else {

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

75 }

76 QTest::qWait(1);

77 }

78 }

80 void scrollToBottom()

81 {

82 const qreal jump = 25;

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

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

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

86 } else {

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

88 }

89 QTest::qWait(1);

90 }

91 }

93 void verifyInitialTopPosition()

94 {

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

96 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

108 }

109

110 QString section(QQuickItem *item)

111 {

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

113 }

114

115private Q_SLOTS:

116

117 void initTestCase()

118 {

119 }

120

121 void init()

122 {

123 view = new QQuickView();

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

125 view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test_section.qml"));

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

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

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

129 QVERIFY(lvwph);

130 QVERIFY(model);

131 QVERIFY(otherDelegate);

132 view->show();

133 QTest::qWaitForWindowExposed(view);

134

135 verifyInitialTopPosition();

136 }

137

138 void cleanup()

139 {

140 delete view;

141 }

142

143 void testCreationDeletion()

144 {

145 // Nothing, init/cleanup already tests this

146 }

147

148 void testDrag1PixelUp()

149 {

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

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

152 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

164 }

165

166 void testHeaderDetachDragDown()

167 {

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QTest::qWait(100);

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

179 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

191

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

193

194 verifyInitialTopPosition();

195 }

196

197 void testDrag375PixelUp()

198 {

199 changeContentY(375);

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

201 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

216 }

217

218 void testDrag520PixelUp()

219 {

220 changeContentY(520);

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

222 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

227 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

237 }

238

239 void testDragHeaderUpThenShow()

240 {

241 changeContentY(120);

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

243 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

258

259 changeContentY(-30);

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

261 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

276 }

277

278 void testDragHeaderUpThenShowWithoutHidingTotally()

279 {

280 changeContentY(10);

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

282 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

294

295 changeContentY(-1);

296

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

298 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

310 }

311

312 void testPositionAtBeginningIndex0Visible()

313 {

314 changeContentY(375);

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

316 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

331

332 lvwph->positionAtBeginning();

333

334 verifyInitialTopPosition();

335 }

336

337 void testPositionAtBeginningIndex0NotVisible()

338 {

339 changeContentY(520);

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

341 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

346 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

356

357 lvwph->positionAtBeginning();

358

359 verifyInitialTopPosition();

360 }

361

362 void testIndex0GrowOnScreen()

363 {

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

365

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

367 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

379 }

380

381 void testIndex0GrowOffScreen()

382 {

383 changeContentY(375);

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

385 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

400

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

402

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

404 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

405 verifyItem(0, -575., 440., 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, 250.);

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

419

420 scrollToTop();

421

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

423 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

435

436 changeContentY(30);

437

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

439 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

451 }

452

453 void testIndex0GrowNotCreated()

454 {

455 changeContentY(520);

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

457 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

462 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

472

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

474

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

476 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

481 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

491

492 scrollToTop();

493

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

495 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

507 }

508

509 void testShowHideShowHeaderAtBottom()

510 {

511 scrollToBottom();

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

513 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

527

528 changeContentY(-30);

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

530 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

544

545 changeContentY(30);

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

547 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

561

562 changeContentY(-30);

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

564 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

578 }

579

580 void testChangeDelegateAtBottom()

581 {

582 scrollToBottom();

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

584 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

598

599 lvwph->setDelegate(otherDelegate);

600

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

602 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

617 }

618

619 void testSetEmptyHeaderAtTop()

620 {

621 lvwph->setHeader(nullptr);

622

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

624 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

635 }

636

637 void testSetEmptyHeaderAtBottom()

638 {

639 scrollToBottom();

640 lvwph->setHeader(nullptr);

641

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

643 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

656

657 scrollToTop();

658

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

660 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

671 }

672

673 void testSetEmptyHeaderWhenPartlyShownClipped()

674 {

675 scrollToBottom();

676 changeContentY(-30);

677 lvwph->setHeader(nullptr);

678

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

680 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

690 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

694

695 scrollToTop();

696

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

698 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

709 }

710

711 void testSetEmptyHeaderWhenPartlyShownNotClipped()

712 {

713 changeContentY(30);

714 lvwph->setHeader(nullptr);

715

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

717 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

730 }

731

732 void testSetNullDelegate()

733 {

734 lvwph->setDelegate(nullptr);

735

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

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

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

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

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

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

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

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

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

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

746 QVERIFY(lvwph->isAtYBeginning());

747 QVERIFY(lvwph->isAtYEnd());

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

749 }

750

751 void testInsertItems()

752 {

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

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

755

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

757 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

771 }

772

773 void testInsertItemsStealSectionItem()

774 {

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

776

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

778 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

791 }

792

793

794 void testInsertItemsOnNotShownPosition()

795 {

796 changeContentY(800);

797

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

799 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

814

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

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

817

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

819 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

834

835 scrollToTop();

836

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

838 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

852 }

853

854 void testInsertItemsAtEndOfViewport()

855 {

856 changeContentY(60);

857

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

859 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

874

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

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

877

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

879 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

894 }

895

896 void testInsertItemsBeforeValidIndex()

897 {

898 changeContentY(520);

899

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

901 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

906 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

916

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

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

919

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

921 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

926 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

936 }

937

938 void testInsertItemsBeforeViewport()

939 {

940 changeContentY(375);

941

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

943 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

958

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

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

961

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

963 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

978

979 scrollToTop();

980

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

982 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

996 }

997

998 void testInsertItemsAtBottom()

999 {

1000 scrollToBottom();

1001

1002 QVERIFY(lvwph->isAtYEnd());

1003

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

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

1006

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

1008 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1025

1026 scrollToBottom();

1027

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

1029 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1041 QVERIFY(lvwph->isAtYEnd());

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

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

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

1045 }

1046

1047 void testInsertItemAtTop()

1048 {

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

1050

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

1052 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1064 QVERIFY(lvwph->isAtYBeginning());

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

1066 }

1067

1068 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1069 {

1070 scrollToBottom();

1071

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

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

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

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

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

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

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

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

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

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

1082

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

1084 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

1098

1099 changeContentY(-1700);

1100

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

1102 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1112 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

1122 }

1123

1124 void testRemoveItemsAtTop()

1125 {

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

1127

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

1129 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1139 QVERIFY(lvwph->isAtYBeginning());

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

1141 }

1142

1143 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1144 {

1145 scrollToBottom();

1146

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

1148

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

1150 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

1164 }

1165

1166 void testRemoveLastItemsAtBottom()

1167 {

1168 scrollToBottom();

1169

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

1171

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

1173 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

1187 }

1188

1189 void testRemoveItemOutOfViewport()

1190 {

1191 changeContentY(520);

1192

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

1194 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1199 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

1209

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

1211

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

1213 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1228 }

1229

1230 void testRemoveFirstOfCategory()

1231 {

1232 changeContentY(520);

1233

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

1235 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

1239 verifyItem(3, 740, 350., true, QString(), true);

1240 QCOMPARE(lvwph->m_minYExtent, 152.5);

1241 QCOMPARE(lvwph->m_clipItem->y(), 520.);

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(), 520.);

1246 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1247 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1248 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1249 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1250

1251 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1252

1253 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1254 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1255 verifyItem(0, -280., 240., true, "Regular", true);

1256 verifyItem(1, -40, 390., false, "Mild", true);

1257 verifyItem(2, 350, 390., false, "Bold", false);

1258 verifyItem(3, 740, 390., true, "Lazy", true);

1259 QCOMPARE(lvwph->m_minYExtent, 162.5);

1260 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1261 QCOMPARE(lvwph->m_clipItem->clip(), false);

1262 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1263 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1264 QCOMPARE(lvwph->contentY(), 520.);

1265 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1266 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1267 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1268 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1269 }

1270

1271 void testAddSecondToCulledCategoryOfTwo()

1272 {

1273 // Do some setup

1274 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1275 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1276

1277 changeContentY(200);

1278

1279 // Very the items are culled

1280 verifyItem(0, -150., 65., true, "Agressive", true);

1281 verifyItem(1, -85, 25., true, QString(), true);

1282

1283 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1284

1285 // Very the new item is there correctly

1286 verifyItem(0, -175., 65., true, "Agressive", true);

1287 verifyItem(1, -110, 25., true, QString(), true);

1288 verifyItem(2, -85, 25., true, QString(), true);

1289 }

1290

1291 void testMoveFirstItems()

1292 {

1293 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1294

1295 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1296 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1297 verifyItem(0, 50., 240., false, "Regular", false);

1298 verifyItem(1, 290., 190., false, "Agressive", false);

1299 verifyItem(2, 480., 390., false, "Mild", false);

1300 QCOMPARE(lvwph->m_minYExtent, 0.);

1301 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1302 QCOMPARE(lvwph->m_clipItem->clip(), false);

1303 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1304 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1305 QCOMPARE(lvwph->contentY(), 0.);

1306 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1307 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1308 }

1309

1310 void testMoveFirstOutOfVisibleItems()

1311 {

1312 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1313

1314 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1315 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1316 verifyItem(0, 50., 240., false, "Regular", false);

1317 verifyItem(1, 290., 390., false, "Mild", false);

1318 verifyItem(2, 680., 390., true, "Bold", true);

1319 QCOMPARE(lvwph->m_minYExtent, 0.);

1320 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1321 QCOMPARE(lvwph->m_clipItem->clip(), false);

1322 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1323 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1324 QCOMPARE(lvwph->contentY(), 0.);

1325 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1326 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1327 }

1328

1329 void testMoveFirstToLastAtBottom()

1330 {

1331 scrollToBottom();

1332

1333 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1334 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1335 verifyItem(0, -588., 390., true, "Bold", true);

1336 verifyItem(1, -198, 350., false, QString(), true);

1337 verifyItem(2, 152, 390., false, "Lazy", false);

1338 QCOMPARE(lvwph->m_minYExtent, 310.);

1339 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1340 QCOMPARE(lvwph->m_clipItem->clip(), false);

1341 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1342 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1343 QCOMPARE(lvwph->contentY(), 1458.);

1344 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1345 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1346 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1347 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1348

1349 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1350

1351 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1352 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1353 verifyItem(0, -588., 390., true, "Bold", true);

1354 verifyItem(1, -198, 350., false, QString(), true);

1355 verifyItem(2, 152, 390., false, "Lazy", false);

1356 verifyItem(3, 542, 190., true, "Agressive", true);

1357 QCOMPARE(lvwph->m_minYExtent, -160.);

1358 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1359 QCOMPARE(lvwph->m_clipItem->clip(), false);

1360 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1361 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1362 QCOMPARE(lvwph->contentY(), 1458.);

1363 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1364 QVERIFY(!lvwph->isAtYEnd());

1365 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1366 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1367 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1368 }

1369

1370 void testChangeSizeVisibleItemNotOnViewport()

1371 {

1372 changeContentY(490);

1373

1374 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1375 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1376 verifyItem(0, -440., 190., true, "Agressive", true);

1377 verifyItem(1, -250., 240., true, "Regular", true);

1378 verifyItem(2, -10, 390., false, "Mild", true);

1379 verifyItem(3, 380, 390., false, "Bold", false);

1380 verifyItem(4, 770, 350., true, QString(), true);

1381 QCOMPARE(lvwph->m_minYExtent, 0.);

1382 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1383 QCOMPARE(lvwph->m_clipItem->clip(), false);

1384 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1385 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1386 QCOMPARE(lvwph->contentY(), 490.);

1387 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1388 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1389 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1390 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1391

1392 model->setProperty(1, "size", 100);

1393

1394 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1395 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1396 verifyItem(0, -340., 190., true, "Agressive", true);

1397 verifyItem(1, -150., 140., true, "Regular", true);

1398 verifyItem(2, -10, 390., false, "Mild", true);

1399 verifyItem(3, 380, 390., false, "Bold", false);

1400 verifyItem(4, 770, 350., true, QString(), true);

1401 QCOMPARE(lvwph->m_minYExtent, -100.);

1402 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1403 QCOMPARE(lvwph->m_clipItem->clip(), false);

1404 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1405 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1406 QCOMPARE(lvwph->contentY(), 490.);

1407 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1408 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1409 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1410 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1411 }

1412

1413 void testShowHeaderHalfShown()

1414 {

1415#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1416 QSKIP("This test is extremely unstable in 5.0.x");

1417#endif

1418 changeContentY(20);

1419

1420 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1422 verifyItem(0, 30., 190., false, "Agressive", false);

1423 verifyItem(1, 220, 240., false, "Regular", false);

1424 verifyItem(2, 460, 390., false, "Mild", false);

1425 QCOMPARE(lvwph->m_minYExtent, 0.);

1426 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1427 QCOMPARE(lvwph->m_clipItem->clip(), false);

1428 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1429 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1430 QCOMPARE(lvwph->contentY(), 20.);

1431 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1432 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1433

1434 lvwph->showHeader();

1435

1436 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1437 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1438 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1439 verifyItem(0, -20., 190., false, "Agressive", true);

1440 verifyItem(1, 170, 240., false, "Regular", false);

1441 verifyItem(2, 410, 390., false, "Mild", false);

1442 QCOMPARE(lvwph->m_minYExtent, 20.);

1443 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1444 QCOMPARE(lvwph->m_clipItem->clip(), true);

1445 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1446 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1447 QCOMPARE(lvwph->contentY(), 0.);

1448 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1449 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1450 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1451 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1452

1453 scrollToTop();

1454

1455 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1456 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1457 verifyItem(0, 50., 190., false, "Agressive", false);

1458 verifyItem(1, 240., 240., false, "Regular", false);

1459 verifyItem(2, 480., 390., false, "Mild", false);

1460 QCOMPARE(lvwph->m_minYExtent, 20.);

1461 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1462 QCOMPARE(lvwph->m_clipItem->clip(), false);

1463 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1464 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1465 QCOMPARE(lvwph->contentY(), -20.);

1466 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1467 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1468 }

1469

1470 void testShowHeaderCloseToTheTop()

1471 {

1472 changeContentY(375);

1473

1474 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1475 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1476 verifyItem(0, -325., 190., true, "Agressive", true);

1477 verifyItem(1, -135, 240., false, "Regular", true);

1478 verifyItem(2, 105, 390., false, "Mild", false);

1479 verifyItem(3, 495, 390., false, "Bold", false);

1480 QCOMPARE(lvwph->m_minYExtent, 0.);

1481 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1482 QCOMPARE(lvwph->m_clipItem->clip(), false);

1483 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1484 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1485 QCOMPARE(lvwph->contentY(), 375.);

1486 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1487 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1488 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1489 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1490

1491 lvwph->showHeader();

1492

1493 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1494 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1495 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1496 verifyItem(0, -375., 190., true, "Agressive", true);

1497 verifyItem(1, -185, 240., false, "Regular", true);

1498 verifyItem(2, 55, 390., false, "Mild", false);

1499 verifyItem(3, 445, 390., false, "Bold", false);

1500 QCOMPARE(lvwph->m_minYExtent, 50.);

1501 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1502 QCOMPARE(lvwph->m_clipItem->clip(), true);

1503 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1504 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1505 QCOMPARE(lvwph->contentY(), 325.);

1506 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1507 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1508 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1509 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1510

1511 scrollToTop();

1512

1513 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1514 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1515 verifyItem(0, 50., 190., false, "Agressive", false);

1516 verifyItem(1, 240., 240., false, "Regular", false);

1517 verifyItem(2, 480., 390., false, "Mild", false);

1518 QCOMPARE(lvwph->m_minYExtent, 50.);

1519 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1520 QCOMPARE(lvwph->m_clipItem->clip(), false);

1521 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1522 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1523 QCOMPARE(lvwph->contentY(), -50.);

1524 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1525 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1526 }

1527

1528 void testShowHeaderAtBottom()

1529 {

1530 scrollToBottom();

1531

1532 lvwph->showHeader();

1533

1534 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1535 QTRY_VERIFY (lvwph->isAtYEnd());

1536 }

1537

1538 void growWindow()

1539 {

1540 view->rootObject()->setHeight(850);

1541

1542 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1543 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1544 verifyItem(0, 50., 190., false, "Agressive", false);

1545 verifyItem(1, 240., 240., false, "Regular", false);

1546 verifyItem(2, 480., 390., false, "Mild", false);

1547 verifyItem(3, 870., 390., true, "Bold", true);

1548 verifyItem(4, 1260., 350., true, QString(), true);

1549 QCOMPARE(lvwph->m_minYExtent, 0.);

1550 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1551 QCOMPARE(lvwph->m_clipItem->clip(), false);

1552 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1553 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1554 QCOMPARE(lvwph->contentY(), 0.);

1555 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1556 }

1557

1558 void growWindowAtBottom()

1559 {

1560 // Need a bunch small items at the bottom to trigger the problem

1561 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1562 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1563 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1564 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1565 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1566 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1567 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1568 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1569 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1570 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1571 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1572 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1573 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1574 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1575 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1576 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1577 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1578 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1579 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1580 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1581

1582 scrollToBottom();

1583

1584 view->rootObject()->setHeight(850);

1585

1586 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1587 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1588 verifyItem(0, -660., 390., true, "Lazy", true);

1589 verifyItem(1, -270., 90., true, "Agressive", true);

1590 verifyItem(2, -180, 50., true, QString(), true);

1591 verifyItem(3, -130, 50., true, QString(), true);

1592 verifyItem(4, -80, 50., true, QString(), true);

1593 verifyItem(5, -30, 50., false, QString(), true);

1594 verifyItem(6, 20, 50., false, QString(), true);

1595 verifyItem(7, 70, 50., false, QString(), true);

1596 verifyItem(8, 120, 50., false, QString(), true);

1597 verifyItem(9, 170, 90., false, "Regular", false);

1598 verifyItem(10, 260, 50., false, QString(), true);

1599 verifyItem(11, 310, 50., false, QString(), true);

1600 verifyItem(12, 360, 50., false, QString(), true);

1601 verifyItem(13, 410, 50., false, QString(), true);

1602 verifyItem(14, 460, 50., false, QString(), true);

1603 verifyItem(15, 510, 90., false, "Agressive", false);

1604 verifyItem(16, 600, 50., false, QString(), true);

1605 verifyItem(17, 650, 50., false, QString(), true);

1606 verifyItem(18, 700, 50., false, QString(), true);

1607 verifyItem(19, 750, 50., false, QString(), true);

1608 verifyItem(20, 800, 50., false, QString(), true);

1609 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - 1970 + 50);

1610 QCOMPARE(lvwph->m_clipItem->y(), 1970.);

1611 QCOMPARE(lvwph->m_clipItem->clip(), false);

1612 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1613 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1614 QCOMPARE(lvwph->contentY(), 1970.);

1615 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1616 }

1617

1618private:

1619 QQuickView *view;

1620 ListViewWithPageHeader *lvwph;

1621 QQuickListModel *model;

1622 QQmlComponent *otherDelegate;

1623};

1624

1625QTEST_MAIN(ListViewWithPageHeaderTestSection)

1626

1627#include "listviewwithpageheadertestsection.moc"