tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp · unity8

git.iko.soy/unity8

on dc488a7 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp

2071 lines 95 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QtTestGui>

23#pragma GCC diagnostic push

24#pragma GCC diagnostic ignored "-pedantic"

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

26#include <private/qquicklistmodel_p.h>

27#else

28#include <private/qqmllistmodel_p.h>

29#endif

30#include <private/qquickanimation_p.h>

31#include <private/qquickitem_p.h>

32#pragma GCC diagnostic pop

34class ListViewWithPageHeaderTestSection : public QObject

35{

36 Q_OBJECT

38private:

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

40 {

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

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

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

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

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

46 if (!sectionHeader.isNull()) {

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

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

49 }

50 }

52 void changeContentY(qreal change)

53 {

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

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

56 const qreal jump = 25;

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

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

59 QTest::qWait(1);

60 }

61 } else {

62 const qreal jump = -25;

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

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

65 QTest::qWait(1);

66 }

67 }

68 lvwph->setContentY(dest);

69 QTest::qWait(1);

70 }

72 void scrollToTop()

73 {

74 const qreal jump = -25;

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

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

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

78 } else {

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

80 }

81 QTest::qWait(1);

82 }

83 }

85 void scrollToBottom()

86 {

87 const qreal jump = 25;

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

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

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

91 } else {

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

93 }

94 QTest::qWait(1);

95 }

96 }

98 void verifyInitialTopPosition()

99 {

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

101 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

113 }

114

115 QString section(QQuickItem *item)

116 {

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

118 }

119

120 int sectionDelegateIndex(QQuickItem *item)

121 {

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

123 }

124

125private Q_SLOTS:

126

127 void initTestCase()

128 {

129 }

130

131 void init()

132 {

133 view = new QQuickView();

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

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

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

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

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

139#else

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

141#endif

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

143 QVERIFY(lvwph);

144 QVERIFY(model);

145 QVERIFY(otherDelegate);

146 view->show();

147 QTest::qWaitForWindowExposed(view);

148

149 verifyInitialTopPosition();

150 }

151

152 void cleanup()

153 {

154 delete view;

155 }

156

157 void testCreationDeletion()

158 {

159 // Nothing, init/cleanup already tests this

160 }

161

162 void testDrag1PixelUp()

163 {

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

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

166 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

178 }

179

180 void testHeaderDetachDragDown()

181 {

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

183 QTest::qWait(100);

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

185 QTest::qWait(100);

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

187 QTest::qWait(100);

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

189 QTest::qWait(100);

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

191 QTest::qWait(100);

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

193 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

205

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

207

208 verifyInitialTopPosition();

209 }

210

211 void testDrag375PixelUp()

212 {

213 changeContentY(375);

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

215 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

231 }

232

233 void testDrag520PixelUp()

234 {

235 changeContentY(520);

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

237 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

242 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

253 }

254

255 void testDragHeaderUpThenShow()

256 {

257 changeContentY(120);

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

259 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

275

276 changeContentY(-30);

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

278 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

294 }

295

296 void testDragHeaderUpThenShowWithoutHidingTotally()

297 {

298 changeContentY(10);

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

300 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

312

313 changeContentY(-1);

314

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

316 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

328 }

329

330 void testPositionAtBeginningIndex0Visible()

331 {

332 changeContentY(375);

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

334 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

350

351 lvwph->positionAtBeginning();

352

353 verifyInitialTopPosition();

354 }

355

356 void testPositionAtBeginningIndex0NotVisible()

357 {

358 changeContentY(520);

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

360 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

365 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

376

377 lvwph->positionAtBeginning();

378

379 verifyInitialTopPosition();

380 }

381

382 void testIndex0GrowOnScreen()

383 {

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

385

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

387 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

399 }

400

401 void testIndex0GrowOffScreen()

402 {

403 changeContentY(375);

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

405 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

421

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

423

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

425 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

441

442 scrollToTop();

443

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

445 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

457

458 changeContentY(30);

459

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

461 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

473 }

474

475 void testIndex0GrowNotCreated()

476 {

477 changeContentY(520);

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

479 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

484 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

495

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

497

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

499 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

504 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

515

516 scrollToTop();

517

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

519 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

531 }

532

533 void testShowHideShowHeaderAtBottom()

534 {

535 scrollToBottom();

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

537 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

552

553 changeContentY(-30);

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

555 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

570

571 changeContentY(30);

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

573 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

588

589 changeContentY(-30);

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

591 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

606 }

607

608 void testChangeDelegateAtBottom()

609 {

610 scrollToBottom();

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

612 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

627

628 lvwph->setDelegate(otherDelegate);

629

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

631 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

646 }

647

648 void testSetEmptyHeaderAtTop()

649 {

650 lvwph->setHeader(nullptr);

651

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

653 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

664 }

665

666 void testSetEmptyHeaderAtBottom()

667 {

668 scrollToBottom();

669 lvwph->setHeader(nullptr);

670

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

672 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

686

687 scrollToTop();

688

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

690 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

701 }

702

703 void testSetEmptyHeaderWhenPartlyShownClipped()

704 {

705 scrollToBottom();

706 changeContentY(-30);

707 lvwph->setHeader(nullptr);

708

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

710 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

720 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

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

725

726 scrollToTop();

727

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

729 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

740 }

741

742 void testSetEmptyHeaderWhenPartlyShownNotClipped()

743 {

744 changeContentY(30);

745 lvwph->setHeader(nullptr);

746

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

748 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

762 }

763

764 void testSetNullDelegate()

765 {

766 lvwph->setDelegate(nullptr);

767

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

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

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

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

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

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

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

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

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

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

778 QVERIFY(lvwph->isAtYBeginning());

779 QVERIFY(lvwph->isAtYEnd());

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

781 }

782

783 void testInsertItems()

784 {

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

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

787

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

789 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

803 }

804

805 void testInsertItemsStealSectionItem()

806 {

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

808

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

810 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

823 }

824

825

826 void testInsertItemsOnNotShownPosition()

827 {

828 changeContentY(800);

829

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

831 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

847

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

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

850

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

852 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

868

869 scrollToTop();

870

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

872 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

886 }

887

888 void testInsertItemsAtEndOfViewport()

889 {

890 changeContentY(60);

891

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

893 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

909

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

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

912

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

914 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

930 }

931

932 void testInsertItemsBeforeValidIndex()

933 {

934 changeContentY(520);

935

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

937 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

942 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

953

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

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

956

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

958 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

963 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

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

974 }

975

976 void testInsertItemsBeforeViewport()

977 {

978 changeContentY(375);

979

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

981 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

997

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

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

1000

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

1002 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1018

1019 scrollToTop();

1020

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

1022 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1036 }

1037

1038 void testInsertItemsAtBottom()

1039 {

1040 scrollToBottom();

1041

1042 QVERIFY(lvwph->isAtYEnd());

1043

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

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

1046

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

1048 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1066

1067 scrollToBottom();

1068

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

1070 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1082 QVERIFY(lvwph->isAtYEnd());

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

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

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

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

1087 }

1088

1089 void testInsertItemAtTop()

1090 {

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

1092

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

1094 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1106 QVERIFY(lvwph->isAtYBeginning());

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

1108 }

1109

1110 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1111 {

1112 scrollToBottom();

1113

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

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

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

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

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

1124

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

1126 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1141

1142 changeContentY(-1700);

1143

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

1145 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1155 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

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

1166 }

1167

1168 void testInsertToEmpty()

1169 {

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

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

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

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

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

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

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

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

1178

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

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

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

1182 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1185 }

1186

1187 void testRemoveItemsAtTop()

1188 {

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

1190

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

1192 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1202 QVERIFY(lvwph->isAtYBeginning());

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

1204 }

1205

1206 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1207 {

1208 scrollToBottom();

1209

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

1211

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

1213 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

1216 verifyItem(2, 152, 390., false, "Lazy", false);

1217 QCOMPARE(lvwph->m_minYExtent, -1330./3.);

1218 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1219 QCOMPARE(lvwph->m_clipItem->clip(), false);

1220 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1221 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1222 QCOMPARE(lvwph->contentY(), 1458.);

1223 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1224 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1225 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1226 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1227 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1228 }

1229

1230 void testRemoveLastItemsAtBottom()

1231 {

1232 scrollToBottom();

1233

1234 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));

1235

1236 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1237 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1238 verifyItem(0, -478., 240., true, "Regular", true);

1239 verifyItem(1, -238, 390., false, "Mild", true);

1240 verifyItem(2, 152, 390., false, "Bold", false);

1241 QCOMPARE(lvwph->m_minYExtent, 150.);

1242 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1243 QCOMPARE(lvwph->m_clipItem->clip(), false);

1244 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1245 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1246 QCOMPARE(lvwph->contentY(), 718.);

1247 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1248 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1249 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1250 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1251 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1252 }

1253

1254 void testRemoveItemOutOfViewport()

1255 {

1256 changeContentY(520);

1257

1258 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1259 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1260 verifyItem(0, -280., 240., true, "Regular", true);

1261 verifyItem(1, -40, 390., false, "Mild", true);

1262 verifyItem(2, 350, 390., false, "Bold", false);

1263 verifyItem(3, 740, 350., true, QString(), true);

1264 QCOMPARE(lvwph->m_minYExtent, 152.5);

1265 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1266 QCOMPARE(lvwph->m_clipItem->clip(), false);

1267 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1268 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1269 QCOMPARE(lvwph->contentY(), 520.);

1270 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1271 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1272 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1273 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1274 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1275

1276 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1277

1278 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1279 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1280 verifyItem(0, -230., 190., true, "Agressive", true);

1281 verifyItem(1, -40, 390., false, "Mild", true);

1282 verifyItem(2, 350, 390., false, "Bold", false);

1283 verifyItem(3, 740, 350., true, QString(), true);

1284 QCOMPARE(lvwph->m_minYExtent, -240.);

1285 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1286 QCOMPARE(lvwph->m_clipItem->clip(), false);

1287 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1288 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1289 QCOMPARE(lvwph->contentY(), 520.);

1290 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1291 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1292 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1293 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1294 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1295 }

1296

1297 void testRemoveFirstOfCategory()

1298 {

1299 changeContentY(520);

1300

1301 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1302 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1303 verifyItem(0, -280., 240., true, "Regular", true);

1304 verifyItem(1, -40, 390., false, "Mild", true);

1305 verifyItem(2, 350, 390., false, "Bold", false);

1306 verifyItem(3, 740, 350., true, QString(), true);

1307 QCOMPARE(lvwph->m_minYExtent, 152.5);

1308 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1309 QCOMPARE(lvwph->m_clipItem->clip(), false);

1310 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1311 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1312 QCOMPARE(lvwph->contentY(), 520.);

1313 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1314 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1315 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1316 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1317 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1318

1319 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1320

1321 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1322 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1323 verifyItem(0, -280., 240., true, "Regular", true);

1324 verifyItem(1, -40, 390., false, "Mild", true);

1325 verifyItem(2, 350, 390., false, "Bold", false);

1326 verifyItem(3, 740, 390., true, "Lazy", true);

1327 QCOMPARE(lvwph->m_minYExtent, 162.5);

1328 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1329 QCOMPARE(lvwph->m_clipItem->clip(), false);

1330 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1331 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1332 QCOMPARE(lvwph->contentY(), 520.);

1333 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1334 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1335 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1336 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1337 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1338 }

1339

1340 void testAddSecondToCulledCategoryOfTwo()

1341 {

1342 // Do some setup

1343 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1344 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1345

1346 changeContentY(200);

1347

1348 // Very the items are culled

1349 verifyItem(0, -150., 65., true, "Agressive", true);

1350 verifyItem(1, -85, 25., true, QString(), true);

1351

1352 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1353

1354 // Very the new item is there correctly

1355 verifyItem(0, -175., 65., true, "Agressive", true);

1356 verifyItem(1, -110, 25., true, QString(), true);

1357 verifyItem(2, -85, 25., true, QString(), true);

1358 }

1359

1360 void testMoveFirstItems()

1361 {

1362 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1363

1364 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1365 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1366 verifyItem(0, 50., 240., false, "Regular", false);

1367 verifyItem(1, 290., 190., false, "Agressive", false);

1368 verifyItem(2, 480., 390., false, "Mild", false);

1369 QCOMPARE(lvwph->m_minYExtent, 0.);

1370 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1371 QCOMPARE(lvwph->m_clipItem->clip(), false);

1372 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1373 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1374 QCOMPARE(lvwph->contentY(), 0.);

1375 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1376 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1377 }

1378

1379 void testMoveFirstOutOfVisibleItems()

1380 {

1381 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1382

1383 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1384 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1385 verifyItem(0, 50., 240., false, "Regular", false);

1386 verifyItem(1, 290., 390., false, "Mild", false);

1387 verifyItem(2, 680., 390., true, "Bold", true);

1388 QCOMPARE(lvwph->m_minYExtent, 0.);

1389 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1390 QCOMPARE(lvwph->m_clipItem->clip(), false);

1391 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1392 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1393 QCOMPARE(lvwph->contentY(), 0.);

1394 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1395 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1396 }

1397

1398 void testMoveFirstToLastAtBottom()

1399 {

1400 scrollToBottom();

1401

1402 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1403 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1404 verifyItem(0, -588., 390., true, "Bold", true);

1405 verifyItem(1, -198, 350., false, QString(), true);

1406 verifyItem(2, 152, 390., false, "Lazy", false);

1407 QCOMPARE(lvwph->m_minYExtent, 310.);

1408 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1409 QCOMPARE(lvwph->m_clipItem->clip(), false);

1410 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1411 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1412 QCOMPARE(lvwph->contentY(), 1458.);

1413 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1414 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1415 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1416 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1417 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1418

1419 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1420

1421 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1422 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1423 verifyItem(0, -588., 390., true, "Bold", true);

1424 verifyItem(1, -198, 350., false, QString(), true);

1425 verifyItem(2, 152, 390., false, "Lazy", false);

1426 verifyItem(3, 542, 190., true, "Agressive", true);

1427 QCOMPARE(lvwph->m_minYExtent, -160.);

1428 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1429 QCOMPARE(lvwph->m_clipItem->clip(), false);

1430 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1431 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1432 QCOMPARE(lvwph->contentY(), 1458.);

1433 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1434 QVERIFY(!lvwph->isAtYEnd());

1435 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1436 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1437 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1438 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1439 }

1440

1441 void testChangeSizeVisibleItemNotOnViewport()

1442 {

1443 changeContentY(490);

1444

1445 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1446 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1447 verifyItem(0, -440., 190., true, "Agressive", true);

1448 verifyItem(1, -250., 240., true, "Regular", true);

1449 verifyItem(2, -10, 390., false, "Mild", true);

1450 verifyItem(3, 380, 390., false, "Bold", false);

1451 verifyItem(4, 770, 350., true, QString(), true);

1452 QCOMPARE(lvwph->m_minYExtent, 0.);

1453 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1454 QCOMPARE(lvwph->m_clipItem->clip(), false);

1455 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1456 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1457 QCOMPARE(lvwph->contentY(), 490.);

1458 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1459 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1460 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1461 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1462 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1463

1464 model->setProperty(1, "size", 100);

1465

1466 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1467 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1468 verifyItem(0, -340., 190., true, "Agressive", true);

1469 verifyItem(1, -150., 140., true, "Regular", true);

1470 verifyItem(2, -10, 390., false, "Mild", true);

1471 verifyItem(3, 380, 390., false, "Bold", false);

1472 verifyItem(4, 770, 350., true, QString(), true);

1473 QCOMPARE(lvwph->m_minYExtent, -100.);

1474 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1475 QCOMPARE(lvwph->m_clipItem->clip(), false);

1476 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1477 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1478 QCOMPARE(lvwph->contentY(), 490.);

1479 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1480 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1481 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1482 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1483 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1484 }

1485

1486 void testShowHeaderHalfShown()

1487 {

1488#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1489 QSKIP("This test is extremely unstable in 5.0.x");

1490#endif

1491 changeContentY(20);

1492

1493 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1494 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1495 verifyItem(0, 30., 190., false, "Agressive", false);

1496 verifyItem(1, 220, 240., false, "Regular", false);

1497 verifyItem(2, 460, 390., false, "Mild", false);

1498 QCOMPARE(lvwph->m_minYExtent, 0.);

1499 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1500 QCOMPARE(lvwph->m_clipItem->clip(), false);

1501 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1502 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1503 QCOMPARE(lvwph->contentY(), 20.);

1504 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1505 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1506

1507 lvwph->showHeader();

1508

1509 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1510 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1511 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1512 verifyItem(0, -20., 190., false, "Agressive", true);

1513 verifyItem(1, 170, 240., false, "Regular", false);

1514 verifyItem(2, 410, 390., false, "Mild", false);

1515 QCOMPARE(lvwph->m_minYExtent, 20.);

1516 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1517 QCOMPARE(lvwph->m_clipItem->clip(), true);

1518 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1519 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1520 QCOMPARE(lvwph->contentY(), 0.);

1521 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1522 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1523 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1524 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1525 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1526

1527 scrollToTop();

1528

1529 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1530 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1531 verifyItem(0, 50., 190., false, "Agressive", false);

1532 verifyItem(1, 240., 240., false, "Regular", false);

1533 verifyItem(2, 480., 390., false, "Mild", false);

1534 QCOMPARE(lvwph->m_minYExtent, 20.);

1535 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1536 QCOMPARE(lvwph->m_clipItem->clip(), false);

1537 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1538 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1539 QCOMPARE(lvwph->contentY(), -20.);

1540 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1541 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1542 }

1543

1544 void testShowHeaderCloseToTheTop()

1545 {

1546 changeContentY(375);

1547

1548 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1549 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1550 verifyItem(0, -325., 190., true, "Agressive", true);

1551 verifyItem(1, -135, 240., false, "Regular", true);

1552 verifyItem(2, 105, 390., false, "Mild", false);

1553 verifyItem(3, 495, 390., false, "Bold", false);

1554 QCOMPARE(lvwph->m_minYExtent, 0.);

1555 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1556 QCOMPARE(lvwph->m_clipItem->clip(), false);

1557 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1558 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1559 QCOMPARE(lvwph->contentY(), 375.);

1560 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1561 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1562 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1563 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1564 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1565

1566 lvwph->showHeader();

1567

1568 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1569 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1570 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1571 verifyItem(0, -375., 190., true, "Agressive", true);

1572 verifyItem(1, -185, 240., false, "Regular", true);

1573 verifyItem(2, 55, 390., false, "Mild", false);

1574 verifyItem(3, 445, 390., false, "Bold", false);

1575 QCOMPARE(lvwph->m_minYExtent, 50.);

1576 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1577 QCOMPARE(lvwph->m_clipItem->clip(), true);

1578 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1579 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1580 QCOMPARE(lvwph->contentY(), 325.);

1581 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1582 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1583 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1584 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1585 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1586

1587 scrollToTop();

1588

1589 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1590 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1591 verifyItem(0, 50., 190., false, "Agressive", false);

1592 verifyItem(1, 240., 240., false, "Regular", false);

1593 verifyItem(2, 480., 390., false, "Mild", false);

1594 QCOMPARE(lvwph->m_minYExtent, 50.);

1595 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1596 QCOMPARE(lvwph->m_clipItem->clip(), false);

1597 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1598 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1599 QCOMPARE(lvwph->contentY(), -50.);

1600 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1601 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1602 }

1603

1604 void testShowHeaderAtBottom()

1605 {

1606 scrollToBottom();

1607

1608 lvwph->showHeader();

1609

1610 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1611 QTRY_VERIFY (lvwph->isAtYEnd());

1612 }

1613

1614 void growWindow()

1615 {

1616 view->rootObject()->setHeight(850);

1617

1618 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1619 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1620 verifyItem(0, 50., 190., false, "Agressive", false);

1621 verifyItem(1, 240., 240., false, "Regular", false);

1622 verifyItem(2, 480., 390., false, "Mild", false);

1623 verifyItem(3, 870., 390., true, "Bold", true);

1624 verifyItem(4, 1260., 350., true, QString(), true);

1625 QCOMPARE(lvwph->m_minYExtent, 0.);

1626 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1627 QCOMPARE(lvwph->m_clipItem->clip(), false);

1628 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1629 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1630 QCOMPARE(lvwph->contentY(), 0.);

1631 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1632 }

1633

1634 void growWindowAtBottom()

1635 {

1636 // Need a bunch small items at the bottom to trigger the problem

1637 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1638 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1639 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1640 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1643 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1644 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1645 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1646 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1647 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1648 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1649 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1650 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1651 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1652 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1653 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1654 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1655 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1656 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1657

1658 scrollToBottom();

1659

1660 view->rootObject()->setHeight(850);

1661

1662 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1663 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1664 verifyItem(0, -660., 390., true, "Lazy", true);

1665 verifyItem(1, -270., 90., true, "Agressive", true);

1666 verifyItem(2, -180, 50., true, QString(), true);

1667 verifyItem(3, -130, 50., true, QString(), true);

1668 verifyItem(4, -80, 50., true, QString(), true);

1669 verifyItem(5, -30, 50., false, QString(), true);

1670 verifyItem(6, 20, 50., false, QString(), true);

1671 verifyItem(7, 70, 50., false, QString(), true);

1672 verifyItem(8, 120, 50., false, QString(), true);

1673 verifyItem(9, 170, 90., false, "Regular", false);

1674 verifyItem(10, 260, 50., false, QString(), true);

1675 verifyItem(11, 310, 50., false, QString(), true);

1676 verifyItem(12, 360, 50., false, QString(), true);

1677 verifyItem(13, 410, 50., false, QString(), true);

1678 verifyItem(14, 460, 50., false, QString(), true);

1679 verifyItem(15, 510, 90., false, "Agressive", false);

1680 verifyItem(16, 600, 50., false, QString(), true);

1681 verifyItem(17, 650, 50., false, QString(), true);

1682 verifyItem(18, 700, 50., false, QString(), true);

1683 verifyItem(19, 750, 50., false, QString(), true);

1684 verifyItem(20, 800, 50., false, QString(), true);

1685 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - 1970 + 50);

1686 QCOMPARE(lvwph->m_clipItem->y(), 1970.);

1687 QCOMPARE(lvwph->m_clipItem->clip(), false);

1688 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1689 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1690 QCOMPARE(lvwph->contentY(), 1970.);

1691 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1692 }

1693

1694 void testCullOnBottomEdge()

1695 {

1696 changeContentY(240);

1697

1698 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1699 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1700 verifyItem(0, -190., 190., true, "Agressive", true);

1701 verifyItem(1, 0., 240., false, "Regular", false);

1702 verifyItem(2, 240., 390., false, "Mild", false);

1703 verifyItem(3, 630., 390., true, "Bold", true);

1704 QCOMPARE(lvwph->m_minYExtent, 0.);

1705 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1706 QCOMPARE(lvwph->m_clipItem->clip(), false);

1707 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1708 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1709 QCOMPARE(lvwph->contentY(), 240.);

1710 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1711 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1712 }

1713

1714 void testSectionItemCullOnFirstSectionItemTopEdge()

1715 {

1716 changeContentY(50);

1717

1718 verifyItem(0, 0., 190., false, "Agressive", false);

1719 verifyItem(1, 190., 240., false, "Regular", false);

1720 verifyItem(2, 430., 390., false, "Mild", false);

1721 QCOMPARE(lvwph->m_minYExtent, 0.);

1722 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1723 QCOMPARE(lvwph->m_clipItem->clip(), false);

1724 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1725 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1726 QCOMPARE(lvwph->contentY(), 50.);

1727 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1728 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1729 }

1730

1731 void testSectionItemCullOnSecondSectionItemTopEdge()

1732 {

1733 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1734 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1735

1736 changeContentY(140);

1737

1738 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1739 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1740 verifyItem(0, -90., 90., true, "Agressive", true);

1741 verifyItem(1, 0., 50., false, QString(), false);

1742 verifyItem(2, 50., 150., false, QString(), false);

1743 verifyItem(3, 200., 240., false, "Regular", false);

1744 verifyItem(4, 440., 390., false, "Mild", false);

1745 QCOMPARE(lvwph->m_minYExtent, 0.);

1746 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1747 QCOMPARE(lvwph->m_clipItem->clip(), false);

1748 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1749 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1750 QCOMPARE(lvwph->contentY(), 140.);

1751 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1752 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1753 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1754 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1755 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1756 }

1757

1758 void testMaximizeVisibleArea()

1759 {

1760 bool res = lvwph->maximizeVisibleArea(2);

1761 QVERIFY(res);

1762 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1763

1764 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1765 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1766 verifyItem(0, -278., 190., true, "Agressive", true);

1767 verifyItem(1, -88., 240., false, "Regular", true);

1768 verifyItem(2, 152, 390., false, "Mild", false);

1769 verifyItem(3, 542, 390., true, "Bold", true);

1770 QCOMPARE(lvwph->m_minYExtent, 0.);

1771 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1772 QCOMPARE(lvwph->m_clipItem->clip(), false);

1773 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1774 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1775 QCOMPARE(lvwph->contentY(), 328.);

1776 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1777 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1778 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1779 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1780 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1781 }

1782

1783 void testMaximizeVisibleAreaVisibleItems()

1784 {

1785 bool res = lvwph->maximizeVisibleArea(0);

1786 QVERIFY(res);

1787 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1788

1789 verifyInitialTopPosition();

1790

1791 res = lvwph->maximizeVisibleArea(1);

1792 QVERIFY(res);

1793 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1794

1795 verifyInitialTopPosition();

1796 }

1797

1798 void testMaximizeVisibleAreaInvalidIndexes()

1799 {

1800 bool res = lvwph->maximizeVisibleArea(-1);

1801 QVERIFY(!res);

1802 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1803

1804 verifyInitialTopPosition();

1805

1806 res = lvwph->maximizeVisibleArea(1000);

1807 QVERIFY(!res);

1808 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1809

1810 verifyInitialTopPosition();

1811

1812 res = lvwph->maximizeVisibleArea(3);

1813 QVERIFY(!res);

1814 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1815

1816 verifyInitialTopPosition();

1817 }

1818

1819 void testMaximizeVisibleAreaBigElement()

1820 {

1821 model->setProperty(2, "size", 4000);

1822 verifyItem(2, 480, 4040., false, "Mild", false);

1823

1824 bool res = lvwph->maximizeVisibleArea(2);

1825 QVERIFY(res);

1826 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1827

1828 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1829 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1830 verifyItem(0, -430., 190., true, "Agressive", true);

1831 verifyItem(1, -240., 240., true, "Regular", true);

1832 verifyItem(2, 0, 4040., false, "Mild", false);

1833 QCOMPARE(lvwph->m_minYExtent, 0.);

1834 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1835 QCOMPARE(lvwph->m_clipItem->clip(), false);

1836 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1837 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1838 QCOMPARE(lvwph->contentY(), 480.);

1839 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1840 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1841 }

1842

1843 void testMaximizeVisibleAreaScrollDown()

1844 {

1845 changeContentY(350);

1846 bool res = lvwph->maximizeVisibleArea(1);

1847 QVERIFY(res);

1848 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1849

1850 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1851 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1852 verifyItem(0, -190., 190., true, "Agressive", true);

1853 verifyItem(1, 0., 240., false, "Regular", false);

1854 verifyItem(2, 240, 390., false, "Mild", false);

1855 verifyItem(3, 630, 390., true, "Bold", true);

1856 QCOMPARE(lvwph->m_minYExtent, 0.);

1857 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1858 QCOMPARE(lvwph->m_clipItem->clip(), false);

1859 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1860 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1861 QCOMPARE(lvwph->contentY(), 240.);

1862 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1863 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1864 }

1865

1866 void testMaximizeVisibleAreaScrollDownBigElement()

1867 {

1868 model->setProperty(1, "size", 1000);

1869 changeContentY(1150);

1870 bool res = lvwph->maximizeVisibleArea(1);

1871 QVERIFY(res);

1872 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1873

1874 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1875 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1876 verifyItem(0, -498., 1040., false, "Regular", true);

1877 verifyItem(1, 542., 390., true, "Mild", true);

1878 QCOMPARE(lvwph->m_minYExtent, 1250/3.);

1879 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1880 QCOMPARE(lvwph->m_clipItem->clip(), false);

1881 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1882 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1883 QCOMPARE(lvwph->contentY(), 738.);

1884 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1885 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1886 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1887 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1888 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1889 }

1890

1891 void testMaximizeVisibleAreaBigElementInTheMiddle()

1892 {

1893 model->setProperty(1, "size", 1000);

1894 changeContentY(650);

1895

1896 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1897 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1898 verifyItem(0, -410., 1040., false, "Regular", true);

1899 verifyItem(1, 630., 390., true, "Mild", true);

1900 QCOMPARE(lvwph->m_minYExtent, 525.);

1901 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1902 QCOMPARE(lvwph->m_clipItem->clip(), false);

1903 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1904 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1905 QCOMPARE(lvwph->contentY(), 650.);

1906 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1907 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1908 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1909 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1910 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1911

1912 bool res = lvwph->maximizeVisibleArea(1);

1913 QVERIFY(res);

1914 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1915

1916 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1917 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1918 verifyItem(0, -410., 1040., false, "Regular", true);

1919 verifyItem(1, 630., 390., true, "Mild", true);

1920 QCOMPARE(lvwph->m_minYExtent, 525.);

1921 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1922 QCOMPARE(lvwph->m_clipItem->clip(), false);

1923 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1924 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1925 QCOMPARE(lvwph->contentY(), 650.);

1926 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1927 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1928 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1929 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1930 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1931 }

1932

1933 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1934 {

1935 changeContentY(430);

1936 changeContentY(-30);

1937

1938 bool res = lvwph->maximizeVisibleArea(1);

1939 QVERIFY(res);

1940 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1941

1942 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1943 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1944 verifyItem(0, -190., 190., true, "Agressive", true);

1945 verifyItem(1, 0., 240., false, "Regular", false);

1946 verifyItem(2, 240, 390., false, "Mild", false);

1947 verifyItem(3, 630, 390., true, "Bold", true);

1948 QCOMPARE(lvwph->m_minYExtent, 0.);

1949 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1950 QCOMPARE(lvwph->m_clipItem->clip(), false);

1951 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1952 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1953 QCOMPARE(lvwph->contentY(), 240.);

1954 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1955 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1956 }

1957

1958 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1959 {

1960 changeContentY(430);

1961 changeContentY(-30);

1962

1963 bool res = lvwph->maximizeVisibleArea(3);

1964 QVERIFY(res);

1965 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1966

1967 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1968 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1969 verifyItem(0, -478., 240., true, "Regular", true);

1970 verifyItem(1, -238., 390., false, "Mild", true);

1971 verifyItem(2, 152, 390., false, "Bold", false);

1972 verifyItem(3, 542, 350., true, QString(), true);

1973 QCOMPARE(lvwph->m_minYExtent, 152.5);

1974 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1975 QCOMPARE(lvwph->m_clipItem->clip(), false);

1976 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1977 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1978 QCOMPARE(lvwph->contentY(), 718.);

1979 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1980 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1981 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1982 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1983 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1984 }

1985

1986 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

1987 {

1988 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

1989 changeContentY(250);

1990 bool res = lvwph->maximizeVisibleArea(1);

1991 QVERIFY(res);

1992 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1993

1994 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1995 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1996 verifyItem(0, -100., 140., false, "Agressive", true);

1997 verifyItem(1, 40., 150., false, QString(), true);

1998 verifyItem(2, 190, 240., false, "Regular", false);

1999 verifyItem(3, 430, 390., false, "Mild", false);

2000 QCOMPARE(lvwph->m_minYExtent, 0.);

2001 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2002 QCOMPARE(lvwph->m_clipItem->clip(), false);

2003 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2004 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2005 QCOMPARE(lvwph->contentY(), 150.);

2006 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2007 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2008 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2009 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2010 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2011

2012 changeContentY(20);

2013 res = lvwph->maximizeVisibleArea(1);

2014 QVERIFY(res);

2015 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2016

2017 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2018 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2019 verifyItem(0, -100., 140., false, "Agressive", true);

2020 verifyItem(1, 40., 150., false, QString(), true);

2021 verifyItem(2, 190, 240., false, "Regular", false);

2022 verifyItem(3, 430, 390., false, "Mild", false);

2023 QCOMPARE(lvwph->m_minYExtent, 0.);

2024 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2025 QCOMPARE(lvwph->m_clipItem->clip(), false);

2026 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2027 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2028 QCOMPARE(lvwph->contentY(), 150.);

2029 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2030 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2031 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2032 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2033 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2034 }

2035

2036 void testMaximizeVisibleAreaWithItemResize()

2037 {

2038 model->setProperty(0, "size", 1000);

2039

2040 bool res = lvwph->maximizeVisibleArea(1);

2041 QVERIFY(res);

2042 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2043

2044 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2045 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2046 verifyItem(0, -738., 1040., false, "Agressive", true);

2047 verifyItem(1, 302., 240., false, "Regular", false);

2048 verifyItem(2, 542, 390., true, "Mild", true);

2049 QCOMPARE(lvwph->m_minYExtent, 0.);

2050 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2051 QCOMPARE(lvwph->m_clipItem->clip(), false);

2052 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2053 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2054 QCOMPARE(lvwph->contentY(), 788.);

2055 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2056 }

2057

2058private:

2059 QQuickView *view;

2060 ListViewWithPageHeader *lvwph;

2061#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

2062 QQuickListModel *model;

2063#else

2064 QQmlListModel *model;

2065#endif

2066 QQmlComponent *otherDelegate;

2067};

2068

2069QTEST_MAIN(ListViewWithPageHeaderTestSection)

2070

2071#include "listviewwithpageheadertestsection.moc"