tests/plugins/Dash/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on 16fa310 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadersectiontest.cpp

2210 lines 102 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#include <private/qqmllistmodel_p.h>

25#include <private/qquickanimation_p.h>

26#include <private/qquickitem_p.h>

28class ListViewWithPageHeaderTestSection : public QObject

29{

30 Q_OBJECT

32private:

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

34 {

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

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

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

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

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

40 if (!sectionHeader.isNull()) {

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

42 QCOMPARE(sectionDelegate(lvwph->m_visibleItems[visibleIndex]->sectionItem()), lvwph->m_visibleItems[visibleIndex]->m_item);

43 }

44 }

46 void changeContentY(qreal change)

47 {

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

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

50 const qreal jump = 25;

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

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

53 QTest::qWait(1);

54 }

55 } else {

56 const qreal jump = -25;

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

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

59 QTest::qWait(1);

60 }

61 }

62 lvwph->setContentY(dest);

63 QTest::qWait(1);

64 }

66 void scrollToTop()

67 {

68 const qreal jump = -25;

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

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

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

72 } else {

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

74 }

75 QTest::qWait(1);

76 }

77 }

79 void scrollToBottom()

80 {

81 const qreal jump = 25;

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

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

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

85 } else {

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

87 }

88 QTest::qWait(1);

89 }

90 }

92 void verifyInitialTopPosition()

93 {

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

95 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

107 }

108

109 bool hasSectionHeaderProperty(QQuickItem *item) const

110 {

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

112 }

113

114 QString section(QQuickItem *item) const

115 {

116 return item ? item->property("text").toString() : QString();

117 }

118

119 QQuickItem *sectionDelegate(QQuickItem *item) const

120 {

121 return item ? item->property("delegate").value<QQuickItem *>() : nullptr;

122 }

123

124private Q_SLOTS:

125

126 void initTestCase()

127 {

128 }

129

130 void init()

131 {

132 view = new QQuickView();

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

134 lvwph = static_cast<ListViewWithPageHeader*>(view->rootObject()->findChild<QQuickFlickable*>());

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

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

137 QVERIFY(lvwph);

138 QVERIFY(model);

139 QVERIFY(otherDelegate);

140 view->show();

141 QTest::qWaitForWindowExposed(view);

142

143 verifyInitialTopPosition();

144 }

145

146 void cleanup()

147 {

148 delete view;

149 }

150

151 void testCreationDeletion()

152 {

153 // Nothing, init/cleanup already tests this

154 }

155

156 void testDrag1PixelUp()

157 {

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

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

160 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

172 }

173

174 void testHeaderDetachDragDown()

175 {

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

177 QTest::qWait(100);

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

179 QTest::qWait(100);

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

181 QTest::qWait(100);

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

183 QTest::qWait(100);

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

185 QTest::qWait(100);

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

187 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

199

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

201

202 verifyInitialTopPosition();

203 }

204

205 void testDrag375PixelUp()

206 {

207 changeContentY(375);

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

209 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

223 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

225 }

226

227 void testDrag520PixelUp()

228 {

229 changeContentY(520);

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

231 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

236 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

245 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

247 }

248

249 void testDragHeaderUpThenShow()

250 {

251 changeContentY(120);

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

253 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

267 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

269

270 changeContentY(-30);

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

272 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

286 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

288 }

289

290 void testDragHeaderUpThenShowWithoutHidingTotally()

291 {

292 changeContentY(10);

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

294 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

306

307 changeContentY(-1);

308

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

310 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

322 }

323

324 void testPositionAtBeginningIndex0Visible()

325 {

326 changeContentY(375);

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

328 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

342 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

344

345 lvwph->positionAtBeginning();

346

347 verifyInitialTopPosition();

348 }

349

350 void testPositionAtBeginningIndex0NotVisible()

351 {

352 changeContentY(520);

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

354 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

359 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

368 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

370

371 lvwph->positionAtBeginning();

372

373 verifyInitialTopPosition();

374 }

375

376 void testIndex0GrowOnScreen()

377 {

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

379

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

381 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

393 }

394

395 void testIndex0GrowOffScreen()

396 {

397 changeContentY(375);

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

399 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

413 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

415

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

417

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

419 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

433 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

435

436 scrollToTop();

437

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

439 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

451

452 changeContentY(30);

453

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

455 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

467 }

468

469 void testIndex0GrowNotCreated()

470 {

471 changeContentY(520);

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

473 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

478 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

487 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

489

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

491

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

493 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

498 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

507 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

509

510 scrollToTop();

511

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

513 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

525 }

526

527 void testShowHideShowHeaderAtBottom()

528 {

529 scrollToBottom();

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

531 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

544 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

546

547 changeContentY(-30);

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

549 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

562 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

564

565 changeContentY(30);

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

567 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

580 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

582

583 changeContentY(-30);

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

585 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

598 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

600 }

601

602 void testChangeDelegateAtBottom()

603 {

604 scrollToBottom();

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

606 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

619 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

621

622 lvwph->setDelegate(otherDelegate);

623

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

625 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

640 }

641

642 void testSetEmptyHeaderAtTop()

643 {

644 lvwph->setHeader(nullptr);

645

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

647 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

658 }

659

660 void testSetEmptyHeaderAtBottom()

661 {

662 scrollToBottom();

663 lvwph->setHeader(nullptr);

664

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

666 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

678 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

680

681 scrollToTop();

682

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

684 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

695 }

696

697 void testSetEmptyHeaderWhenPartlyShownClipped()

698 {

699 scrollToBottom();

700 changeContentY(-30);

701 lvwph->setHeader(nullptr);

702

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

704 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

714 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

717 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

719

720 scrollToTop();

721

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

723 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

734 }

735

736 void testSetEmptyHeaderWhenPartlyShownNotClipped()

737 {

738 changeContentY(30);

739 lvwph->setHeader(nullptr);

740

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

742 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

754 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

756 }

757

758 void testSetNullDelegate()

759 {

760 lvwph->setDelegate(nullptr);

761

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

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

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

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

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

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

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

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

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

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

772 QVERIFY(lvwph->isAtYBeginning());

773 QVERIFY(lvwph->isAtYEnd());

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

775 }

776

777 void testInsertItems()

778 {

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

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

781

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

783 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

797 }

798

799 void testInsertItemsStealSectionItem()

800 {

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

802

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

804 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

817 }

818

819

820 void testInsertItemsOnNotShownPosition()

821 {

822 changeContentY(800);

823

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

825 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

839 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

841

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

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

844

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

846 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

860 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

862

863 scrollToTop();

864

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

866 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

880 }

881

882 void testInsertItemsAtEndOfViewport()

883 {

884 changeContentY(60);

885

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

887 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

901 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

903

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

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

906

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

908 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

922 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

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

924 }

925

926 void testInsertItemsBeforeValidIndex()

927 {

928 changeContentY(520);

929

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

931 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

936 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

945 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

947

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

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

950

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

952 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

957 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

966 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

968 }

969

970 void testInsertItemsBeforeViewport()

971 {

972 changeContentY(375);

973

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

975 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

989 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

991

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

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

994

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

996 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

1010 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1012

1013 scrollToTop();

1014

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

1016 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1030 }

1031

1032 void testInsertItemsAtBottom()

1033 {

1034 scrollToBottom();

1035

1036 QVERIFY(lvwph->isAtYEnd());

1037

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

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

1040

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

1042 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1058 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1060

1061 scrollToBottom();

1062

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

1064 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1076 QVERIFY(lvwph->isAtYEnd());

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

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

1079 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1081 }

1082

1083 void testInsertItemAtTop()

1084 {

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

1086

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

1088 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1100 QVERIFY(lvwph->isAtYBeginning());

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

1102 }

1103

1104 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1105 {

1106 scrollToBottom();

1107

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

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

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

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

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

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

1118

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

1120 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

1133 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1135

1136 changeContentY(-1700);

1137

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

1139 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1149 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

1158 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[3]->m_item);

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

1160 }

1161

1162 void testInsertToEmpty()

1163 {

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

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

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

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

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

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

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

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

1172

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

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

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

1176 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1179 }

1180

1181 void testRemoveItemsAtTop()

1182 {

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

1184

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

1186 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1196 QVERIFY(lvwph->isAtYBeginning());

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

1198 }

1199

1200 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1201 {

1202 scrollToBottom();

1203

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

1205

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

1207 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

1220 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1222 }

1223

1224 void testRemoveLastItemsAtBottom()

1225 {

1226 scrollToBottom();

1227

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

1229

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

1231 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

1244 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1246 }

1247

1248 void testRemoveItemOutOfViewport()

1249 {

1250 changeContentY(520);

1251

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

1253 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1258 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

1267 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

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

1269

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

1271

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

1273 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

1275 verifyItem(1, -40, 390., false, "Mild", true);

1276 verifyItem(2, 350, 390., false, "Bold", false);

1277 verifyItem(3, 740, 350., true, QString(), true);

1278 QCOMPARE(lvwph->m_minYExtent, -240.);

1279 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1280 QCOMPARE(lvwph->m_clipItem->clip(), false);

1281 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1282 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1283 QCOMPARE(lvwph->contentY(), 520.);

1284 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1285 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1286 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1287 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1288 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1289 }

1290

1291 void testRemoveFirstOfCategory()

1292 {

1293 changeContentY(520);

1294

1295 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1296 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1297 verifyItem(0, -280., 240., true, "Regular", true);

1298 verifyItem(1, -40, 390., false, "Mild", true);

1299 verifyItem(2, 350, 390., false, "Bold", false);

1300 verifyItem(3, 740, 350., true, QString(), true);

1301 QCOMPARE(lvwph->m_minYExtent, 152.5);

1302 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1303 QCOMPARE(lvwph->m_clipItem->clip(), false);

1304 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1305 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1306 QCOMPARE(lvwph->contentY(), 520.);

1307 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1308 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1309 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1310 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1311 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1312

1313 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1314

1315 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1316 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1317 verifyItem(0, -280., 240., true, "Regular", true);

1318 verifyItem(1, -40, 390., false, "Mild", true);

1319 verifyItem(2, 350, 390., false, "Bold", false);

1320 verifyItem(3, 740, 390., true, "Lazy", true);

1321 QCOMPARE(lvwph->m_minYExtent, 162.5);

1322 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1323 QCOMPARE(lvwph->m_clipItem->clip(), false);

1324 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1325 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1326 QCOMPARE(lvwph->contentY(), 520.);

1327 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1328 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1329 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1330 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1331 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1332 }

1333

1334 void testAddSecondToCulledCategoryOfTwo()

1335 {

1336 // Do some setup

1337 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1338 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1339

1340 changeContentY(200);

1341

1342 // Very the items are culled

1343 verifyItem(0, -150., 65., true, "Agressive", true);

1344 verifyItem(1, -85, 25., true, QString(), true);

1345

1346 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1347

1348 // Very the new item is there correctly

1349 verifyItem(0, -175., 65., true, "Agressive", true);

1350 verifyItem(1, -110, 25., true, QString(), true);

1351 verifyItem(2, -85, 25., true, QString(), true);

1352 }

1353

1354 void testMoveFirstItems()

1355 {

1356 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1357

1358 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1359 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1360 verifyItem(0, 50., 240., false, "Regular", false);

1361 verifyItem(1, 290., 190., false, "Agressive", false);

1362 verifyItem(2, 480., 390., false, "Mild", false);

1363 QCOMPARE(lvwph->m_minYExtent, 0.);

1364 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1365 QCOMPARE(lvwph->m_clipItem->clip(), false);

1366 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1367 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1368 QCOMPARE(lvwph->contentY(), 0.);

1369 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1370 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1371 }

1372

1373 void testMoveFirstOutOfVisibleItems()

1374 {

1375 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1376

1377 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1378 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1379 verifyItem(0, 50., 240., false, "Regular", false);

1380 verifyItem(1, 290., 390., false, "Mild", false);

1381 verifyItem(2, 680., 390., true, "Bold", true);

1382 QCOMPARE(lvwph->m_minYExtent, 0.);

1383 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1384 QCOMPARE(lvwph->m_clipItem->clip(), false);

1385 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1386 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1387 QCOMPARE(lvwph->contentY(), 0.);

1388 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1389 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1390 }

1391

1392 void testMoveFirstToLastAtBottom()

1393 {

1394 scrollToBottom();

1395

1396 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1397 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1398 verifyItem(0, -588., 390., true, "Bold", true);

1399 verifyItem(1, -198, 350., false, QString(), true);

1400 verifyItem(2, 152, 390., false, "Lazy", false);

1401 QCOMPARE(lvwph->m_minYExtent, 310.);

1402 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1403 QCOMPARE(lvwph->m_clipItem->clip(), false);

1404 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1405 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1406 QCOMPARE(lvwph->contentY(), 1458.);

1407 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1408 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1409 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1410 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1411 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1412

1413 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1414

1415 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1416 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1417 verifyItem(0, -588., 390., true, "Bold", true);

1418 verifyItem(1, -198, 350., false, QString(), true);

1419 verifyItem(2, 152, 390., false, "Lazy", false);

1420 verifyItem(3, 542, 190., true, "Agressive", true);

1421 QCOMPARE(lvwph->m_minYExtent, -160.);

1422 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1423 QCOMPARE(lvwph->m_clipItem->clip(), false);

1424 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1425 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1426 QCOMPARE(lvwph->contentY(), 1458.);

1427 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1428 QVERIFY(!lvwph->isAtYEnd());

1429 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1430 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1431 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1432 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1433 }

1434

1435 void testChangeSizeVisibleItemNotOnViewport()

1436 {

1437 changeContentY(490);

1438

1439 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1440 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1441 verifyItem(0, -440., 190., true, "Agressive", true);

1442 verifyItem(1, -250., 240., true, "Regular", true);

1443 verifyItem(2, -10, 390., false, "Mild", true);

1444 verifyItem(3, 380, 390., false, "Bold", false);

1445 verifyItem(4, 770, 350., true, QString(), true);

1446 QCOMPARE(lvwph->m_minYExtent, 0.);

1447 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1448 QCOMPARE(lvwph->m_clipItem->clip(), false);

1449 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1450 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1451 QCOMPARE(lvwph->contentY(), 490.);

1452 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1453 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1454 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1455 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[2]->m_item);

1456 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1457

1458 model->setProperty(1, "size", 100);

1459

1460 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1461 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1462 verifyItem(0, -340., 190., true, "Agressive", true);

1463 verifyItem(1, -150., 140., true, "Regular", true);

1464 verifyItem(2, -10, 390., false, "Mild", true);

1465 verifyItem(3, 380, 390., false, "Bold", false);

1466 verifyItem(4, 770, 350., true, QString(), true);

1467 QCOMPARE(lvwph->m_minYExtent, -100.);

1468 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1469 QCOMPARE(lvwph->m_clipItem->clip(), false);

1470 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1471 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1472 QCOMPARE(lvwph->contentY(), 490.);

1473 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1474 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1475 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1476 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[2]->m_item);

1477 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1478 }

1479

1480 void testShowHeaderHalfShown()

1481 {

1482 changeContentY(20);

1483

1484 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1485 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1486 verifyItem(0, 30., 190., false, "Agressive", false);

1487 verifyItem(1, 220, 240., false, "Regular", false);

1488 verifyItem(2, 460, 390., false, "Mild", false);

1489 QCOMPARE(lvwph->m_minYExtent, 0.);

1490 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1491 QCOMPARE(lvwph->m_clipItem->clip(), false);

1492 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1493 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1494 QCOMPARE(lvwph->contentY(), 20.);

1495 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1496 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1497

1498 lvwph->showHeader();

1499

1500 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1501 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1502 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1503 verifyItem(0, -20., 190., false, "Agressive", true);

1504 verifyItem(1, 170, 240., false, "Regular", false);

1505 verifyItem(2, 410, 390., false, "Mild", false);

1506 QCOMPARE(lvwph->m_minYExtent, 20.);

1507 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1508 QCOMPARE(lvwph->m_clipItem->clip(), true);

1509 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1510 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1511 QCOMPARE(lvwph->contentY(), 0.);

1512 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1513 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1514 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1515 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1516 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1517

1518 scrollToTop();

1519

1520 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1521 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1522 verifyItem(0, 50., 190., false, "Agressive", false);

1523 verifyItem(1, 240., 240., false, "Regular", false);

1524 verifyItem(2, 480., 390., false, "Mild", false);

1525 QCOMPARE(lvwph->m_minYExtent, 20.);

1526 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1527 QCOMPARE(lvwph->m_clipItem->clip(), false);

1528 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1529 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1530 QCOMPARE(lvwph->contentY(), -20.);

1531 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1532 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1533 }

1534

1535 void testShowHeaderCloseToTheTop()

1536 {

1537 changeContentY(375);

1538

1539 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1540 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1541 verifyItem(0, -325., 190., true, "Agressive", true);

1542 verifyItem(1, -135, 240., false, "Regular", true);

1543 verifyItem(2, 105, 390., false, "Mild", false);

1544 verifyItem(3, 495, 390., false, "Bold", false);

1545 QCOMPARE(lvwph->m_minYExtent, 0.);

1546 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1547 QCOMPARE(lvwph->m_clipItem->clip(), false);

1548 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1549 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1550 QCOMPARE(lvwph->contentY(), 375.);

1551 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1552 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1553 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1554 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1555 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1556

1557 lvwph->showHeader();

1558

1559 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1560 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1561 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1562 verifyItem(0, -375., 190., true, "Agressive", true);

1563 verifyItem(1, -185, 240., false, "Regular", true);

1564 verifyItem(2, 55, 390., false, "Mild", false);

1565 verifyItem(3, 445, 390., false, "Bold", false);

1566 QCOMPARE(lvwph->m_minYExtent, 50.);

1567 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1568 QCOMPARE(lvwph->m_clipItem->clip(), true);

1569 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1570 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1571 QCOMPARE(lvwph->contentY(), 325.);

1572 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1573 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1574 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1575 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1576 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1577

1578 scrollToTop();

1579

1580 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1581 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1582 verifyItem(0, 50., 190., false, "Agressive", false);

1583 verifyItem(1, 240., 240., false, "Regular", false);

1584 verifyItem(2, 480., 390., false, "Mild", false);

1585 QCOMPARE(lvwph->m_minYExtent, 50.);

1586 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1587 QCOMPARE(lvwph->m_clipItem->clip(), false);

1588 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1589 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1590 QCOMPARE(lvwph->contentY(), -50.);

1591 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1592 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1593 }

1594

1595 void testShowHeaderAtBottom()

1596 {

1597 scrollToBottom();

1598

1599 lvwph->showHeader();

1600

1601 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1602 QTRY_VERIFY (lvwph->isAtYEnd());

1603 }

1604

1605 void growWindow()

1606 {

1607 view->rootObject()->setHeight(850);

1608

1609 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1610 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1611 verifyItem(0, 50., 190., false, "Agressive", false);

1612 verifyItem(1, 240., 240., false, "Regular", false);

1613 verifyItem(2, 480., 390., false, "Mild", false);

1614 verifyItem(3, 870., 390., true, "Bold", true);

1615 verifyItem(4, 1260., 350., true, QString(), true);

1616 QCOMPARE(lvwph->m_minYExtent, 0.);

1617 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1618 QCOMPARE(lvwph->m_clipItem->clip(), false);

1619 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1620 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1621 QCOMPARE(lvwph->contentY(), 0.);

1622 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1623 }

1624

1625 void growWindowAtBottom()

1626 {

1627 // Need a bunch small items at the bottom to trigger the problem

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, "Agressive"));

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, "Regular"));

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 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1648

1649 scrollToBottom();

1650

1651 view->rootObject()->setHeight(850);

1652

1653 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1654 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1655 verifyItem(0, -660., 390., true, "Lazy", true);

1656 verifyItem(1, -270., 90., true, "Agressive", true);

1657 verifyItem(2, -180, 50., true, QString(), true);

1658 verifyItem(3, -130, 50., true, QString(), true);

1659 verifyItem(4, -80, 50., true, QString(), true);

1660 verifyItem(5, -30, 50., false, QString(), true);

1661 verifyItem(6, 20, 50., false, QString(), true);

1662 verifyItem(7, 70, 50., false, QString(), true);

1663 verifyItem(8, 120, 50., false, QString(), true);

1664 verifyItem(9, 170, 90., false, "Regular", false);

1665 verifyItem(10, 260, 50., false, QString(), true);

1666 verifyItem(11, 310, 50., false, QString(), true);

1667 verifyItem(12, 360, 50., false, QString(), true);

1668 verifyItem(13, 410, 50., false, QString(), true);

1669 verifyItem(14, 460, 50., false, QString(), true);

1670 verifyItem(15, 510, 90., false, "Agressive", false);

1671 verifyItem(16, 600, 50., false, QString(), true);

1672 verifyItem(17, 650, 50., false, QString(), true);

1673 verifyItem(18, 700, 50., false, QString(), true);

1674 verifyItem(19, 750, 50., false, QString(), true);

1675 verifyItem(20, 800, 50., false, QString(), true);

1676 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1677 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

1678 QCOMPARE(lvwph->m_clipItem->clip(), false);

1679 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1680 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1681 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1682 }

1683

1684 void testCullOnBottomEdge()

1685 {

1686 changeContentY(240);

1687

1688 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1689 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1690 verifyItem(0, -190., 190., true, "Agressive", true);

1691 verifyItem(1, 0., 240., false, "Regular", false);

1692 verifyItem(2, 240., 390., false, "Mild", false);

1693 verifyItem(3, 630., 390., true, "Bold", true);

1694 QCOMPARE(lvwph->m_minYExtent, 0.);

1695 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1696 QCOMPARE(lvwph->m_clipItem->clip(), false);

1697 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1698 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1699 QCOMPARE(lvwph->contentY(), 240.);

1700 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1701 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1702 }

1703

1704 void testSectionItemCullOnFirstSectionItemTopEdge()

1705 {

1706 changeContentY(50);

1707

1708 verifyItem(0, 0., 190., false, "Agressive", false);

1709 verifyItem(1, 190., 240., false, "Regular", false);

1710 verifyItem(2, 430., 390., false, "Mild", false);

1711 QCOMPARE(lvwph->m_minYExtent, 0.);

1712 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1713 QCOMPARE(lvwph->m_clipItem->clip(), false);

1714 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1715 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1716 QCOMPARE(lvwph->contentY(), 50.);

1717 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1718 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1719 }

1720

1721 void testSectionItemCullOnSecondSectionItemTopEdge()

1722 {

1723 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1724 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1725

1726 changeContentY(5);

1727

1728 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1729 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1730 verifyItem(0, 45., 90., false, "Agressive", false);

1731 verifyItem(1, 135., 50., false, QString(), false);

1732 verifyItem(2, 185., 150., false, QString(), false);

1733 verifyItem(3, 335., 240., false, "Regular", false);

1734 verifyItem(4, 575., 390., true, "Mild", true);

1735 QCOMPARE(lvwph->m_minYExtent, 0.);

1736 QCOMPARE(lvwph->m_clipItem->y(), 5.);

1737 QCOMPARE(lvwph->m_clipItem->clip(), false);

1738 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1739 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1740 QCOMPARE(lvwph->contentY(), 5.);

1741 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1742 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1743

1744 changeContentY(135);

1745

1746 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1747 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1748 verifyItem(0, -90., 90., true, "Agressive", true);

1749 verifyItem(1, 0., 50., false, QString(), false);

1750 verifyItem(2, 50., 150., false, QString(), false);

1751 verifyItem(3, 200., 240., false, "Regular", false);

1752 verifyItem(4, 440., 390., false, "Mild", false);

1753 QCOMPARE(lvwph->m_minYExtent, 0.);

1754 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1755 QCOMPARE(lvwph->m_clipItem->clip(), false);

1756 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1757 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1758 QCOMPARE(lvwph->contentY(), 140.);

1759 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1760 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1761 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1762 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1763 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1764 }

1765

1766 void testMaximizeVisibleArea()

1767 {

1768 bool res = lvwph->maximizeVisibleArea(2);

1769 QVERIFY(res);

1770 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1771

1772 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1773 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1774 verifyItem(0, -278., 190., true, "Agressive", true);

1775 verifyItem(1, -88., 240., false, "Regular", true);

1776 verifyItem(2, 152, 390., false, "Mild", false);

1777 verifyItem(3, 542, 390., true, "Bold", true);

1778 QCOMPARE(lvwph->m_minYExtent, 0.);

1779 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1780 QCOMPARE(lvwph->m_clipItem->clip(), false);

1781 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1782 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1783 QCOMPARE(lvwph->contentY(), 328.);

1784 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1785 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1786 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1787 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1788 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1789 }

1790

1791 void testMaximizeVisibleAreaVisibleItems()

1792 {

1793 bool res = lvwph->maximizeVisibleArea(0);

1794 QVERIFY(res);

1795 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1796

1797 verifyInitialTopPosition();

1798

1799 res = lvwph->maximizeVisibleArea(1);

1800 QVERIFY(res);

1801 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1802

1803 verifyInitialTopPosition();

1804 }

1805

1806 void testMaximizeVisibleAreaInvalidIndexes()

1807 {

1808 bool res = lvwph->maximizeVisibleArea(-1);

1809 QVERIFY(!res);

1810 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1811

1812 verifyInitialTopPosition();

1813

1814 res = lvwph->maximizeVisibleArea(1000);

1815 QVERIFY(!res);

1816 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1817

1818 verifyInitialTopPosition();

1819

1820 res = lvwph->maximizeVisibleArea(3);

1821 QVERIFY(!res);

1822 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1823

1824 verifyInitialTopPosition();

1825 }

1826

1827 void testMaximizeVisibleAreaBigElement()

1828 {

1829 model->setProperty(2, "size", 4000);

1830 verifyItem(2, 480, 4040., false, "Mild", false);

1831

1832 bool res = lvwph->maximizeVisibleArea(2);

1833 QVERIFY(res);

1834 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1835

1836 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1837 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1838 verifyItem(0, -430., 190., true, "Agressive", true);

1839 verifyItem(1, -240., 240., true, "Regular", true);

1840 verifyItem(2, 0, 4040., false, "Mild", false);

1841 QCOMPARE(lvwph->m_minYExtent, 0.);

1842 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1843 QCOMPARE(lvwph->m_clipItem->clip(), false);

1844 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1845 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1846 QCOMPARE(lvwph->contentY(), 480.);

1847 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1848 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1849 }

1850

1851 void testMaximizeVisibleAreaScrollDown()

1852 {

1853 changeContentY(350);

1854 bool res = lvwph->maximizeVisibleArea(1);

1855 QVERIFY(res);

1856 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1857

1858 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1859 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1860 verifyItem(0, -190., 190., true, "Agressive", true);

1861 verifyItem(1, 0., 240., false, "Regular", false);

1862 verifyItem(2, 240, 390., false, "Mild", false);

1863 verifyItem(3, 630, 390., true, "Bold", true);

1864 QCOMPARE(lvwph->m_minYExtent, 0.);

1865 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1866 QCOMPARE(lvwph->m_clipItem->clip(), false);

1867 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1868 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1869 QCOMPARE(lvwph->contentY(), 240.);

1870 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1871 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1872 }

1873

1874 void testMaximizeVisibleAreaScrollDownBigElement()

1875 {

1876 model->setProperty(1, "size", 1000);

1877 changeContentY(1150);

1878 bool res = lvwph->maximizeVisibleArea(1);

1879 QVERIFY(res);

1880 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1881

1882 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1883 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1884 verifyItem(0, -498., 1040., false, "Regular", true);

1885 verifyItem(1, 542., 390., true, "Mild", true);

1886 QCOMPARE(lvwph->m_minYExtent, 525.);

1887 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1888 QCOMPARE(lvwph->m_clipItem->clip(), false);

1889 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1890 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1891 QCOMPARE(lvwph->contentY(), 738.);

1892 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1893 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1894 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1895 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1896 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1897 }

1898

1899 void testMaximizeVisibleAreaBigElementInTheMiddle()

1900 {

1901 model->setProperty(1, "size", 1000);

1902 changeContentY(650);

1903

1904 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1905 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1906 verifyItem(0, -410., 1040., false, "Regular", true);

1907 verifyItem(1, 630., 390., true, "Mild", true);

1908 QCOMPARE(lvwph->m_minYExtent, 525.);

1909 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1910 QCOMPARE(lvwph->m_clipItem->clip(), false);

1911 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1912 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1913 QCOMPARE(lvwph->contentY(), 650.);

1914 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1915 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1916 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1917 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1918 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1919

1920 bool res = lvwph->maximizeVisibleArea(1);

1921 QVERIFY(res);

1922 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1923

1924 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1925 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1926 verifyItem(0, -410., 1040., false, "Regular", true);

1927 verifyItem(1, 630., 390., true, "Mild", true);

1928 QCOMPARE(lvwph->m_minYExtent, 525.);

1929 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1930 QCOMPARE(lvwph->m_clipItem->clip(), false);

1931 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1932 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1933 QCOMPARE(lvwph->contentY(), 650.);

1934 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1935 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1936 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1937 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1938 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1939 }

1940

1941 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1942 {

1943 changeContentY(430);

1944 changeContentY(-30);

1945

1946 bool res = lvwph->maximizeVisibleArea(1);

1947 QVERIFY(res);

1948 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1949

1950 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1951 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1952 verifyItem(0, -190., 190., true, "Agressive", true);

1953 verifyItem(1, 0., 240., false, "Regular", false);

1954 verifyItem(2, 240, 390., false, "Mild", false);

1955 verifyItem(3, 630, 390., true, "Bold", true);

1956 QCOMPARE(lvwph->m_minYExtent, 0.);

1957 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1958 QCOMPARE(lvwph->m_clipItem->clip(), false);

1959 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1960 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1961 QCOMPARE(lvwph->contentY(), 240.);

1962 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1963 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1964 }

1965

1966 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1967 {

1968 changeContentY(430);

1969 changeContentY(-30);

1970

1971 bool res = lvwph->maximizeVisibleArea(3);

1972 QVERIFY(res);

1973 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1974

1975 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1976 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1977 verifyItem(0, -478., 240., true, "Regular", true);

1978 verifyItem(1, -238., 390., false, "Mild", true);

1979 verifyItem(2, 152, 390., false, "Bold", false);

1980 verifyItem(3, 542, 350., true, QString(), true);

1981 QCOMPARE(lvwph->m_minYExtent, 152.5);

1982 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1983 QCOMPARE(lvwph->m_clipItem->clip(), false);

1984 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1985 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1986 QCOMPARE(lvwph->contentY(), 718.);

1987 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1988 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1989 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1990 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1991 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1992 }

1993

1994 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

1995 {

1996 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

1997 changeContentY(250);

1998 bool res = lvwph->maximizeVisibleArea(1);

1999 QVERIFY(res);

2000 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2001

2002 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2003 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2004 verifyItem(0, -100., 140., false, "Agressive", true);

2005 verifyItem(1, 40., 150., false, QString(), true);

2006 verifyItem(2, 190, 240., false, "Regular", false);

2007 verifyItem(3, 430, 390., false, "Mild", false);

2008 QCOMPARE(lvwph->m_minYExtent, 0.);

2009 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2010 QCOMPARE(lvwph->m_clipItem->clip(), false);

2011 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2012 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2013 QCOMPARE(lvwph->contentY(), 150.);

2014 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2015 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2016 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2017 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

2018 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2019

2020 changeContentY(20);

2021 res = lvwph->maximizeVisibleArea(1);

2022 QVERIFY(res);

2023 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2024

2025 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2026 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2027 verifyItem(0, -100., 140., false, "Agressive", true);

2028 verifyItem(1, 40., 150., false, QString(), true);

2029 verifyItem(2, 190, 240., false, "Regular", false);

2030 verifyItem(3, 430, 390., false, "Mild", false);

2031 QCOMPARE(lvwph->m_minYExtent, 0.);

2032 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2033 QCOMPARE(lvwph->m_clipItem->clip(), false);

2034 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2035 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2036 QCOMPARE(lvwph->contentY(), 150.);

2037 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2038 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2039 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2040 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

2041 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2042 }

2043

2044 void testMaximizeVisibleAreaWithItemResize()

2045 {

2046 model->setProperty(0, "size", 1000);

2047

2048 bool res = lvwph->maximizeVisibleArea(1);

2049 QVERIFY(res);

2050 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2051

2052 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2053 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2054 verifyItem(0, -738., 1040., false, "Agressive", true);

2055 verifyItem(1, 302., 240., false, "Regular", false);

2056 verifyItem(2, 542, 390., true, "Mild", true);

2057 QCOMPARE(lvwph->m_minYExtent, 0.);

2058 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2059 QCOMPARE(lvwph->m_clipItem->clip(), false);

2060 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2061 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2062 QCOMPARE(lvwph->contentY(), 788.);

2063 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2064 }

2065

2066 void addingRemoveItemsShouldNotChangeContentY()

2067 {

2068 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

2069 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

2070 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

2071

2072 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2073 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2074 verifyItem(0, 50., 190., false, "Agressive", false);

2075 QCOMPARE(lvwph->m_minYExtent, 0.);

2076 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2077 QCOMPARE(lvwph->m_clipItem->clip(), false);

2078 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2079 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2080 QCOMPARE(lvwph->contentY(), 0.);

2081 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2082

2083 QCOMPARE(spy.count(), 0);

2084 }

2085

2086 void testDownAndUp()

2087 {

2088 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2089

2090 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2091 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2092 verifyItem(0, 50., 190., false, "Agressive", false);

2093 QCOMPARE(lvwph->m_minYExtent, 0.);

2094 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2095 QCOMPARE(lvwph->m_clipItem->clip(), false);

2096 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2097 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2098 QCOMPARE(lvwph->contentY(), 0.);

2099 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2100 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2101

2102 QTest::qWait(1);

2103 QCoreApplication::instance()->processEvents();

2104

2105 changeContentY(-15);

2106

2107 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2108 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2109 verifyItem(0, 65., 190., false, "Agressive", false);

2110 QCOMPARE(lvwph->m_minYExtent, 0.);

2111 QCOMPARE(lvwph->m_clipItem->y(), -15.);

2112 QCOMPARE(lvwph->m_clipItem->clip(), false);

2113 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2114 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2115 QCOMPARE(lvwph->contentY(), -15.);

2116 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2117 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2118

2119 changeContentY(25);

2120

2121 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2122 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2123 verifyItem(0, 40., 190., false, "Agressive", false);

2124 QCOMPARE(lvwph->m_minYExtent, 0.);

2125 QCOMPARE(lvwph->m_clipItem->y(), 10.);

2126 QCOMPARE(lvwph->m_clipItem->clip(), false);

2127 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2128 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2129 QCOMPARE(lvwph->contentY(), 10.);

2130 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2131 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2132

2133

2134 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2135

2136 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2137 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2138 verifyItem(0, 50., 190., false, "Agressive", false);

2139 QCOMPARE(lvwph->m_minYExtent, 0.);

2140 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2141 QCOMPARE(lvwph->m_clipItem->clip(), false);

2142 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2143 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2144 QCOMPARE(lvwph->contentY(), 0.);

2145 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2146 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2147 }

2148

2149 void changeSectionProperty()

2150 {

2151 model->setProperty(1, "type", "Rojo");

2152 verifyItem(1, 240., 240., false, "Rojo", false);

2153

2154 model->setProperty(1, "type", "Agressive");

2155 verifyItem(1, 240., 200., false, QString(), true);

2156

2157 model->setProperty(1, "type", "Rojo");

2158 verifyItem(1, 240., 240., false, "Rojo", false);

2159

2160 model->setProperty(1, "type", "Mild");

2161 verifyItem(1, 240., 240., false, "Mild", false);

2162 verifyItem(2, 480., 350., false, QString(), false);

2163

2164 model->setProperty(1, "type", "Rojo");

2165 verifyItem(1, 240., 240., false, "Rojo", false);

2166 verifyItem(2, 480., 390., false, "Mild", false);

2167

2168 model->setProperty(2, "type", "Agressive");

2169 verifyItem(2, 480., 390., false, "Agressive", false);

2170

2171 model->setProperty(1, "type", "Agressive");

2172 verifyItem(1, 240., 200., false, QString(), true);

2173 verifyItem(2, 440., 350., false, QString(), false);

2174

2175 model->setProperty(1, "type", "Rojo");

2176 verifyItem(1, 240., 240., false, "Rojo", false);

2177 verifyItem(2, 480., 390., false, "Agressive", false);

2178 }

2179

2180 void firstItemSectionHeightChange()

2181 {

2182 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2183 model->setProperty(0, "type", "halfheight");

2184 verifyItem(0, 50., 170., false, "halfheight", false);

2185 }

2186

2187 void secondItemSectionHeightChange()

2188 {

2189 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 2), Q_ARG(QVariant, 4));

2190 model->setProperty(1, "type", "halfheight");

2191 verifyItem(0, 50., 190., false, "Agressive", false);

2192 verifyItem(1, 240., 220., false, "halfheight", false);

2193 }

2194

2195 void testInvalidSectionDelegate()

2196 {

2197 lvwph->setProperty("useBrokenSectionDelegateComponent", true);

2198 scrollToBottom();

2199 }

2200

2201private:

2202 QQuickView *view;

2203 ListViewWithPageHeader *lvwph;

2204 QQmlListModel *model;

2205 QQmlComponent *otherDelegate;

2206};

2207

2208QTEST_MAIN(ListViewWithPageHeaderTestSection)

2209

2210#include "listviewwithpageheadersectiontest.moc"