tests/plugins/Dash/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on f621663 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadersectiontest.cpp

2162 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->engine()->addImportPath(BUILT_PLUGINS_DIR);

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

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

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

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

141 QVERIFY(lvwph);

142 QVERIFY(model);

143 QVERIFY(otherDelegate);

144 view->show();

145 QTest::qWaitForWindowExposed(view);

146

147 verifyInitialTopPosition();

148 }

149

150 void cleanup()

151 {

152 delete view;

153 }

154

155 void testCreationDeletion()

156 {

157 // Nothing, init/cleanup already tests this

158 }

159

160 void testDrag1PixelUp()

161 {

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

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

164 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

176 }

177

178 void testHeaderDetachDragDown()

179 {

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

181 QTest::qWait(100);

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

183 QTest::qWait(100);

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

185 QTest::qWait(100);

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

187 QTest::qWait(100);

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

189 QTest::qWait(100);

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

191 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

203

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

205

206 verifyInitialTopPosition();

207 }

208

209 void testDrag375PixelUp()

210 {

211 changeContentY(375);

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

213 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

229 }

230

231 void testDrag520PixelUp()

232 {

233 changeContentY(520);

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

235 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

240 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

251 }

252

253 void testDragHeaderUpThenShow()

254 {

255 changeContentY(120);

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

257 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

273

274 changeContentY(-30);

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

276 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

292 }

293

294 void testDragHeaderUpThenShowWithoutHidingTotally()

295 {

296 changeContentY(10);

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

298 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

310

311 changeContentY(-1);

312

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

314 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

326 }

327

328 void testPositionAtBeginningIndex0Visible()

329 {

330 changeContentY(375);

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

332 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

348

349 lvwph->positionAtBeginning();

350

351 verifyInitialTopPosition();

352 }

353

354 void testPositionAtBeginningIndex0NotVisible()

355 {

356 changeContentY(520);

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

358 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

363 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

374

375 lvwph->positionAtBeginning();

376

377 verifyInitialTopPosition();

378 }

379

380 void testIndex0GrowOnScreen()

381 {

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

383

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

385 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

397 }

398

399 void testIndex0GrowOffScreen()

400 {

401 changeContentY(375);

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

403 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

419

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

421

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

423 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

439

440 scrollToTop();

441

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

443 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

455

456 changeContentY(30);

457

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

459 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

471 }

472

473 void testIndex0GrowNotCreated()

474 {

475 changeContentY(520);

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

477 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

482 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

493

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

495

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

497 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

502 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

513

514 scrollToTop();

515

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

517 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

529 }

530

531 void testShowHideShowHeaderAtBottom()

532 {

533 scrollToBottom();

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

535 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

550

551 changeContentY(-30);

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

553 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

568

569 changeContentY(30);

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

571 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

586

587 changeContentY(-30);

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

589 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

604 }

605

606 void testChangeDelegateAtBottom()

607 {

608 scrollToBottom();

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

610 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

625

626 lvwph->setDelegate(otherDelegate);

627

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

629 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

644 }

645

646 void testSetEmptyHeaderAtTop()

647 {

648 lvwph->setHeader(nullptr);

649

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

651 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

662 }

663

664 void testSetEmptyHeaderAtBottom()

665 {

666 scrollToBottom();

667 lvwph->setHeader(nullptr);

668

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

670 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

684

685 scrollToTop();

686

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

688 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

699 }

700

701 void testSetEmptyHeaderWhenPartlyShownClipped()

702 {

703 scrollToBottom();

704 changeContentY(-30);

705 lvwph->setHeader(nullptr);

706

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

708 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

718 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

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

723

724 scrollToTop();

725

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

727 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

738 }

739

740 void testSetEmptyHeaderWhenPartlyShownNotClipped()

741 {

742 changeContentY(30);

743 lvwph->setHeader(nullptr);

744

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

746 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

760 }

761

762 void testSetNullDelegate()

763 {

764 lvwph->setDelegate(nullptr);

765

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

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

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

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

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

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

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

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

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

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

776 QVERIFY(lvwph->isAtYBeginning());

777 QVERIFY(lvwph->isAtYEnd());

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

779 }

780

781 void testInsertItems()

782 {

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

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

785

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

787 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

801 }

802

803 void testInsertItemsStealSectionItem()

804 {

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

806

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

808 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

821 }

822

823

824 void testInsertItemsOnNotShownPosition()

825 {

826 changeContentY(800);

827

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

829 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

845

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

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

848

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

850 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

866

867 scrollToTop();

868

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

870 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

884 }

885

886 void testInsertItemsAtEndOfViewport()

887 {

888 changeContentY(60);

889

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

891 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

907

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

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

910

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

912 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

928 }

929

930 void testInsertItemsBeforeValidIndex()

931 {

932 changeContentY(520);

933

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

935 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

940 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

951

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

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

954

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

956 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

961 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

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

972 }

973

974 void testInsertItemsBeforeViewport()

975 {

976 changeContentY(375);

977

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

979 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

995

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

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

998

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

1000 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1016

1017 scrollToTop();

1018

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

1020 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1034 }

1035

1036 void testInsertItemsAtBottom()

1037 {

1038 scrollToBottom();

1039

1040 QVERIFY(lvwph->isAtYEnd());

1041

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

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

1044

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

1046 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1064

1065 scrollToBottom();

1066

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

1068 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1080 QVERIFY(lvwph->isAtYEnd());

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

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

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

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

1085 }

1086

1087 void testInsertItemAtTop()

1088 {

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

1090

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

1092 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1104 QVERIFY(lvwph->isAtYBeginning());

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

1106 }

1107

1108 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1109 {

1110 scrollToBottom();

1111

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

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

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

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

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

1122

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

1124 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1139

1140 changeContentY(-1700);

1141

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

1143 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1153 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

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

1164 }

1165

1166 void testInsertToEmpty()

1167 {

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

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

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

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

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

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

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

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

1176

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

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

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

1180 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1183 }

1184

1185 void testRemoveItemsAtTop()

1186 {

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

1188

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

1190 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1200 QVERIFY(lvwph->isAtYBeginning());

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

1202 }

1203

1204 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1205 {

1206 scrollToBottom();

1207

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

1209

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

1211 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1226 }

1227

1228 void testRemoveLastItemsAtBottom()

1229 {

1230 scrollToBottom();

1231

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

1233

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

1235 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1250 }

1251

1252 void testRemoveItemOutOfViewport()

1253 {

1254 changeContentY(520);

1255

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

1257 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1262 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

1273

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

1275

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

1277 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1280 verifyItem(2, 350, 390., false, "Bold", false);

1281 verifyItem(3, 740, 350., true, QString(), true);

1282 QCOMPARE(lvwph->m_minYExtent, -240.);

1283 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1284 QCOMPARE(lvwph->m_clipItem->clip(), false);

1285 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1286 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1287 QCOMPARE(lvwph->contentY(), 520.);

1288 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1289 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1290 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1291 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1292 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1293 }

1294

1295 void testRemoveFirstOfCategory()

1296 {

1297 changeContentY(520);

1298

1299 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1300 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1301 verifyItem(0, -280., 240., true, "Regular", true);

1302 verifyItem(1, -40, 390., false, "Mild", true);

1303 verifyItem(2, 350, 390., false, "Bold", false);

1304 verifyItem(3, 740, 350., true, QString(), true);

1305 QCOMPARE(lvwph->m_minYExtent, 152.5);

1306 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1307 QCOMPARE(lvwph->m_clipItem->clip(), false);

1308 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1309 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1310 QCOMPARE(lvwph->contentY(), 520.);

1311 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1312 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1313 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1314 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1315 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1316

1317 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1318

1319 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1320 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1321 verifyItem(0, -280., 240., true, "Regular", true);

1322 verifyItem(1, -40, 390., false, "Mild", true);

1323 verifyItem(2, 350, 390., false, "Bold", false);

1324 verifyItem(3, 740, 390., true, "Lazy", true);

1325 QCOMPARE(lvwph->m_minYExtent, 162.5);

1326 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1327 QCOMPARE(lvwph->m_clipItem->clip(), false);

1328 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1329 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1330 QCOMPARE(lvwph->contentY(), 520.);

1331 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1332 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1333 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1334 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1335 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1336 }

1337

1338 void testAddSecondToCulledCategoryOfTwo()

1339 {

1340 // Do some setup

1341 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1342 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1343

1344 changeContentY(200);

1345

1346 // Very the items are culled

1347 verifyItem(0, -150., 65., true, "Agressive", true);

1348 verifyItem(1, -85, 25., true, QString(), true);

1349

1350 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1351

1352 // Very the new item is there correctly

1353 verifyItem(0, -175., 65., true, "Agressive", true);

1354 verifyItem(1, -110, 25., true, QString(), true);

1355 verifyItem(2, -85, 25., true, QString(), true);

1356 }

1357

1358 void testMoveFirstItems()

1359 {

1360 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1361

1362 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1363 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1364 verifyItem(0, 50., 240., false, "Regular", false);

1365 verifyItem(1, 290., 190., false, "Agressive", false);

1366 verifyItem(2, 480., 390., false, "Mild", false);

1367 QCOMPARE(lvwph->m_minYExtent, 0.);

1368 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1369 QCOMPARE(lvwph->m_clipItem->clip(), false);

1370 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1371 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1372 QCOMPARE(lvwph->contentY(), 0.);

1373 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1374 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1375 }

1376

1377 void testMoveFirstOutOfVisibleItems()

1378 {

1379 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1380

1381 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1382 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1383 verifyItem(0, 50., 240., false, "Regular", false);

1384 verifyItem(1, 290., 390., false, "Mild", false);

1385 verifyItem(2, 680., 390., true, "Bold", true);

1386 QCOMPARE(lvwph->m_minYExtent, 0.);

1387 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1388 QCOMPARE(lvwph->m_clipItem->clip(), false);

1389 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1390 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1391 QCOMPARE(lvwph->contentY(), 0.);

1392 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1393 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1394 }

1395

1396 void testMoveFirstToLastAtBottom()

1397 {

1398 scrollToBottom();

1399

1400 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1401 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1402 verifyItem(0, -588., 390., true, "Bold", true);

1403 verifyItem(1, -198, 350., false, QString(), true);

1404 verifyItem(2, 152, 390., false, "Lazy", false);

1405 QCOMPARE(lvwph->m_minYExtent, 310.);

1406 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1407 QCOMPARE(lvwph->m_clipItem->clip(), false);

1408 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1409 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1410 QCOMPARE(lvwph->contentY(), 1458.);

1411 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1412 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1413 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1414 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1415 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1416

1417 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1418

1419 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1420 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1421 verifyItem(0, -588., 390., true, "Bold", true);

1422 verifyItem(1, -198, 350., false, QString(), true);

1423 verifyItem(2, 152, 390., false, "Lazy", false);

1424 verifyItem(3, 542, 190., true, "Agressive", true);

1425 QCOMPARE(lvwph->m_minYExtent, -160.);

1426 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1427 QCOMPARE(lvwph->m_clipItem->clip(), false);

1428 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1429 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1430 QCOMPARE(lvwph->contentY(), 1458.);

1431 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1432 QVERIFY(!lvwph->isAtYEnd());

1433 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1434 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1435 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1436 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1437 }

1438

1439 void testChangeSizeVisibleItemNotOnViewport()

1440 {

1441 changeContentY(490);

1442

1443 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1444 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1445 verifyItem(0, -440., 190., true, "Agressive", true);

1446 verifyItem(1, -250., 240., true, "Regular", true);

1447 verifyItem(2, -10, 390., false, "Mild", true);

1448 verifyItem(3, 380, 390., false, "Bold", false);

1449 verifyItem(4, 770, 350., true, QString(), true);

1450 QCOMPARE(lvwph->m_minYExtent, 0.);

1451 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1452 QCOMPARE(lvwph->m_clipItem->clip(), false);

1453 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1454 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1455 QCOMPARE(lvwph->contentY(), 490.);

1456 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1457 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1458 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1459 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1460 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1461

1462 model->setProperty(1, "size", 100);

1463

1464 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1465 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1466 verifyItem(0, -340., 190., true, "Agressive", true);

1467 verifyItem(1, -150., 140., true, "Regular", true);

1468 verifyItem(2, -10, 390., false, "Mild", true);

1469 verifyItem(3, 380, 390., false, "Bold", false);

1470 verifyItem(4, 770, 350., true, QString(), true);

1471 QCOMPARE(lvwph->m_minYExtent, -100.);

1472 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1473 QCOMPARE(lvwph->m_clipItem->clip(), false);

1474 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1475 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1476 QCOMPARE(lvwph->contentY(), 490.);

1477 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1478 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1479 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1480 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1481 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1482 }

1483

1484 void testShowHeaderHalfShown()

1485 {

1486 changeContentY(20);

1487

1488 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1489 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1490 verifyItem(0, 30., 190., false, "Agressive", false);

1491 verifyItem(1, 220, 240., false, "Regular", false);

1492 verifyItem(2, 460, 390., false, "Mild", false);

1493 QCOMPARE(lvwph->m_minYExtent, 0.);

1494 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1495 QCOMPARE(lvwph->m_clipItem->clip(), false);

1496 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1497 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1498 QCOMPARE(lvwph->contentY(), 20.);

1499 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1500 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1501

1502 lvwph->showHeader();

1503

1504 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1505 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1506 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1507 verifyItem(0, -20., 190., false, "Agressive", true);

1508 verifyItem(1, 170, 240., false, "Regular", false);

1509 verifyItem(2, 410, 390., false, "Mild", false);

1510 QCOMPARE(lvwph->m_minYExtent, 20.);

1511 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1512 QCOMPARE(lvwph->m_clipItem->clip(), true);

1513 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1514 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1515 QCOMPARE(lvwph->contentY(), 0.);

1516 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1517 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1518 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1519 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1520 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1521

1522 scrollToTop();

1523

1524 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1525 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1526 verifyItem(0, 50., 190., false, "Agressive", false);

1527 verifyItem(1, 240., 240., false, "Regular", false);

1528 verifyItem(2, 480., 390., false, "Mild", false);

1529 QCOMPARE(lvwph->m_minYExtent, 20.);

1530 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1531 QCOMPARE(lvwph->m_clipItem->clip(), false);

1532 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1533 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1534 QCOMPARE(lvwph->contentY(), -20.);

1535 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1536 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1537 }

1538

1539 void testShowHeaderCloseToTheTop()

1540 {

1541 changeContentY(375);

1542

1543 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1544 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1545 verifyItem(0, -325., 190., true, "Agressive", true);

1546 verifyItem(1, -135, 240., false, "Regular", true);

1547 verifyItem(2, 105, 390., false, "Mild", false);

1548 verifyItem(3, 495, 390., false, "Bold", false);

1549 QCOMPARE(lvwph->m_minYExtent, 0.);

1550 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1551 QCOMPARE(lvwph->m_clipItem->clip(), false);

1552 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1553 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1554 QCOMPARE(lvwph->contentY(), 375.);

1555 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1556 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1557 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1558 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1559 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1560

1561 lvwph->showHeader();

1562

1563 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1564 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1565 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1566 verifyItem(0, -375., 190., true, "Agressive", true);

1567 verifyItem(1, -185, 240., false, "Regular", true);

1568 verifyItem(2, 55, 390., false, "Mild", false);

1569 verifyItem(3, 445, 390., false, "Bold", false);

1570 QCOMPARE(lvwph->m_minYExtent, 50.);

1571 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1572 QCOMPARE(lvwph->m_clipItem->clip(), true);

1573 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1574 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1575 QCOMPARE(lvwph->contentY(), 325.);

1576 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1577 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1578 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1579 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1580 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1581

1582 scrollToTop();

1583

1584 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1585 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1586 verifyItem(0, 50., 190., false, "Agressive", false);

1587 verifyItem(1, 240., 240., false, "Regular", false);

1588 verifyItem(2, 480., 390., false, "Mild", false);

1589 QCOMPARE(lvwph->m_minYExtent, 50.);

1590 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1591 QCOMPARE(lvwph->m_clipItem->clip(), false);

1592 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1593 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1594 QCOMPARE(lvwph->contentY(), -50.);

1595 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1596 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1597 }

1598

1599 void testShowHeaderAtBottom()

1600 {

1601 scrollToBottom();

1602

1603 lvwph->showHeader();

1604

1605 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1606 QTRY_VERIFY (lvwph->isAtYEnd());

1607 }

1608

1609 void growWindow()

1610 {

1611 view->rootObject()->setHeight(850);

1612

1613 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1614 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1615 verifyItem(0, 50., 190., false, "Agressive", false);

1616 verifyItem(1, 240., 240., false, "Regular", false);

1617 verifyItem(2, 480., 390., false, "Mild", false);

1618 verifyItem(3, 870., 390., true, "Bold", true);

1619 verifyItem(4, 1260., 350., true, QString(), true);

1620 QCOMPARE(lvwph->m_minYExtent, 0.);

1621 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1622 QCOMPARE(lvwph->m_clipItem->clip(), false);

1623 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1624 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1625 QCOMPARE(lvwph->contentY(), 0.);

1626 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1627 }

1628

1629 void growWindowAtBottom()

1630 {

1631 // Need a bunch small items at the bottom to trigger the problem

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, "Agressive"));

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, "Regular"));

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 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1652

1653 scrollToBottom();

1654

1655 view->rootObject()->setHeight(850);

1656

1657 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1658 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1659 verifyItem(0, -660., 390., true, "Lazy", true);

1660 verifyItem(1, -270., 90., true, "Agressive", true);

1661 verifyItem(2, -180, 50., true, QString(), true);

1662 verifyItem(3, -130, 50., true, QString(), true);

1663 verifyItem(4, -80, 50., true, QString(), true);

1664 verifyItem(5, -30, 50., false, QString(), true);

1665 verifyItem(6, 20, 50., false, QString(), true);

1666 verifyItem(7, 70, 50., false, QString(), true);

1667 verifyItem(8, 120, 50., false, QString(), true);

1668 verifyItem(9, 170, 90., false, "Regular", false);

1669 verifyItem(10, 260, 50., false, QString(), true);

1670 verifyItem(11, 310, 50., false, QString(), true);

1671 verifyItem(12, 360, 50., false, QString(), true);

1672 verifyItem(13, 410, 50., false, QString(), true);

1673 verifyItem(14, 460, 50., false, QString(), true);

1674 verifyItem(15, 510, 90., false, "Agressive", false);

1675 verifyItem(16, 600, 50., false, QString(), true);

1676 verifyItem(17, 650, 50., false, QString(), true);

1677 verifyItem(18, 700, 50., false, QString(), true);

1678 verifyItem(19, 750, 50., false, QString(), true);

1679 verifyItem(20, 800, 50., false, QString(), true);

1680 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1681 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

1682 QCOMPARE(lvwph->m_clipItem->clip(), false);

1683 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1684 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1685 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1686 }

1687

1688 void testCullOnBottomEdge()

1689 {

1690 changeContentY(240);

1691

1692 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1693 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1694 verifyItem(0, -190., 190., true, "Agressive", true);

1695 verifyItem(1, 0., 240., false, "Regular", false);

1696 verifyItem(2, 240., 390., false, "Mild", false);

1697 verifyItem(3, 630., 390., true, "Bold", true);

1698 QCOMPARE(lvwph->m_minYExtent, 0.);

1699 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1700 QCOMPARE(lvwph->m_clipItem->clip(), false);

1701 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1702 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1703 QCOMPARE(lvwph->contentY(), 240.);

1704 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1705 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1706 }

1707

1708 void testSectionItemCullOnFirstSectionItemTopEdge()

1709 {

1710 changeContentY(50);

1711

1712 verifyItem(0, 0., 190., false, "Agressive", false);

1713 verifyItem(1, 190., 240., false, "Regular", false);

1714 verifyItem(2, 430., 390., false, "Mild", false);

1715 QCOMPARE(lvwph->m_minYExtent, 0.);

1716 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1717 QCOMPARE(lvwph->m_clipItem->clip(), false);

1718 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1719 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1720 QCOMPARE(lvwph->contentY(), 50.);

1721 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1722 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1723 }

1724

1725 void testSectionItemCullOnSecondSectionItemTopEdge()

1726 {

1727 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1728 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1729

1730 changeContentY(5);

1731

1732 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1733 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1734 verifyItem(0, 45., 90., false, "Agressive", false);

1735 verifyItem(1, 135., 50., false, QString(), false);

1736 verifyItem(2, 185., 150., false, QString(), false);

1737 verifyItem(3, 335., 240., false, "Regular", false);

1738 verifyItem(4, 575., 390., true, "Mild", true);

1739 QCOMPARE(lvwph->m_minYExtent, 0.);

1740 QCOMPARE(lvwph->m_clipItem->y(), 5.);

1741 QCOMPARE(lvwph->m_clipItem->clip(), false);

1742 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1743 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1744 QCOMPARE(lvwph->contentY(), 5.);

1745 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1746 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1747

1748 changeContentY(135);

1749

1750 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1751 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1752 verifyItem(0, -90., 90., true, "Agressive", true);

1753 verifyItem(1, 0., 50., false, QString(), false);

1754 verifyItem(2, 50., 150., false, QString(), false);

1755 verifyItem(3, 200., 240., false, "Regular", false);

1756 verifyItem(4, 440., 390., false, "Mild", false);

1757 QCOMPARE(lvwph->m_minYExtent, 0.);

1758 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1759 QCOMPARE(lvwph->m_clipItem->clip(), false);

1760 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1761 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1762 QCOMPARE(lvwph->contentY(), 140.);

1763 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1764 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1765 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1766 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1767 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1768 }

1769

1770 void testMaximizeVisibleArea()

1771 {

1772 bool res = lvwph->maximizeVisibleArea(2);

1773 QVERIFY(res);

1774 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1775

1776 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1777 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1778 verifyItem(0, -278., 190., true, "Agressive", true);

1779 verifyItem(1, -88., 240., false, "Regular", true);

1780 verifyItem(2, 152, 390., false, "Mild", false);

1781 verifyItem(3, 542, 390., true, "Bold", true);

1782 QCOMPARE(lvwph->m_minYExtent, 0.);

1783 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1784 QCOMPARE(lvwph->m_clipItem->clip(), false);

1785 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1786 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1787 QCOMPARE(lvwph->contentY(), 328.);

1788 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1789 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1790 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1791 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1792 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1793 }

1794

1795 void testMaximizeVisibleAreaVisibleItems()

1796 {

1797 bool res = lvwph->maximizeVisibleArea(0);

1798 QVERIFY(res);

1799 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1800

1801 verifyInitialTopPosition();

1802

1803 res = lvwph->maximizeVisibleArea(1);

1804 QVERIFY(res);

1805 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1806

1807 verifyInitialTopPosition();

1808 }

1809

1810 void testMaximizeVisibleAreaInvalidIndexes()

1811 {

1812 bool res = lvwph->maximizeVisibleArea(-1);

1813 QVERIFY(!res);

1814 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1815

1816 verifyInitialTopPosition();

1817

1818 res = lvwph->maximizeVisibleArea(1000);

1819 QVERIFY(!res);

1820 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1821

1822 verifyInitialTopPosition();

1823

1824 res = lvwph->maximizeVisibleArea(3);

1825 QVERIFY(!res);

1826 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1827

1828 verifyInitialTopPosition();

1829 }

1830

1831 void testMaximizeVisibleAreaBigElement()

1832 {

1833 model->setProperty(2, "size", 4000);

1834 verifyItem(2, 480, 4040., false, "Mild", false);

1835

1836 bool res = lvwph->maximizeVisibleArea(2);

1837 QVERIFY(res);

1838 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1839

1840 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1841 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1842 verifyItem(0, -430., 190., true, "Agressive", true);

1843 verifyItem(1, -240., 240., true, "Regular", true);

1844 verifyItem(2, 0, 4040., false, "Mild", false);

1845 QCOMPARE(lvwph->m_minYExtent, 0.);

1846 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1847 QCOMPARE(lvwph->m_clipItem->clip(), false);

1848 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1849 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1850 QCOMPARE(lvwph->contentY(), 480.);

1851 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1852 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1853 }

1854

1855 void testMaximizeVisibleAreaScrollDown()

1856 {

1857 changeContentY(350);

1858 bool res = lvwph->maximizeVisibleArea(1);

1859 QVERIFY(res);

1860 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1861

1862 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1863 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1864 verifyItem(0, -190., 190., true, "Agressive", true);

1865 verifyItem(1, 0., 240., false, "Regular", false);

1866 verifyItem(2, 240, 390., false, "Mild", false);

1867 verifyItem(3, 630, 390., true, "Bold", true);

1868 QCOMPARE(lvwph->m_minYExtent, 0.);

1869 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1870 QCOMPARE(lvwph->m_clipItem->clip(), false);

1871 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1872 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1873 QCOMPARE(lvwph->contentY(), 240.);

1874 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1875 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1876 }

1877

1878 void testMaximizeVisibleAreaScrollDownBigElement()

1879 {

1880 model->setProperty(1, "size", 1000);

1881 changeContentY(1150);

1882 bool res = lvwph->maximizeVisibleArea(1);

1883 QVERIFY(res);

1884 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1885

1886 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1887 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1888 verifyItem(0, -498., 1040., false, "Regular", true);

1889 verifyItem(1, 542., 390., true, "Mild", true);

1890 QCOMPARE(lvwph->m_minYExtent, 525.);

1891 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1892 QCOMPARE(lvwph->m_clipItem->clip(), false);

1893 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1894 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1895 QCOMPARE(lvwph->contentY(), 738.);

1896 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1897 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1898 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1899 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1900 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1901 }

1902

1903 void testMaximizeVisibleAreaBigElementInTheMiddle()

1904 {

1905 model->setProperty(1, "size", 1000);

1906 changeContentY(650);

1907

1908 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1909 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1910 verifyItem(0, -410., 1040., false, "Regular", true);

1911 verifyItem(1, 630., 390., true, "Mild", true);

1912 QCOMPARE(lvwph->m_minYExtent, 525.);

1913 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1914 QCOMPARE(lvwph->m_clipItem->clip(), false);

1915 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1916 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1917 QCOMPARE(lvwph->contentY(), 650.);

1918 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1919 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1920 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1921 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1922 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1923

1924 bool res = lvwph->maximizeVisibleArea(1);

1925 QVERIFY(res);

1926 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1927

1928 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1929 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1930 verifyItem(0, -410., 1040., false, "Regular", true);

1931 verifyItem(1, 630., 390., true, "Mild", true);

1932 QCOMPARE(lvwph->m_minYExtent, 525.);

1933 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1934 QCOMPARE(lvwph->m_clipItem->clip(), false);

1935 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1936 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1937 QCOMPARE(lvwph->contentY(), 650.);

1938 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1939 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1940 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1941 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1942 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1943 }

1944

1945 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1946 {

1947 changeContentY(430);

1948 changeContentY(-30);

1949

1950 bool res = lvwph->maximizeVisibleArea(1);

1951 QVERIFY(res);

1952 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1953

1954 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1955 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1956 verifyItem(0, -190., 190., true, "Agressive", true);

1957 verifyItem(1, 0., 240., false, "Regular", false);

1958 verifyItem(2, 240, 390., false, "Mild", false);

1959 verifyItem(3, 630, 390., true, "Bold", true);

1960 QCOMPARE(lvwph->m_minYExtent, 0.);

1961 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1962 QCOMPARE(lvwph->m_clipItem->clip(), false);

1963 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1964 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1965 QCOMPARE(lvwph->contentY(), 240.);

1966 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1967 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1968 }

1969

1970 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1971 {

1972 changeContentY(430);

1973 changeContentY(-30);

1974

1975 bool res = lvwph->maximizeVisibleArea(3);

1976 QVERIFY(res);

1977 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1978

1979 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1980 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1981 verifyItem(0, -478., 240., true, "Regular", true);

1982 verifyItem(1, -238., 390., false, "Mild", true);

1983 verifyItem(2, 152, 390., false, "Bold", false);

1984 verifyItem(3, 542, 350., true, QString(), true);

1985 QCOMPARE(lvwph->m_minYExtent, 152.5);

1986 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1987 QCOMPARE(lvwph->m_clipItem->clip(), false);

1988 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1989 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1990 QCOMPARE(lvwph->contentY(), 718.);

1991 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1992 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1993 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1994 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1995 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1996 }

1997

1998 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

1999 {

2000 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

2001 changeContentY(250);

2002 bool res = lvwph->maximizeVisibleArea(1);

2003 QVERIFY(res);

2004 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2005

2006 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2007 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2008 verifyItem(0, -100., 140., false, "Agressive", true);

2009 verifyItem(1, 40., 150., false, QString(), true);

2010 verifyItem(2, 190, 240., false, "Regular", false);

2011 verifyItem(3, 430, 390., false, "Mild", false);

2012 QCOMPARE(lvwph->m_minYExtent, 0.);

2013 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2014 QCOMPARE(lvwph->m_clipItem->clip(), false);

2015 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2016 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2017 QCOMPARE(lvwph->contentY(), 150.);

2018 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2019 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2020 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2021 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2022 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2023

2024 changeContentY(20);

2025 res = lvwph->maximizeVisibleArea(1);

2026 QVERIFY(res);

2027 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2028

2029 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2030 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2031 verifyItem(0, -100., 140., false, "Agressive", true);

2032 verifyItem(1, 40., 150., false, QString(), true);

2033 verifyItem(2, 190, 240., false, "Regular", false);

2034 verifyItem(3, 430, 390., false, "Mild", false);

2035 QCOMPARE(lvwph->m_minYExtent, 0.);

2036 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2037 QCOMPARE(lvwph->m_clipItem->clip(), false);

2038 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2039 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2040 QCOMPARE(lvwph->contentY(), 150.);

2041 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2042 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2043 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2044 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2045 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2046 }

2047

2048 void testMaximizeVisibleAreaWithItemResize()

2049 {

2050 model->setProperty(0, "size", 1000);

2051

2052 bool res = lvwph->maximizeVisibleArea(1);

2053 QVERIFY(res);

2054 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2055

2056 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2057 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2058 verifyItem(0, -738., 1040., false, "Agressive", true);

2059 verifyItem(1, 302., 240., false, "Regular", false);

2060 verifyItem(2, 542, 390., true, "Mild", true);

2061 QCOMPARE(lvwph->m_minYExtent, 0.);

2062 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2063 QCOMPARE(lvwph->m_clipItem->clip(), false);

2064 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2065 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2066 QCOMPARE(lvwph->contentY(), 788.);

2067 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2068 }

2069

2070 void addingRemoveItemsShouldNotChangeContentY()

2071 {

2072 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

2073 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

2074 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

2075

2076 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2077 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2078 verifyItem(0, 50., 190., false, "Agressive", false);

2079 QCOMPARE(lvwph->m_minYExtent, 0.);

2080 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2081 QCOMPARE(lvwph->m_clipItem->clip(), false);

2082 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2083 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2084 QCOMPARE(lvwph->contentY(), 0.);

2085 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2086

2087 QCOMPARE(spy.count(), 0);

2088 }

2089

2090 void testDownAndUp()

2091 {

2092 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2093

2094 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2095 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2096 verifyItem(0, 50., 190., false, "Agressive", false);

2097 QCOMPARE(lvwph->m_minYExtent, 0.);

2098 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2099 QCOMPARE(lvwph->m_clipItem->clip(), false);

2100 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2101 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2102 QCOMPARE(lvwph->contentY(), 0.);

2103 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2104 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2105

2106 QTest::qWait(1);

2107 QCoreApplication::instance()->processEvents();

2108

2109 changeContentY(-15);

2110

2111 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2112 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2113 verifyItem(0, 65., 190., false, "Agressive", false);

2114 QCOMPARE(lvwph->m_minYExtent, 0.);

2115 QCOMPARE(lvwph->m_clipItem->y(), -15.);

2116 QCOMPARE(lvwph->m_clipItem->clip(), false);

2117 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2118 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2119 QCOMPARE(lvwph->contentY(), -15.);

2120 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2121 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2122

2123 changeContentY(25);

2124

2125 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2126 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2127 verifyItem(0, 40., 190., false, "Agressive", false);

2128 QCOMPARE(lvwph->m_minYExtent, 0.);

2129 QCOMPARE(lvwph->m_clipItem->y(), 10.);

2130 QCOMPARE(lvwph->m_clipItem->clip(), false);

2131 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2132 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2133 QCOMPARE(lvwph->contentY(), 10.);

2134 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2135 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2136

2137

2138 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2139

2140 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2141 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2142 verifyItem(0, 50., 190., false, "Agressive", false);

2143 QCOMPARE(lvwph->m_minYExtent, 0.);

2144 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2145 QCOMPARE(lvwph->m_clipItem->clip(), false);

2146 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2147 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2148 QCOMPARE(lvwph->contentY(), 0.);

2149 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2150 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2151 }

2152

2153private:

2154 QQuickView *view;

2155 ListViewWithPageHeader *lvwph;

2156 QQmlListModel *model;

2157 QQmlComponent *otherDelegate;

2158};

2159

2160QTEST_MAIN(ListViewWithPageHeaderTestSection)

2161

2162#include "listviewwithpageheadersectiontest.moc"