tests/plugins/Dash/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on d28fa91 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadersectiontest.cpp

2161 lines 99 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

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

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

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

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "listviewwithpageheader.h"

19#include <QAbstractItemModel>

20#include <QQmlEngine>

21#include <QQuickView>

22#include <QSignalSpy>

23#include <QtTestGui>

24#pragma GCC diagnostic push

25#pragma GCC diagnostic ignored "-pedantic"

26#include <private/qqmllistmodel_p.h>

27#include <private/qquickanimation_p.h>

28#include <private/qquickitem_p.h>

29#pragma GCC diagnostic pop

31class ListViewWithPageHeaderTestSection : public QObject

32{

33 Q_OBJECT

35private:

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

37 {

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

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

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

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

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

43 if (!sectionHeader.isNull()) {

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

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

46 }

47 }

49 void changeContentY(qreal change)

50 {

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

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

53 const qreal jump = 25;

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

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

56 QTest::qWait(1);

57 }

58 } else {

59 const qreal jump = -25;

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

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

62 QTest::qWait(1);

63 }

64 }

65 lvwph->setContentY(dest);

66 QTest::qWait(1);

67 }

69 void scrollToTop()

70 {

71 const qreal jump = -25;

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

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

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

75 } else {

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

77 }

78 QTest::qWait(1);

79 }

80 }

82 void scrollToBottom()

83 {

84 const qreal jump = 25;

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

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

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

88 } else {

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

90 }

91 QTest::qWait(1);

92 }

93 }

95 void verifyInitialTopPosition()

96 {

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

98 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

110 }

111

112 bool hasSectionHeaderProperty(QQuickItem *item) const

113 {

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

115 }

116

117 QString section(QQuickItem *item) const

118 {

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

120 }

121

122 int sectionDelegateIndex(QQuickItem *item) const

123 {

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

125 }

126

127private Q_SLOTS:

128

129 void initTestCase()

130 {

131 }

132

133 void init()

134 {

135 view = new QQuickView();

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

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

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

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

140 QVERIFY(lvwph);

141 QVERIFY(model);

142 QVERIFY(otherDelegate);

143 view->show();

144 QTest::qWaitForWindowExposed(view);

145

146 verifyInitialTopPosition();

147 }

148

149 void cleanup()

150 {

151 delete view;

152 }

153

154 void testCreationDeletion()

155 {

156 // Nothing, init/cleanup already tests this

157 }

158

159 void testDrag1PixelUp()

160 {

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

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

163 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

175 }

176

177 void testHeaderDetachDragDown()

178 {

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

180 QTest::qWait(100);

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

182 QTest::qWait(100);

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

184 QTest::qWait(100);

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

186 QTest::qWait(100);

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

188 QTest::qWait(100);

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

190 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

202

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

204

205 verifyInitialTopPosition();

206 }

207

208 void testDrag375PixelUp()

209 {

210 changeContentY(375);

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

212 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

228 }

229

230 void testDrag520PixelUp()

231 {

232 changeContentY(520);

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

234 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

239 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

250 }

251

252 void testDragHeaderUpThenShow()

253 {

254 changeContentY(120);

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

256 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

272

273 changeContentY(-30);

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

275 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

291 }

292

293 void testDragHeaderUpThenShowWithoutHidingTotally()

294 {

295 changeContentY(10);

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

297 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

309

310 changeContentY(-1);

311

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

313 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

325 }

326

327 void testPositionAtBeginningIndex0Visible()

328 {

329 changeContentY(375);

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

331 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

347

348 lvwph->positionAtBeginning();

349

350 verifyInitialTopPosition();

351 }

352

353 void testPositionAtBeginningIndex0NotVisible()

354 {

355 changeContentY(520);

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

357 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

362 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

373

374 lvwph->positionAtBeginning();

375

376 verifyInitialTopPosition();

377 }

378

379 void testIndex0GrowOnScreen()

380 {

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

382

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

384 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

396 }

397

398 void testIndex0GrowOffScreen()

399 {

400 changeContentY(375);

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

402 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

418

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

420

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

422 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

438

439 scrollToTop();

440

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

442 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

454

455 changeContentY(30);

456

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

458 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

470 }

471

472 void testIndex0GrowNotCreated()

473 {

474 changeContentY(520);

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

476 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

481 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

492

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

494

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

496 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

501 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

512

513 scrollToTop();

514

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

516 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

528 }

529

530 void testShowHideShowHeaderAtBottom()

531 {

532 scrollToBottom();

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

534 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

549

550 changeContentY(-30);

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

552 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

567

568 changeContentY(30);

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

570 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

585

586 changeContentY(-30);

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

588 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

603 }

604

605 void testChangeDelegateAtBottom()

606 {

607 scrollToBottom();

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

609 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

624

625 lvwph->setDelegate(otherDelegate);

626

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

628 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

643 }

644

645 void testSetEmptyHeaderAtTop()

646 {

647 lvwph->setHeader(nullptr);

648

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

650 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

661 }

662

663 void testSetEmptyHeaderAtBottom()

664 {

665 scrollToBottom();

666 lvwph->setHeader(nullptr);

667

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

669 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

683

684 scrollToTop();

685

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

687 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

698 }

699

700 void testSetEmptyHeaderWhenPartlyShownClipped()

701 {

702 scrollToBottom();

703 changeContentY(-30);

704 lvwph->setHeader(nullptr);

705

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

707 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

717 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

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

722

723 scrollToTop();

724

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

726 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

737 }

738

739 void testSetEmptyHeaderWhenPartlyShownNotClipped()

740 {

741 changeContentY(30);

742 lvwph->setHeader(nullptr);

743

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

745 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

759 }

760

761 void testSetNullDelegate()

762 {

763 lvwph->setDelegate(nullptr);

764

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

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

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

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

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

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

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

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

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

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

775 QVERIFY(lvwph->isAtYBeginning());

776 QVERIFY(lvwph->isAtYEnd());

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

778 }

779

780 void testInsertItems()

781 {

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

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

784

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

786 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

800 }

801

802 void testInsertItemsStealSectionItem()

803 {

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

805

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

807 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

820 }

821

822

823 void testInsertItemsOnNotShownPosition()

824 {

825 changeContentY(800);

826

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

828 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

844

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

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

847

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

849 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

865

866 scrollToTop();

867

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

869 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

883 }

884

885 void testInsertItemsAtEndOfViewport()

886 {

887 changeContentY(60);

888

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

890 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

906

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

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

909

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

911 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

927 }

928

929 void testInsertItemsBeforeValidIndex()

930 {

931 changeContentY(520);

932

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

934 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

939 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

950

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

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

953

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

955 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

960 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

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

971 }

972

973 void testInsertItemsBeforeViewport()

974 {

975 changeContentY(375);

976

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

978 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

994

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

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

997

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

999 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1015

1016 scrollToTop();

1017

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

1019 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1033 }

1034

1035 void testInsertItemsAtBottom()

1036 {

1037 scrollToBottom();

1038

1039 QVERIFY(lvwph->isAtYEnd());

1040

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

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

1043

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

1045 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1063

1064 scrollToBottom();

1065

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

1067 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1079 QVERIFY(lvwph->isAtYEnd());

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

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

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

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

1084 }

1085

1086 void testInsertItemAtTop()

1087 {

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

1089

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

1091 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1103 QVERIFY(lvwph->isAtYBeginning());

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

1105 }

1106

1107 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1108 {

1109 scrollToBottom();

1110

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

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

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

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

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

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

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

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

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

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

1123 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1138

1139 changeContentY(-1700);

1140

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

1142 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1152 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

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

1163 }

1164

1165 void testInsertToEmpty()

1166 {

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

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

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

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

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

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

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

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

1175

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

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

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

1179 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1182 }

1183

1184 void testRemoveItemsAtTop()

1185 {

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

1187

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

1189 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1199 QVERIFY(lvwph->isAtYBeginning());

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

1201 }

1202

1203 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1204 {

1205 scrollToBottom();

1206

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

1208

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

1210 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

1213 verifyItem(2, 152, 390., false, "Lazy", false);

1214 QCOMPARE(lvwph->m_minYExtent, -1330./3.);

1215 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1216 QCOMPARE(lvwph->m_clipItem->clip(), false);

1217 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1218 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1219 QCOMPARE(lvwph->contentY(), 1458.);

1220 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1221 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1222 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1223 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1224 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1225 }

1226

1227 void testRemoveLastItemsAtBottom()

1228 {

1229 scrollToBottom();

1230

1231 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));

1232

1233 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1234 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1235 verifyItem(0, -478., 240., true, "Regular", true);

1236 verifyItem(1, -238, 390., false, "Mild", true);

1237 verifyItem(2, 152, 390., false, "Bold", false);

1238 QCOMPARE(lvwph->m_minYExtent, 150.);

1239 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1240 QCOMPARE(lvwph->m_clipItem->clip(), false);

1241 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1242 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1243 QCOMPARE(lvwph->contentY(), 718.);

1244 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1245 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1246 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1247 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1248 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1249 }

1250

1251 void testRemoveItemOutOfViewport()

1252 {

1253 changeContentY(520);

1254

1255 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1256 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1257 verifyItem(0, -280., 240., true, "Regular", true);

1258 verifyItem(1, -40, 390., false, "Mild", true);

1259 verifyItem(2, 350, 390., false, "Bold", false);

1260 verifyItem(3, 740, 350., true, QString(), true);

1261 QCOMPARE(lvwph->m_minYExtent, 152.5);

1262 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1263 QCOMPARE(lvwph->m_clipItem->clip(), false);

1264 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1265 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1266 QCOMPARE(lvwph->contentY(), 520.);

1267 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1268 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1269 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1270 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1271 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1272

1273 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1274

1275 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1276 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1277 verifyItem(0, -230., 190., true, "Agressive", true);

1278 verifyItem(1, -40, 390., false, "Mild", true);

1279 verifyItem(2, 350, 390., false, "Bold", false);

1280 verifyItem(3, 740, 350., true, QString(), true);

1281 QCOMPARE(lvwph->m_minYExtent, -240.);

1282 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1283 QCOMPARE(lvwph->m_clipItem->clip(), false);

1284 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1285 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1286 QCOMPARE(lvwph->contentY(), 520.);

1287 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1288 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1289 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1290 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1291 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1292 }

1293

1294 void testRemoveFirstOfCategory()

1295 {

1296 changeContentY(520);

1297

1298 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1299 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1300 verifyItem(0, -280., 240., true, "Regular", true);

1301 verifyItem(1, -40, 390., false, "Mild", true);

1302 verifyItem(2, 350, 390., false, "Bold", false);

1303 verifyItem(3, 740, 350., true, QString(), true);

1304 QCOMPARE(lvwph->m_minYExtent, 152.5);

1305 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1306 QCOMPARE(lvwph->m_clipItem->clip(), false);

1307 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1308 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1309 QCOMPARE(lvwph->contentY(), 520.);

1310 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1311 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1312 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1313 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1314 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1315

1316 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1317

1318 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1319 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1320 verifyItem(0, -280., 240., true, "Regular", true);

1321 verifyItem(1, -40, 390., false, "Mild", true);

1322 verifyItem(2, 350, 390., false, "Bold", false);

1323 verifyItem(3, 740, 390., true, "Lazy", true);

1324 QCOMPARE(lvwph->m_minYExtent, 162.5);

1325 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1326 QCOMPARE(lvwph->m_clipItem->clip(), false);

1327 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1328 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1329 QCOMPARE(lvwph->contentY(), 520.);

1330 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1331 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1332 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1333 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1334 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1335 }

1336

1337 void testAddSecondToCulledCategoryOfTwo()

1338 {

1339 // Do some setup

1340 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1341 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1342

1343 changeContentY(200);

1344

1345 // Very the items are culled

1346 verifyItem(0, -150., 65., true, "Agressive", true);

1347 verifyItem(1, -85, 25., true, QString(), true);

1348

1349 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1350

1351 // Very the new item is there correctly

1352 verifyItem(0, -175., 65., true, "Agressive", true);

1353 verifyItem(1, -110, 25., true, QString(), true);

1354 verifyItem(2, -85, 25., true, QString(), true);

1355 }

1356

1357 void testMoveFirstItems()

1358 {

1359 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1360

1361 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1362 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1363 verifyItem(0, 50., 240., false, "Regular", false);

1364 verifyItem(1, 290., 190., false, "Agressive", false);

1365 verifyItem(2, 480., 390., false, "Mild", false);

1366 QCOMPARE(lvwph->m_minYExtent, 0.);

1367 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1368 QCOMPARE(lvwph->m_clipItem->clip(), false);

1369 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1370 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1371 QCOMPARE(lvwph->contentY(), 0.);

1372 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1373 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1374 }

1375

1376 void testMoveFirstOutOfVisibleItems()

1377 {

1378 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1379

1380 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1381 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1382 verifyItem(0, 50., 240., false, "Regular", false);

1383 verifyItem(1, 290., 390., false, "Mild", false);

1384 verifyItem(2, 680., 390., true, "Bold", true);

1385 QCOMPARE(lvwph->m_minYExtent, 0.);

1386 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1387 QCOMPARE(lvwph->m_clipItem->clip(), false);

1388 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1389 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1390 QCOMPARE(lvwph->contentY(), 0.);

1391 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1392 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1393 }

1394

1395 void testMoveFirstToLastAtBottom()

1396 {

1397 scrollToBottom();

1398

1399 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1400 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1401 verifyItem(0, -588., 390., true, "Bold", true);

1402 verifyItem(1, -198, 350., false, QString(), true);

1403 verifyItem(2, 152, 390., false, "Lazy", false);

1404 QCOMPARE(lvwph->m_minYExtent, 310.);

1405 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1406 QCOMPARE(lvwph->m_clipItem->clip(), false);

1407 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1408 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1409 QCOMPARE(lvwph->contentY(), 1458.);

1410 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1411 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1412 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1413 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1414 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1415

1416 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1417

1418 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1419 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1420 verifyItem(0, -588., 390., true, "Bold", true);

1421 verifyItem(1, -198, 350., false, QString(), true);

1422 verifyItem(2, 152, 390., false, "Lazy", false);

1423 verifyItem(3, 542, 190., true, "Agressive", true);

1424 QCOMPARE(lvwph->m_minYExtent, -160.);

1425 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1426 QCOMPARE(lvwph->m_clipItem->clip(), false);

1427 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1428 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1429 QCOMPARE(lvwph->contentY(), 1458.);

1430 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1431 QVERIFY(!lvwph->isAtYEnd());

1432 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1433 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1434 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1435 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1436 }

1437

1438 void testChangeSizeVisibleItemNotOnViewport()

1439 {

1440 changeContentY(490);

1441

1442 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1443 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1444 verifyItem(0, -440., 190., true, "Agressive", true);

1445 verifyItem(1, -250., 240., true, "Regular", true);

1446 verifyItem(2, -10, 390., false, "Mild", true);

1447 verifyItem(3, 380, 390., false, "Bold", false);

1448 verifyItem(4, 770, 350., true, QString(), true);

1449 QCOMPARE(lvwph->m_minYExtent, 0.);

1450 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1451 QCOMPARE(lvwph->m_clipItem->clip(), false);

1452 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1453 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1454 QCOMPARE(lvwph->contentY(), 490.);

1455 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1456 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1457 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1458 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1459 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1460

1461 model->setProperty(1, "size", 100);

1462

1463 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1464 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1465 verifyItem(0, -340., 190., true, "Agressive", true);

1466 verifyItem(1, -150., 140., true, "Regular", true);

1467 verifyItem(2, -10, 390., false, "Mild", true);

1468 verifyItem(3, 380, 390., false, "Bold", false);

1469 verifyItem(4, 770, 350., true, QString(), true);

1470 QCOMPARE(lvwph->m_minYExtent, -100.);

1471 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1472 QCOMPARE(lvwph->m_clipItem->clip(), false);

1473 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1474 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1475 QCOMPARE(lvwph->contentY(), 490.);

1476 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1477 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1478 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1479 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1480 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1481 }

1482

1483 void testShowHeaderHalfShown()

1484 {

1485 changeContentY(20);

1486

1487 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1488 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1489 verifyItem(0, 30., 190., false, "Agressive", false);

1490 verifyItem(1, 220, 240., false, "Regular", false);

1491 verifyItem(2, 460, 390., false, "Mild", false);

1492 QCOMPARE(lvwph->m_minYExtent, 0.);

1493 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1494 QCOMPARE(lvwph->m_clipItem->clip(), false);

1495 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1496 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1497 QCOMPARE(lvwph->contentY(), 20.);

1498 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1499 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1500

1501 lvwph->showHeader();

1502

1503 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1504 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1505 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1506 verifyItem(0, -20., 190., false, "Agressive", true);

1507 verifyItem(1, 170, 240., false, "Regular", false);

1508 verifyItem(2, 410, 390., false, "Mild", false);

1509 QCOMPARE(lvwph->m_minYExtent, 20.);

1510 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1511 QCOMPARE(lvwph->m_clipItem->clip(), true);

1512 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1513 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1514 QCOMPARE(lvwph->contentY(), 0.);

1515 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1516 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1517 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1518 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1519 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1520

1521 scrollToTop();

1522

1523 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1524 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1525 verifyItem(0, 50., 190., false, "Agressive", false);

1526 verifyItem(1, 240., 240., false, "Regular", false);

1527 verifyItem(2, 480., 390., false, "Mild", false);

1528 QCOMPARE(lvwph->m_minYExtent, 20.);

1529 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1530 QCOMPARE(lvwph->m_clipItem->clip(), false);

1531 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1532 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1533 QCOMPARE(lvwph->contentY(), -20.);

1534 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1535 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1536 }

1537

1538 void testShowHeaderCloseToTheTop()

1539 {

1540 changeContentY(375);

1541

1542 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1543 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1544 verifyItem(0, -325., 190., true, "Agressive", true);

1545 verifyItem(1, -135, 240., false, "Regular", true);

1546 verifyItem(2, 105, 390., false, "Mild", false);

1547 verifyItem(3, 495, 390., false, "Bold", false);

1548 QCOMPARE(lvwph->m_minYExtent, 0.);

1549 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1550 QCOMPARE(lvwph->m_clipItem->clip(), false);

1551 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1552 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1553 QCOMPARE(lvwph->contentY(), 375.);

1554 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1555 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1556 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1557 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1558 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1559

1560 lvwph->showHeader();

1561

1562 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1563 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1564 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1565 verifyItem(0, -375., 190., true, "Agressive", true);

1566 verifyItem(1, -185, 240., false, "Regular", true);

1567 verifyItem(2, 55, 390., false, "Mild", false);

1568 verifyItem(3, 445, 390., false, "Bold", false);

1569 QCOMPARE(lvwph->m_minYExtent, 50.);

1570 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1571 QCOMPARE(lvwph->m_clipItem->clip(), true);

1572 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1573 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1574 QCOMPARE(lvwph->contentY(), 325.);

1575 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1576 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1577 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1578 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1579 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1580

1581 scrollToTop();

1582

1583 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1584 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1585 verifyItem(0, 50., 190., false, "Agressive", false);

1586 verifyItem(1, 240., 240., false, "Regular", false);

1587 verifyItem(2, 480., 390., false, "Mild", false);

1588 QCOMPARE(lvwph->m_minYExtent, 50.);

1589 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1590 QCOMPARE(lvwph->m_clipItem->clip(), false);

1591 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1592 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1593 QCOMPARE(lvwph->contentY(), -50.);

1594 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1595 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1596 }

1597

1598 void testShowHeaderAtBottom()

1599 {

1600 scrollToBottom();

1601

1602 lvwph->showHeader();

1603

1604 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1605 QTRY_VERIFY (lvwph->isAtYEnd());

1606 }

1607

1608 void growWindow()

1609 {

1610 view->rootObject()->setHeight(850);

1611

1612 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1613 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1614 verifyItem(0, 50., 190., false, "Agressive", false);

1615 verifyItem(1, 240., 240., false, "Regular", false);

1616 verifyItem(2, 480., 390., false, "Mild", false);

1617 verifyItem(3, 870., 390., true, "Bold", true);

1618 verifyItem(4, 1260., 350., true, QString(), true);

1619 QCOMPARE(lvwph->m_minYExtent, 0.);

1620 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1621 QCOMPARE(lvwph->m_clipItem->clip(), false);

1622 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1623 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1624 QCOMPARE(lvwph->contentY(), 0.);

1625 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1626 }

1627

1628 void growWindowAtBottom()

1629 {

1630 // Need a bunch small items at the bottom to trigger the problem

1631 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1632 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1633 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1634 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1635 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1636 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1637 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1638 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1639 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1640 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1643 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1644 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1645 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1646 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1647 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1648 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1649 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1650 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1651

1652 scrollToBottom();

1653

1654 view->rootObject()->setHeight(850);

1655

1656 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1657 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1658 verifyItem(0, -660., 390., true, "Lazy", true);

1659 verifyItem(1, -270., 90., true, "Agressive", true);

1660 verifyItem(2, -180, 50., true, QString(), true);

1661 verifyItem(3, -130, 50., true, QString(), true);

1662 verifyItem(4, -80, 50., true, QString(), true);

1663 verifyItem(5, -30, 50., false, QString(), true);

1664 verifyItem(6, 20, 50., false, QString(), true);

1665 verifyItem(7, 70, 50., false, QString(), true);

1666 verifyItem(8, 120, 50., false, QString(), true);

1667 verifyItem(9, 170, 90., false, "Regular", false);

1668 verifyItem(10, 260, 50., false, QString(), true);

1669 verifyItem(11, 310, 50., false, QString(), true);

1670 verifyItem(12, 360, 50., false, QString(), true);

1671 verifyItem(13, 410, 50., false, QString(), true);

1672 verifyItem(14, 460, 50., false, QString(), true);

1673 verifyItem(15, 510, 90., false, "Agressive", false);

1674 verifyItem(16, 600, 50., false, QString(), true);

1675 verifyItem(17, 650, 50., false, QString(), true);

1676 verifyItem(18, 700, 50., false, QString(), true);

1677 verifyItem(19, 750, 50., false, QString(), true);

1678 verifyItem(20, 800, 50., false, QString(), true);

1679 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1680 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

1681 QCOMPARE(lvwph->m_clipItem->clip(), false);

1682 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1683 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1684 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1685 }

1686

1687 void testCullOnBottomEdge()

1688 {

1689 changeContentY(240);

1690

1691 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1692 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1693 verifyItem(0, -190., 190., true, "Agressive", true);

1694 verifyItem(1, 0., 240., false, "Regular", false);

1695 verifyItem(2, 240., 390., false, "Mild", false);

1696 verifyItem(3, 630., 390., true, "Bold", true);

1697 QCOMPARE(lvwph->m_minYExtent, 0.);

1698 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1699 QCOMPARE(lvwph->m_clipItem->clip(), false);

1700 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1701 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1702 QCOMPARE(lvwph->contentY(), 240.);

1703 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1704 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1705 }

1706

1707 void testSectionItemCullOnFirstSectionItemTopEdge()

1708 {

1709 changeContentY(50);

1710

1711 verifyItem(0, 0., 190., false, "Agressive", false);

1712 verifyItem(1, 190., 240., false, "Regular", false);

1713 verifyItem(2, 430., 390., false, "Mild", false);

1714 QCOMPARE(lvwph->m_minYExtent, 0.);

1715 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1716 QCOMPARE(lvwph->m_clipItem->clip(), false);

1717 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1718 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1719 QCOMPARE(lvwph->contentY(), 50.);

1720 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1721 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1722 }

1723

1724 void testSectionItemCullOnSecondSectionItemTopEdge()

1725 {

1726 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1727 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1728

1729 changeContentY(5);

1730

1731 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1732 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1733 verifyItem(0, 45., 90., false, "Agressive", false);

1734 verifyItem(1, 135., 50., false, QString(), false);

1735 verifyItem(2, 185., 150., false, QString(), false);

1736 verifyItem(3, 335., 240., false, "Regular", false);

1737 verifyItem(4, 575., 390., true, "Mild", true);

1738 QCOMPARE(lvwph->m_minYExtent, 0.);

1739 QCOMPARE(lvwph->m_clipItem->y(), 5.);

1740 QCOMPARE(lvwph->m_clipItem->clip(), false);

1741 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1742 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1743 QCOMPARE(lvwph->contentY(), 5.);

1744 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1745 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1746

1747 changeContentY(135);

1748

1749 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1750 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1751 verifyItem(0, -90., 90., true, "Agressive", true);

1752 verifyItem(1, 0., 50., false, QString(), false);

1753 verifyItem(2, 50., 150., false, QString(), false);

1754 verifyItem(3, 200., 240., false, "Regular", false);

1755 verifyItem(4, 440., 390., false, "Mild", false);

1756 QCOMPARE(lvwph->m_minYExtent, 0.);

1757 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1758 QCOMPARE(lvwph->m_clipItem->clip(), false);

1759 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1760 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1761 QCOMPARE(lvwph->contentY(), 140.);

1762 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1763 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1764 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1765 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1766 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1767 }

1768

1769 void testMaximizeVisibleArea()

1770 {

1771 bool res = lvwph->maximizeVisibleArea(2);

1772 QVERIFY(res);

1773 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1774

1775 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1776 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1777 verifyItem(0, -278., 190., true, "Agressive", true);

1778 verifyItem(1, -88., 240., false, "Regular", true);

1779 verifyItem(2, 152, 390., false, "Mild", false);

1780 verifyItem(3, 542, 390., true, "Bold", true);

1781 QCOMPARE(lvwph->m_minYExtent, 0.);

1782 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1783 QCOMPARE(lvwph->m_clipItem->clip(), false);

1784 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1785 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1786 QCOMPARE(lvwph->contentY(), 328.);

1787 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1788 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1789 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1790 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1791 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1792 }

1793

1794 void testMaximizeVisibleAreaVisibleItems()

1795 {

1796 bool res = lvwph->maximizeVisibleArea(0);

1797 QVERIFY(res);

1798 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1799

1800 verifyInitialTopPosition();

1801

1802 res = lvwph->maximizeVisibleArea(1);

1803 QVERIFY(res);

1804 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1805

1806 verifyInitialTopPosition();

1807 }

1808

1809 void testMaximizeVisibleAreaInvalidIndexes()

1810 {

1811 bool res = lvwph->maximizeVisibleArea(-1);

1812 QVERIFY(!res);

1813 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1814

1815 verifyInitialTopPosition();

1816

1817 res = lvwph->maximizeVisibleArea(1000);

1818 QVERIFY(!res);

1819 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1820

1821 verifyInitialTopPosition();

1822

1823 res = lvwph->maximizeVisibleArea(3);

1824 QVERIFY(!res);

1825 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1826

1827 verifyInitialTopPosition();

1828 }

1829

1830 void testMaximizeVisibleAreaBigElement()

1831 {

1832 model->setProperty(2, "size", 4000);

1833 verifyItem(2, 480, 4040., false, "Mild", false);

1834

1835 bool res = lvwph->maximizeVisibleArea(2);

1836 QVERIFY(res);

1837 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1838

1839 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1840 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1841 verifyItem(0, -430., 190., true, "Agressive", true);

1842 verifyItem(1, -240., 240., true, "Regular", true);

1843 verifyItem(2, 0, 4040., false, "Mild", false);

1844 QCOMPARE(lvwph->m_minYExtent, 0.);

1845 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1846 QCOMPARE(lvwph->m_clipItem->clip(), false);

1847 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1848 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1849 QCOMPARE(lvwph->contentY(), 480.);

1850 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1851 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1852 }

1853

1854 void testMaximizeVisibleAreaScrollDown()

1855 {

1856 changeContentY(350);

1857 bool res = lvwph->maximizeVisibleArea(1);

1858 QVERIFY(res);

1859 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1860

1861 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1862 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1863 verifyItem(0, -190., 190., true, "Agressive", true);

1864 verifyItem(1, 0., 240., false, "Regular", false);

1865 verifyItem(2, 240, 390., false, "Mild", false);

1866 verifyItem(3, 630, 390., true, "Bold", true);

1867 QCOMPARE(lvwph->m_minYExtent, 0.);

1868 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1869 QCOMPARE(lvwph->m_clipItem->clip(), false);

1870 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1871 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1872 QCOMPARE(lvwph->contentY(), 240.);

1873 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1874 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1875 }

1876

1877 void testMaximizeVisibleAreaScrollDownBigElement()

1878 {

1879 model->setProperty(1, "size", 1000);

1880 changeContentY(1150);

1881 bool res = lvwph->maximizeVisibleArea(1);

1882 QVERIFY(res);

1883 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1884

1885 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1886 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1887 verifyItem(0, -498., 1040., false, "Regular", true);

1888 verifyItem(1, 542., 390., true, "Mild", true);

1889 QCOMPARE(lvwph->m_minYExtent, 525.);

1890 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1891 QCOMPARE(lvwph->m_clipItem->clip(), false);

1892 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1893 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1894 QCOMPARE(lvwph->contentY(), 738.);

1895 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1896 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1897 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1898 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1899 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1900 }

1901

1902 void testMaximizeVisibleAreaBigElementInTheMiddle()

1903 {

1904 model->setProperty(1, "size", 1000);

1905 changeContentY(650);

1906

1907 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1908 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1909 verifyItem(0, -410., 1040., false, "Regular", true);

1910 verifyItem(1, 630., 390., true, "Mild", true);

1911 QCOMPARE(lvwph->m_minYExtent, 525.);

1912 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1913 QCOMPARE(lvwph->m_clipItem->clip(), false);

1914 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1915 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1916 QCOMPARE(lvwph->contentY(), 650.);

1917 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1918 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1919 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1920 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1921 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1922

1923 bool res = lvwph->maximizeVisibleArea(1);

1924 QVERIFY(res);

1925 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1926

1927 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1928 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1929 verifyItem(0, -410., 1040., false, "Regular", true);

1930 verifyItem(1, 630., 390., true, "Mild", true);

1931 QCOMPARE(lvwph->m_minYExtent, 525.);

1932 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1933 QCOMPARE(lvwph->m_clipItem->clip(), false);

1934 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1935 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1936 QCOMPARE(lvwph->contentY(), 650.);

1937 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1938 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1939 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1940 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1941 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1942 }

1943

1944 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1945 {

1946 changeContentY(430);

1947 changeContentY(-30);

1948

1949 bool res = lvwph->maximizeVisibleArea(1);

1950 QVERIFY(res);

1951 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1952

1953 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1954 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1955 verifyItem(0, -190., 190., true, "Agressive", true);

1956 verifyItem(1, 0., 240., false, "Regular", false);

1957 verifyItem(2, 240, 390., false, "Mild", false);

1958 verifyItem(3, 630, 390., true, "Bold", true);

1959 QCOMPARE(lvwph->m_minYExtent, 0.);

1960 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1961 QCOMPARE(lvwph->m_clipItem->clip(), false);

1962 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1963 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1964 QCOMPARE(lvwph->contentY(), 240.);

1965 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1966 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1967 }

1968

1969 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1970 {

1971 changeContentY(430);

1972 changeContentY(-30);

1973

1974 bool res = lvwph->maximizeVisibleArea(3);

1975 QVERIFY(res);

1976 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1977

1978 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1979 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1980 verifyItem(0, -478., 240., true, "Regular", true);

1981 verifyItem(1, -238., 390., false, "Mild", true);

1982 verifyItem(2, 152, 390., false, "Bold", false);

1983 verifyItem(3, 542, 350., true, QString(), true);

1984 QCOMPARE(lvwph->m_minYExtent, 152.5);

1985 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1986 QCOMPARE(lvwph->m_clipItem->clip(), false);

1987 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1988 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1989 QCOMPARE(lvwph->contentY(), 718.);

1990 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1991 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1992 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1993 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1994 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1995 }

1996

1997 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

1998 {

1999 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

2000 changeContentY(250);

2001 bool res = lvwph->maximizeVisibleArea(1);

2002 QVERIFY(res);

2003 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2004

2005 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2006 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2007 verifyItem(0, -100., 140., false, "Agressive", true);

2008 verifyItem(1, 40., 150., false, QString(), true);

2009 verifyItem(2, 190, 240., false, "Regular", false);

2010 verifyItem(3, 430, 390., false, "Mild", false);

2011 QCOMPARE(lvwph->m_minYExtent, 0.);

2012 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2013 QCOMPARE(lvwph->m_clipItem->clip(), false);

2014 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2015 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2016 QCOMPARE(lvwph->contentY(), 150.);

2017 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2018 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2019 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2020 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2021 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2022

2023 changeContentY(20);

2024 res = lvwph->maximizeVisibleArea(1);

2025 QVERIFY(res);

2026 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2027

2028 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2029 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2030 verifyItem(0, -100., 140., false, "Agressive", true);

2031 verifyItem(1, 40., 150., false, QString(), true);

2032 verifyItem(2, 190, 240., false, "Regular", false);

2033 verifyItem(3, 430, 390., false, "Mild", false);

2034 QCOMPARE(lvwph->m_minYExtent, 0.);

2035 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2036 QCOMPARE(lvwph->m_clipItem->clip(), false);

2037 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2038 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2039 QCOMPARE(lvwph->contentY(), 150.);

2040 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2041 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2042 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2043 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2044 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2045 }

2046

2047 void testMaximizeVisibleAreaWithItemResize()

2048 {

2049 model->setProperty(0, "size", 1000);

2050

2051 bool res = lvwph->maximizeVisibleArea(1);

2052 QVERIFY(res);

2053 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2054

2055 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2056 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2057 verifyItem(0, -738., 1040., false, "Agressive", true);

2058 verifyItem(1, 302., 240., false, "Regular", false);

2059 verifyItem(2, 542, 390., true, "Mild", true);

2060 QCOMPARE(lvwph->m_minYExtent, 0.);

2061 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2062 QCOMPARE(lvwph->m_clipItem->clip(), false);

2063 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2064 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2065 QCOMPARE(lvwph->contentY(), 788.);

2066 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2067 }

2068

2069 void addingRemoveItemsShouldNotChangeContentY()

2070 {

2071 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

2072 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

2073 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

2074

2075 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2076 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2077 verifyItem(0, 50., 190., false, "Agressive", false);

2078 QCOMPARE(lvwph->m_minYExtent, 0.);

2079 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2080 QCOMPARE(lvwph->m_clipItem->clip(), false);

2081 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2082 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2083 QCOMPARE(lvwph->contentY(), 0.);

2084 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2085

2086 QCOMPARE(spy.count(), 0);

2087 }

2088

2089 void testDownAndUp()

2090 {

2091 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2092

2093 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2094 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2095 verifyItem(0, 50., 190., false, "Agressive", false);

2096 QCOMPARE(lvwph->m_minYExtent, 0.);

2097 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2098 QCOMPARE(lvwph->m_clipItem->clip(), false);

2099 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2100 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2101 QCOMPARE(lvwph->contentY(), 0.);

2102 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2103 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2104

2105 QTest::qWait(1);

2106 QCoreApplication::instance()->processEvents();

2107

2108 changeContentY(-15);

2109

2110 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2111 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2112 verifyItem(0, 65., 190., false, "Agressive", false);

2113 QCOMPARE(lvwph->m_minYExtent, 0.);

2114 QCOMPARE(lvwph->m_clipItem->y(), -15.);

2115 QCOMPARE(lvwph->m_clipItem->clip(), false);

2116 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2117 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2118 QCOMPARE(lvwph->contentY(), -15.);

2119 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2120 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2121

2122 changeContentY(25);

2123

2124 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2125 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2126 verifyItem(0, 40., 190., false, "Agressive", false);

2127 QCOMPARE(lvwph->m_minYExtent, 0.);

2128 QCOMPARE(lvwph->m_clipItem->y(), 10.);

2129 QCOMPARE(lvwph->m_clipItem->clip(), false);

2130 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2131 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2132 QCOMPARE(lvwph->contentY(), 10.);

2133 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2134 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2135

2136

2137 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2138

2139 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2140 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2141 verifyItem(0, 50., 190., false, "Agressive", false);

2142 QCOMPARE(lvwph->m_minYExtent, 0.);

2143 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2144 QCOMPARE(lvwph->m_clipItem->clip(), false);

2145 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2146 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2147 QCOMPARE(lvwph->contentY(), 0.);

2148 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2149 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2150 }

2151

2152private:

2153 QQuickView *view;

2154 ListViewWithPageHeader *lvwph;

2155 QQmlListModel *model;

2156 QQmlComponent *otherDelegate;

2157};

2158

2159QTEST_MAIN(ListViewWithPageHeaderTestSection)

2160

2161#include "listviewwithpageheadersectiontest.moc"