tests/plugins/Dash/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on 67fd442 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadersectiontest.cpp

2157 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]->m_sectionItem), sectionHeader);

43 if (!sectionHeader.isNull()) {

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

45 QCOMPARE(sectionDelegateIndex(lvwph->m_visibleItems[visibleIndex]->m_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 QString section(QQuickItem *item)

113 {

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

115 }

116

117 int sectionDelegateIndex(QQuickItem *item)

118 {

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

120 }

121

122private Q_SLOTS:

123

124 void initTestCase()

125 {

126 }

127

128 void init()

129 {

130 view = new QQuickView();

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

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

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

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

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

136 QVERIFY(lvwph);

137 QVERIFY(model);

138 QVERIFY(otherDelegate);

139 view->show();

140 QTest::qWaitForWindowExposed(view);

141

142 verifyInitialTopPosition();

143 }

144

145 void cleanup()

146 {

147 delete view;

148 }

149

150 void testCreationDeletion()

151 {

152 // Nothing, init/cleanup already tests this

153 }

154

155 void testDrag1PixelUp()

156 {

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

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

159 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

171 }

172

173 void testHeaderDetachDragDown()

174 {

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

176 QTest::qWait(100);

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

178 QTest::qWait(100);

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

180 QTest::qWait(100);

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

182 QTest::qWait(100);

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

184 QTest::qWait(100);

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

186 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

198

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

200

201 verifyInitialTopPosition();

202 }

203

204 void testDrag375PixelUp()

205 {

206 changeContentY(375);

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

208 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

224 }

225

226 void testDrag520PixelUp()

227 {

228 changeContentY(520);

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

230 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

235 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

246 }

247

248 void testDragHeaderUpThenShow()

249 {

250 changeContentY(120);

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

252 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

268

269 changeContentY(-30);

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

271 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

287 }

288

289 void testDragHeaderUpThenShowWithoutHidingTotally()

290 {

291 changeContentY(10);

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

293 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

305

306 changeContentY(-1);

307

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

309 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

321 }

322

323 void testPositionAtBeginningIndex0Visible()

324 {

325 changeContentY(375);

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

327 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

343

344 lvwph->positionAtBeginning();

345

346 verifyInitialTopPosition();

347 }

348

349 void testPositionAtBeginningIndex0NotVisible()

350 {

351 changeContentY(520);

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

353 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

358 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

369

370 lvwph->positionAtBeginning();

371

372 verifyInitialTopPosition();

373 }

374

375 void testIndex0GrowOnScreen()

376 {

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

378

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

380 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

392 }

393

394 void testIndex0GrowOffScreen()

395 {

396 changeContentY(375);

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

398 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

414

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

416

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

418 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

434

435 scrollToTop();

436

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

438 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

450

451 changeContentY(30);

452

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

454 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

466 }

467

468 void testIndex0GrowNotCreated()

469 {

470 changeContentY(520);

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

472 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

477 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

488

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

490

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

492 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

497 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

508

509 scrollToTop();

510

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

512 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

524 }

525

526 void testShowHideShowHeaderAtBottom()

527 {

528 scrollToBottom();

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

530 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

545

546 changeContentY(-30);

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

548 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

563

564 changeContentY(30);

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

566 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

581

582 changeContentY(-30);

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

584 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

599 }

600

601 void testChangeDelegateAtBottom()

602 {

603 scrollToBottom();

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

605 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

620

621 lvwph->setDelegate(otherDelegate);

622

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

624 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

639 }

640

641 void testSetEmptyHeaderAtTop()

642 {

643 lvwph->setHeader(nullptr);

644

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

646 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

657 }

658

659 void testSetEmptyHeaderAtBottom()

660 {

661 scrollToBottom();

662 lvwph->setHeader(nullptr);

663

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

665 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

679

680 scrollToTop();

681

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

683 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

694 }

695

696 void testSetEmptyHeaderWhenPartlyShownClipped()

697 {

698 scrollToBottom();

699 changeContentY(-30);

700 lvwph->setHeader(nullptr);

701

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

703 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

713 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

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

718

719 scrollToTop();

720

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

722 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

733 }

734

735 void testSetEmptyHeaderWhenPartlyShownNotClipped()

736 {

737 changeContentY(30);

738 lvwph->setHeader(nullptr);

739

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

741 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

755 }

756

757 void testSetNullDelegate()

758 {

759 lvwph->setDelegate(nullptr);

760

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

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

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

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

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

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

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

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

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

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

771 QVERIFY(lvwph->isAtYBeginning());

772 QVERIFY(lvwph->isAtYEnd());

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

774 }

775

776 void testInsertItems()

777 {

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

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

780

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

782 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

796 }

797

798 void testInsertItemsStealSectionItem()

799 {

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

801

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

803 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

816 }

817

818

819 void testInsertItemsOnNotShownPosition()

820 {

821 changeContentY(800);

822

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

824 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

840

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

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

843

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

845 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

861

862 scrollToTop();

863

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

865 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

879 }

880

881 void testInsertItemsAtEndOfViewport()

882 {

883 changeContentY(60);

884

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

886 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

902

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

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

905

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

907 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

923 }

924

925 void testInsertItemsBeforeValidIndex()

926 {

927 changeContentY(520);

928

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

930 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

935 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

946

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

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

949

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

951 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

956 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

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

967 }

968

969 void testInsertItemsBeforeViewport()

970 {

971 changeContentY(375);

972

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

974 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

990

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

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

993

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

995 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1011

1012 scrollToTop();

1013

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

1015 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1029 }

1030

1031 void testInsertItemsAtBottom()

1032 {

1033 scrollToBottom();

1034

1035 QVERIFY(lvwph->isAtYEnd());

1036

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

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

1039

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

1041 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1059

1060 scrollToBottom();

1061

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

1063 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1075 QVERIFY(lvwph->isAtYEnd());

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

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

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

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

1080 }

1081

1082 void testInsertItemAtTop()

1083 {

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

1085

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

1087 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1099 QVERIFY(lvwph->isAtYBeginning());

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

1101 }

1102

1103 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1104 {

1105 scrollToBottom();

1106

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

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

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

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

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

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

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

1117

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

1119 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1134

1135 changeContentY(-1700);

1136

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

1138 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1148 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

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

1159 }

1160

1161 void testInsertToEmpty()

1162 {

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

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

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

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

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

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

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

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

1171

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

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

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

1175 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1178 }

1179

1180 void testRemoveItemsAtTop()

1181 {

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

1183

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

1185 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1195 QVERIFY(lvwph->isAtYBeginning());

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

1197 }

1198

1199 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1200 {

1201 scrollToBottom();

1202

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

1204

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

1206 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1221 }

1222

1223 void testRemoveLastItemsAtBottom()

1224 {

1225 scrollToBottom();

1226

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

1228

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

1230 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1245 }

1246

1247 void testRemoveItemOutOfViewport()

1248 {

1249 changeContentY(520);

1250

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

1252 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1257 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

1266 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1267 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1268

1269 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1270

1271 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1272 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1273 verifyItem(0, -230., 190., true, "Agressive", true);

1274 verifyItem(1, -40, 390., false, "Mild", true);

1275 verifyItem(2, 350, 390., false, "Bold", false);

1276 verifyItem(3, 740, 350., true, QString(), true);

1277 QCOMPARE(lvwph->m_minYExtent, -240.);

1278 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1279 QCOMPARE(lvwph->m_clipItem->clip(), false);

1280 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1281 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1282 QCOMPARE(lvwph->contentY(), 520.);

1283 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1284 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1285 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1286 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1287 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1288 }

1289

1290 void testRemoveFirstOfCategory()

1291 {

1292 changeContentY(520);

1293

1294 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1295 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1296 verifyItem(0, -280., 240., true, "Regular", true);

1297 verifyItem(1, -40, 390., false, "Mild", true);

1298 verifyItem(2, 350, 390., false, "Bold", false);

1299 verifyItem(3, 740, 350., true, QString(), true);

1300 QCOMPARE(lvwph->m_minYExtent, 152.5);

1301 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1302 QCOMPARE(lvwph->m_clipItem->clip(), false);

1303 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1304 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1305 QCOMPARE(lvwph->contentY(), 520.);

1306 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1307 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1308 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1309 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1310 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1311

1312 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1313

1314 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1315 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1316 verifyItem(0, -280., 240., true, "Regular", true);

1317 verifyItem(1, -40, 390., false, "Mild", true);

1318 verifyItem(2, 350, 390., false, "Bold", false);

1319 verifyItem(3, 740, 390., true, "Lazy", true);

1320 QCOMPARE(lvwph->m_minYExtent, 162.5);

1321 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1322 QCOMPARE(lvwph->m_clipItem->clip(), false);

1323 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1324 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1325 QCOMPARE(lvwph->contentY(), 520.);

1326 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1327 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1328 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1329 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1330 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1331 }

1332

1333 void testAddSecondToCulledCategoryOfTwo()

1334 {

1335 // Do some setup

1336 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1337 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1338

1339 changeContentY(200);

1340

1341 // Very the items are culled

1342 verifyItem(0, -150., 65., true, "Agressive", true);

1343 verifyItem(1, -85, 25., true, QString(), true);

1344

1345 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1346

1347 // Very the new item is there correctly

1348 verifyItem(0, -175., 65., true, "Agressive", true);

1349 verifyItem(1, -110, 25., true, QString(), true);

1350 verifyItem(2, -85, 25., true, QString(), true);

1351 }

1352

1353 void testMoveFirstItems()

1354 {

1355 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1356

1357 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1358 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1359 verifyItem(0, 50., 240., false, "Regular", false);

1360 verifyItem(1, 290., 190., false, "Agressive", false);

1361 verifyItem(2, 480., 390., false, "Mild", false);

1362 QCOMPARE(lvwph->m_minYExtent, 0.);

1363 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1364 QCOMPARE(lvwph->m_clipItem->clip(), false);

1365 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1366 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1367 QCOMPARE(lvwph->contentY(), 0.);

1368 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1369 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1370 }

1371

1372 void testMoveFirstOutOfVisibleItems()

1373 {

1374 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1375

1376 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1377 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1378 verifyItem(0, 50., 240., false, "Regular", false);

1379 verifyItem(1, 290., 390., false, "Mild", false);

1380 verifyItem(2, 680., 390., true, "Bold", true);

1381 QCOMPARE(lvwph->m_minYExtent, 0.);

1382 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1383 QCOMPARE(lvwph->m_clipItem->clip(), false);

1384 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1385 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1386 QCOMPARE(lvwph->contentY(), 0.);

1387 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1388 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1389 }

1390

1391 void testMoveFirstToLastAtBottom()

1392 {

1393 scrollToBottom();

1394

1395 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1396 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1397 verifyItem(0, -588., 390., true, "Bold", true);

1398 verifyItem(1, -198, 350., false, QString(), true);

1399 verifyItem(2, 152, 390., false, "Lazy", false);

1400 QCOMPARE(lvwph->m_minYExtent, 310.);

1401 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1402 QCOMPARE(lvwph->m_clipItem->clip(), false);

1403 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1404 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1405 QCOMPARE(lvwph->contentY(), 1458.);

1406 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1407 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1408 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1409 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 3);

1410 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1411

1412 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1413

1414 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1415 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1416 verifyItem(0, -588., 390., true, "Bold", true);

1417 verifyItem(1, -198, 350., false, QString(), true);

1418 verifyItem(2, 152, 390., false, "Lazy", false);

1419 verifyItem(3, 542, 190., true, "Agressive", true);

1420 QCOMPARE(lvwph->m_minYExtent, -160.);

1421 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1422 QCOMPARE(lvwph->m_clipItem->clip(), false);

1423 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1424 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1425 QCOMPARE(lvwph->contentY(), 1458.);

1426 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1427 QVERIFY(!lvwph->isAtYEnd());

1428 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1429 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1430 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1431 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1432 }

1433

1434 void testChangeSizeVisibleItemNotOnViewport()

1435 {

1436 changeContentY(490);

1437

1438 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1439 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1440 verifyItem(0, -440., 190., true, "Agressive", true);

1441 verifyItem(1, -250., 240., true, "Regular", true);

1442 verifyItem(2, -10, 390., false, "Mild", true);

1443 verifyItem(3, 380, 390., false, "Bold", false);

1444 verifyItem(4, 770, 350., true, QString(), true);

1445 QCOMPARE(lvwph->m_minYExtent, 0.);

1446 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1447 QCOMPARE(lvwph->m_clipItem->clip(), false);

1448 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1449 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1450 QCOMPARE(lvwph->contentY(), 490.);

1451 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1452 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1453 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1454 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1455 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1456

1457 model->setProperty(1, "size", 100);

1458

1459 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1460 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1461 verifyItem(0, -340., 190., true, "Agressive", true);

1462 verifyItem(1, -150., 140., true, "Regular", true);

1463 verifyItem(2, -10, 390., false, "Mild", true);

1464 verifyItem(3, 380, 390., false, "Bold", false);

1465 verifyItem(4, 770, 350., true, QString(), true);

1466 QCOMPARE(lvwph->m_minYExtent, -100.);

1467 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1468 QCOMPARE(lvwph->m_clipItem->clip(), false);

1469 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1470 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1471 QCOMPARE(lvwph->contentY(), 490.);

1472 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1473 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1474 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1475 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1476 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1477 }

1478

1479 void testShowHeaderHalfShown()

1480 {

1481 changeContentY(20);

1482

1483 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1484 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1485 verifyItem(0, 30., 190., false, "Agressive", false);

1486 verifyItem(1, 220, 240., false, "Regular", false);

1487 verifyItem(2, 460, 390., false, "Mild", false);

1488 QCOMPARE(lvwph->m_minYExtent, 0.);

1489 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1490 QCOMPARE(lvwph->m_clipItem->clip(), false);

1491 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1492 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1493 QCOMPARE(lvwph->contentY(), 20.);

1494 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1495 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1496

1497 lvwph->showHeader();

1498

1499 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1500 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1501 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1502 verifyItem(0, -20., 190., false, "Agressive", true);

1503 verifyItem(1, 170, 240., false, "Regular", false);

1504 verifyItem(2, 410, 390., false, "Mild", false);

1505 QCOMPARE(lvwph->m_minYExtent, 20.);

1506 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1507 QCOMPARE(lvwph->m_clipItem->clip(), true);

1508 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1509 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1510 QCOMPARE(lvwph->contentY(), 0.);

1511 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1512 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1513 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1514 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1515 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1516

1517 scrollToTop();

1518

1519 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1520 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1521 verifyItem(0, 50., 190., false, "Agressive", false);

1522 verifyItem(1, 240., 240., false, "Regular", false);

1523 verifyItem(2, 480., 390., false, "Mild", false);

1524 QCOMPARE(lvwph->m_minYExtent, 20.);

1525 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1526 QCOMPARE(lvwph->m_clipItem->clip(), false);

1527 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1528 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1529 QCOMPARE(lvwph->contentY(), -20.);

1530 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1531 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1532 }

1533

1534 void testShowHeaderCloseToTheTop()

1535 {

1536 changeContentY(375);

1537

1538 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1539 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1540 verifyItem(0, -325., 190., true, "Agressive", true);

1541 verifyItem(1, -135, 240., false, "Regular", true);

1542 verifyItem(2, 105, 390., false, "Mild", false);

1543 verifyItem(3, 495, 390., false, "Bold", false);

1544 QCOMPARE(lvwph->m_minYExtent, 0.);

1545 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1546 QCOMPARE(lvwph->m_clipItem->clip(), false);

1547 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1548 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1549 QCOMPARE(lvwph->contentY(), 375.);

1550 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1551 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1552 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1553 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1554 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1555

1556 lvwph->showHeader();

1557

1558 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1559 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1560 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1561 verifyItem(0, -375., 190., true, "Agressive", true);

1562 verifyItem(1, -185, 240., false, "Regular", true);

1563 verifyItem(2, 55, 390., false, "Mild", false);

1564 verifyItem(3, 445, 390., false, "Bold", false);

1565 QCOMPARE(lvwph->m_minYExtent, 50.);

1566 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1567 QCOMPARE(lvwph->m_clipItem->clip(), true);

1568 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1569 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1570 QCOMPARE(lvwph->contentY(), 325.);

1571 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1572 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1573 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1574 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1575 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1576

1577 scrollToTop();

1578

1579 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1580 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1581 verifyItem(0, 50., 190., false, "Agressive", false);

1582 verifyItem(1, 240., 240., false, "Regular", false);

1583 verifyItem(2, 480., 390., false, "Mild", false);

1584 QCOMPARE(lvwph->m_minYExtent, 50.);

1585 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1586 QCOMPARE(lvwph->m_clipItem->clip(), false);

1587 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1588 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1589 QCOMPARE(lvwph->contentY(), -50.);

1590 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1591 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1592 }

1593

1594 void testShowHeaderAtBottom()

1595 {

1596 scrollToBottom();

1597

1598 lvwph->showHeader();

1599

1600 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1601 QTRY_VERIFY (lvwph->isAtYEnd());

1602 }

1603

1604 void growWindow()

1605 {

1606 view->rootObject()->setHeight(850);

1607

1608 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1609 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1610 verifyItem(0, 50., 190., false, "Agressive", false);

1611 verifyItem(1, 240., 240., false, "Regular", false);

1612 verifyItem(2, 480., 390., false, "Mild", false);

1613 verifyItem(3, 870., 390., true, "Bold", true);

1614 verifyItem(4, 1260., 350., true, QString(), true);

1615 QCOMPARE(lvwph->m_minYExtent, 0.);

1616 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1617 QCOMPARE(lvwph->m_clipItem->clip(), false);

1618 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1619 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1620 QCOMPARE(lvwph->contentY(), 0.);

1621 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1622 }

1623

1624 void growWindowAtBottom()

1625 {

1626 // Need a bunch small items at the bottom to trigger the problem

1627 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1628 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1629 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1630 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1631 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1632 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1633 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1634 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1635 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1636 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1637 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1638 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1639 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1640 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1643 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1644 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1645 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1646 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1647

1648 scrollToBottom();

1649

1650 view->rootObject()->setHeight(850);

1651

1652 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1653 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1654 verifyItem(0, -660., 390., true, "Lazy", true);

1655 verifyItem(1, -270., 90., true, "Agressive", true);

1656 verifyItem(2, -180, 50., true, QString(), true);

1657 verifyItem(3, -130, 50., true, QString(), true);

1658 verifyItem(4, -80, 50., true, QString(), true);

1659 verifyItem(5, -30, 50., false, QString(), true);

1660 verifyItem(6, 20, 50., false, QString(), true);

1661 verifyItem(7, 70, 50., false, QString(), true);

1662 verifyItem(8, 120, 50., false, QString(), true);

1663 verifyItem(9, 170, 90., false, "Regular", false);

1664 verifyItem(10, 260, 50., false, QString(), true);

1665 verifyItem(11, 310, 50., false, QString(), true);

1666 verifyItem(12, 360, 50., false, QString(), true);

1667 verifyItem(13, 410, 50., false, QString(), true);

1668 verifyItem(14, 460, 50., false, QString(), true);

1669 verifyItem(15, 510, 90., false, "Agressive", false);

1670 verifyItem(16, 600, 50., false, QString(), true);

1671 verifyItem(17, 650, 50., false, QString(), true);

1672 verifyItem(18, 700, 50., false, QString(), true);

1673 verifyItem(19, 750, 50., false, QString(), true);

1674 verifyItem(20, 800, 50., false, QString(), true);

1675 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1676 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

1677 QCOMPARE(lvwph->m_clipItem->clip(), false);

1678 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1679 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1680 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1681 }

1682

1683 void testCullOnBottomEdge()

1684 {

1685 changeContentY(240);

1686

1687 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1688 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1689 verifyItem(0, -190., 190., true, "Agressive", true);

1690 verifyItem(1, 0., 240., false, "Regular", false);

1691 verifyItem(2, 240., 390., false, "Mild", false);

1692 verifyItem(3, 630., 390., true, "Bold", true);

1693 QCOMPARE(lvwph->m_minYExtent, 0.);

1694 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1695 QCOMPARE(lvwph->m_clipItem->clip(), false);

1696 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1697 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1698 QCOMPARE(lvwph->contentY(), 240.);

1699 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1700 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1701 }

1702

1703 void testSectionItemCullOnFirstSectionItemTopEdge()

1704 {

1705 changeContentY(50);

1706

1707 verifyItem(0, 0., 190., false, "Agressive", false);

1708 verifyItem(1, 190., 240., false, "Regular", false);

1709 verifyItem(2, 430., 390., false, "Mild", false);

1710 QCOMPARE(lvwph->m_minYExtent, 0.);

1711 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1712 QCOMPARE(lvwph->m_clipItem->clip(), false);

1713 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1714 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1715 QCOMPARE(lvwph->contentY(), 50.);

1716 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1717 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1718 }

1719

1720 void testSectionItemCullOnSecondSectionItemTopEdge()

1721 {

1722 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1723 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1724

1725 changeContentY(5);

1726

1727 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1728 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1729 verifyItem(0, 45., 90., false, "Agressive", false);

1730 verifyItem(1, 135., 50., false, QString(), false);

1731 verifyItem(2, 185., 150., false, QString(), false);

1732 verifyItem(3, 335., 240., false, "Regular", false);

1733 verifyItem(4, 575., 390., true, "Mild", true);

1734 QCOMPARE(lvwph->m_minYExtent, 0.);

1735 QCOMPARE(lvwph->m_clipItem->y(), 5.);

1736 QCOMPARE(lvwph->m_clipItem->clip(), false);

1737 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1738 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1739 QCOMPARE(lvwph->contentY(), 5.);

1740 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1741 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1742

1743 changeContentY(135);

1744

1745 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1746 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1747 verifyItem(0, -90., 90., true, "Agressive", true);

1748 verifyItem(1, 0., 50., false, QString(), false);

1749 verifyItem(2, 50., 150., false, QString(), false);

1750 verifyItem(3, 200., 240., false, "Regular", false);

1751 verifyItem(4, 440., 390., false, "Mild", false);

1752 QCOMPARE(lvwph->m_minYExtent, 0.);

1753 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1754 QCOMPARE(lvwph->m_clipItem->clip(), false);

1755 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1756 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1757 QCOMPARE(lvwph->contentY(), 140.);

1758 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1759 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1760 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1761 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

1762 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1763 }

1764

1765 void testMaximizeVisibleArea()

1766 {

1767 bool res = lvwph->maximizeVisibleArea(2);

1768 QVERIFY(res);

1769 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1770

1771 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1772 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1773 verifyItem(0, -278., 190., true, "Agressive", true);

1774 verifyItem(1, -88., 240., false, "Regular", true);

1775 verifyItem(2, 152, 390., false, "Mild", false);

1776 verifyItem(3, 542, 390., true, "Bold", true);

1777 QCOMPARE(lvwph->m_minYExtent, 0.);

1778 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1779 QCOMPARE(lvwph->m_clipItem->clip(), false);

1780 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1781 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1782 QCOMPARE(lvwph->contentY(), 328.);

1783 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1784 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1785 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1786 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1787 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1788 }

1789

1790 void testMaximizeVisibleAreaVisibleItems()

1791 {

1792 bool res = lvwph->maximizeVisibleArea(0);

1793 QVERIFY(res);

1794 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1795

1796 verifyInitialTopPosition();

1797

1798 res = lvwph->maximizeVisibleArea(1);

1799 QVERIFY(res);

1800 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1801

1802 verifyInitialTopPosition();

1803 }

1804

1805 void testMaximizeVisibleAreaInvalidIndexes()

1806 {

1807 bool res = lvwph->maximizeVisibleArea(-1);

1808 QVERIFY(!res);

1809 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1810

1811 verifyInitialTopPosition();

1812

1813 res = lvwph->maximizeVisibleArea(1000);

1814 QVERIFY(!res);

1815 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1816

1817 verifyInitialTopPosition();

1818

1819 res = lvwph->maximizeVisibleArea(3);

1820 QVERIFY(!res);

1821 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1822

1823 verifyInitialTopPosition();

1824 }

1825

1826 void testMaximizeVisibleAreaBigElement()

1827 {

1828 model->setProperty(2, "size", 4000);

1829 verifyItem(2, 480, 4040., false, "Mild", false);

1830

1831 bool res = lvwph->maximizeVisibleArea(2);

1832 QVERIFY(res);

1833 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1834

1835 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1836 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1837 verifyItem(0, -430., 190., true, "Agressive", true);

1838 verifyItem(1, -240., 240., true, "Regular", true);

1839 verifyItem(2, 0, 4040., false, "Mild", false);

1840 QCOMPARE(lvwph->m_minYExtent, 0.);

1841 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1842 QCOMPARE(lvwph->m_clipItem->clip(), false);

1843 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1844 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1845 QCOMPARE(lvwph->contentY(), 480.);

1846 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1847 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1848 }

1849

1850 void testMaximizeVisibleAreaScrollDown()

1851 {

1852 changeContentY(350);

1853 bool res = lvwph->maximizeVisibleArea(1);

1854 QVERIFY(res);

1855 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1856

1857 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1858 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1859 verifyItem(0, -190., 190., true, "Agressive", true);

1860 verifyItem(1, 0., 240., false, "Regular", false);

1861 verifyItem(2, 240, 390., false, "Mild", false);

1862 verifyItem(3, 630, 390., true, "Bold", true);

1863 QCOMPARE(lvwph->m_minYExtent, 0.);

1864 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1865 QCOMPARE(lvwph->m_clipItem->clip(), false);

1866 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1867 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1868 QCOMPARE(lvwph->contentY(), 240.);

1869 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1870 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1871 }

1872

1873 void testMaximizeVisibleAreaScrollDownBigElement()

1874 {

1875 model->setProperty(1, "size", 1000);

1876 changeContentY(1150);

1877 bool res = lvwph->maximizeVisibleArea(1);

1878 QVERIFY(res);

1879 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1880

1881 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1882 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1883 verifyItem(0, -498., 1040., false, "Regular", true);

1884 verifyItem(1, 542., 390., true, "Mild", true);

1885 QCOMPARE(lvwph->m_minYExtent, 525.);

1886 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1887 QCOMPARE(lvwph->m_clipItem->clip(), false);

1888 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1889 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1890 QCOMPARE(lvwph->contentY(), 738.);

1891 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1892 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1893 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1894 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1895 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1896 }

1897

1898 void testMaximizeVisibleAreaBigElementInTheMiddle()

1899 {

1900 model->setProperty(1, "size", 1000);

1901 changeContentY(650);

1902

1903 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1904 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1905 verifyItem(0, -410., 1040., false, "Regular", true);

1906 verifyItem(1, 630., 390., true, "Mild", true);

1907 QCOMPARE(lvwph->m_minYExtent, 525.);

1908 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1909 QCOMPARE(lvwph->m_clipItem->clip(), false);

1910 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1911 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1912 QCOMPARE(lvwph->contentY(), 650.);

1913 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1914 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1915 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1916 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1917 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1918

1919 bool res = lvwph->maximizeVisibleArea(1);

1920 QVERIFY(res);

1921 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1922

1923 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1924 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1925 verifyItem(0, -410., 1040., false, "Regular", true);

1926 verifyItem(1, 630., 390., true, "Mild", true);

1927 QCOMPARE(lvwph->m_minYExtent, 525.);

1928 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1929 QCOMPARE(lvwph->m_clipItem->clip(), false);

1930 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1931 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1932 QCOMPARE(lvwph->contentY(), 650.);

1933 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1934 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1935 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1936 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 1);

1937 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1938 }

1939

1940 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1941 {

1942 changeContentY(430);

1943 changeContentY(-30);

1944

1945 bool res = lvwph->maximizeVisibleArea(1);

1946 QVERIFY(res);

1947 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1948

1949 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1950 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1951 verifyItem(0, -190., 190., true, "Agressive", true);

1952 verifyItem(1, 0., 240., false, "Regular", false);

1953 verifyItem(2, 240, 390., false, "Mild", false);

1954 verifyItem(3, 630, 390., true, "Bold", true);

1955 QCOMPARE(lvwph->m_minYExtent, 0.);

1956 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1957 QCOMPARE(lvwph->m_clipItem->clip(), false);

1958 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1959 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1960 QCOMPARE(lvwph->contentY(), 240.);

1961 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1962 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1963 }

1964

1965 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1966 {

1967 changeContentY(430);

1968 changeContentY(-30);

1969

1970 bool res = lvwph->maximizeVisibleArea(3);

1971 QVERIFY(res);

1972 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1973

1974 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1975 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1976 verifyItem(0, -478., 240., true, "Regular", true);

1977 verifyItem(1, -238., 390., false, "Mild", true);

1978 verifyItem(2, 152, 390., false, "Bold", false);

1979 verifyItem(3, 542, 350., true, QString(), true);

1980 QCOMPARE(lvwph->m_minYExtent, 152.5);

1981 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1982 QCOMPARE(lvwph->m_clipItem->clip(), false);

1983 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1984 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1985 QCOMPARE(lvwph->contentY(), 718.);

1986 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1987 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1988 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1989 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 2);

1990 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1991 }

1992

1993 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

1994 {

1995 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

1996 changeContentY(250);

1997 bool res = lvwph->maximizeVisibleArea(1);

1998 QVERIFY(res);

1999 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2000

2001 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2002 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2003 verifyItem(0, -100., 140., false, "Agressive", true);

2004 verifyItem(1, 40., 150., false, QString(), true);

2005 verifyItem(2, 190, 240., false, "Regular", false);

2006 verifyItem(3, 430, 390., false, "Mild", false);

2007 QCOMPARE(lvwph->m_minYExtent, 0.);

2008 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2009 QCOMPARE(lvwph->m_clipItem->clip(), false);

2010 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2011 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2012 QCOMPARE(lvwph->contentY(), 150.);

2013 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2014 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2015 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2016 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2017 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2018

2019 changeContentY(20);

2020 res = lvwph->maximizeVisibleArea(1);

2021 QVERIFY(res);

2022 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2023

2024 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2025 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2026 verifyItem(0, -100., 140., false, "Agressive", true);

2027 verifyItem(1, 40., 150., false, QString(), true);

2028 verifyItem(2, 190, 240., false, "Regular", false);

2029 verifyItem(3, 430, 390., false, "Mild", false);

2030 QCOMPARE(lvwph->m_minYExtent, 0.);

2031 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2032 QCOMPARE(lvwph->m_clipItem->clip(), false);

2033 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2034 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2035 QCOMPARE(lvwph->contentY(), 150.);

2036 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2037 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2038 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2039 QCOMPARE(sectionDelegateIndex(lvwph->m_topSectionItem), 0);

2040 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2041 }

2042

2043 void testMaximizeVisibleAreaWithItemResize()

2044 {

2045 model->setProperty(0, "size", 1000);

2046

2047 bool res = lvwph->maximizeVisibleArea(1);

2048 QVERIFY(res);

2049 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2050

2051 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2052 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2053 verifyItem(0, -738., 1040., false, "Agressive", true);

2054 verifyItem(1, 302., 240., false, "Regular", false);

2055 verifyItem(2, 542, 390., true, "Mild", true);

2056 QCOMPARE(lvwph->m_minYExtent, 0.);

2057 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2058 QCOMPARE(lvwph->m_clipItem->clip(), false);

2059 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2060 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2061 QCOMPARE(lvwph->contentY(), 788.);

2062 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2063 }

2064

2065 void addingRemoveItemsShouldNotChangeContentY()

2066 {

2067 QSignalSpy spy(lvwph, SIGNAL(contentYChanged()));

2068 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

2069 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

2070

2071 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2072 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2073 verifyItem(0, 50., 190., false, "Agressive", false);

2074 QCOMPARE(lvwph->m_minYExtent, 0.);

2075 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2076 QCOMPARE(lvwph->m_clipItem->clip(), false);

2077 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2078 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2079 QCOMPARE(lvwph->contentY(), 0.);

2080 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2081

2082 QCOMPARE(spy.count(), 0);

2083 }

2084

2085 void testDownAndUp()

2086 {

2087 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2088

2089 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2090 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2091 verifyItem(0, 50., 190., false, "Agressive", false);

2092 QCOMPARE(lvwph->m_minYExtent, 0.);

2093 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2094 QCOMPARE(lvwph->m_clipItem->clip(), false);

2095 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2096 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2097 QCOMPARE(lvwph->contentY(), 0.);

2098 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2099 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2100

2101 QTest::qWait(1);

2102 QCoreApplication::instance()->processEvents();

2103

2104 changeContentY(-15);

2105

2106 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2107 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2108 verifyItem(0, 65., 190., false, "Agressive", false);

2109 QCOMPARE(lvwph->m_minYExtent, 0.);

2110 QCOMPARE(lvwph->m_clipItem->y(), -15.);

2111 QCOMPARE(lvwph->m_clipItem->clip(), false);

2112 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2113 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2114 QCOMPARE(lvwph->contentY(), -15.);

2115 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2116 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2117

2118 changeContentY(25);

2119

2120 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2121 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2122 verifyItem(0, 40., 190., false, "Agressive", false);

2123 QCOMPARE(lvwph->m_minYExtent, 0.);

2124 QCOMPARE(lvwph->m_clipItem->y(), 10.);

2125 QCOMPARE(lvwph->m_clipItem->clip(), false);

2126 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2127 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2128 QCOMPARE(lvwph->contentY(), 10.);

2129 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2130 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2131

2132

2133 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2134

2135 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2136 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2137 verifyItem(0, 50., 190., false, "Agressive", false);

2138 QCOMPARE(lvwph->m_minYExtent, 0.);

2139 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2140 QCOMPARE(lvwph->m_clipItem->clip(), false);

2141 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2142 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2143 QCOMPARE(lvwph->contentY(), 0.);

2144 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2145 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2146 }

2147

2148private:

2149 QQuickView *view;

2150 ListViewWithPageHeader *lvwph;

2151 QQmlListModel *model;

2152 QQmlComponent *otherDelegate;

2153};

2154

2155QTEST_MAIN(ListViewWithPageHeaderTestSection)

2156

2157#include "listviewwithpageheadersectiontest.moc"