tests/plugins/Dash/listviewwithpageheadersectiontest.cpp · unity8

git.iko.soy/unity8

on 7b99df2 help sign in

unity8/tests/plugins/Dash/listviewwithpageheadersectiontest.cpp

2212 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>

28#include <paths.h>

30class ListViewWithPageHeaderTestSection : public QObject

31{

32 Q_OBJECT

34private:

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

36 {

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

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

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

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

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

42 if (!sectionHeader.isNull()) {

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

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

45 }

46 }

48 void changeContentY(qreal change)

49 {

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

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

52 const qreal jump = 25;

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

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

55 QTest::qWait(1);

56 }

57 } else {

58 const qreal jump = -25;

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

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

61 QTest::qWait(1);

62 }

63 }

64 lvwph->setContentY(dest);

65 QTest::qWait(1);

66 }

68 void scrollToTop()

69 {

70 const qreal jump = -25;

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

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

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

74 } else {

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

76 }

77 QTest::qWait(1);

78 }

79 }

81 void scrollToBottom()

82 {

83 const qreal jump = 25;

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

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

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

87 } else {

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

89 }

90 QTest::qWait(1);

91 }

92 }

94 void verifyInitialTopPosition()

95 {

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

97 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

109 }

110

111 bool hasSectionHeaderProperty(QQuickItem *item) const

112 {

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

114 }

115

116 QString section(QQuickItem *item) const

117 {

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

119 }

120

121 QQuickItem *sectionDelegate(QQuickItem *item) const

122 {

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

124 }

125

126private Q_SLOTS:

127

128 void initTestCase()

129 {

130 }

131

132 void init()

133 {

134 view = new QQuickView();

135 view->setSource(QUrl::fromLocalFile(testDataDir() + "/" TEST_DIR "/listviewwithpageheadertestsection.qml"));

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

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

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

139 QVERIFY(lvwph);

140 QVERIFY(model);

141 QVERIFY(otherDelegate);

142 view->show();

143 QTest::qWaitForWindowExposed(view);

144

145 verifyInitialTopPosition();

146 }

147

148 void cleanup()

149 {

150 delete view;

151 }

152

153 void testCreationDeletion()

154 {

155 // Nothing, init/cleanup already tests this

156 }

157

158 void testDrag1PixelUp()

159 {

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

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

162 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

174 }

175

176 void testHeaderDetachDragDown()

177 {

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

179 QTest::qWait(100);

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

181 QTest::qWait(100);

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

183 QTest::qWait(100);

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

185 QTest::qWait(100);

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

187 QTest::qWait(100);

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

189 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

201

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

203

204 verifyInitialTopPosition();

205 }

206

207 void testDrag375PixelUp()

208 {

209 changeContentY(375);

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

211 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

227 }

228

229 void testDrag520PixelUp()

230 {

231 changeContentY(520);

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

233 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

238 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

249 }

250

251 void testDragHeaderUpThenShow()

252 {

253 changeContentY(120);

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

255 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

271

272 changeContentY(-30);

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

274 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

290 }

291

292 void testDragHeaderUpThenShowWithoutHidingTotally()

293 {

294 changeContentY(10);

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

296 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

308

309 changeContentY(-1);

310

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

312 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

324 }

325

326 void testPositionAtBeginningIndex0Visible()

327 {

328 changeContentY(375);

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

330 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

346

347 lvwph->positionAtBeginning();

348

349 verifyInitialTopPosition();

350 }

351

352 void testPositionAtBeginningIndex0NotVisible()

353 {

354 changeContentY(520);

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

356 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

361 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

372

373 lvwph->positionAtBeginning();

374

375 verifyInitialTopPosition();

376 }

377

378 void testIndex0GrowOnScreen()

379 {

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

381

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

383 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

395 }

396

397 void testIndex0GrowOffScreen()

398 {

399 changeContentY(375);

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

401 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

417

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

419

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

421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

437

438 scrollToTop();

439

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

441 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

453

454 changeContentY(30);

455

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

457 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

469 }

470

471 void testIndex0GrowNotCreated()

472 {

473 changeContentY(520);

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

475 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

480 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

491

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

493

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

495 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

500 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

511

512 scrollToTop();

513

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

515 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

527 }

528

529 void testShowHideShowHeaderAtBottom()

530 {

531 scrollToBottom();

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

533 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

548

549 changeContentY(-30);

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

551 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

566

567 changeContentY(30);

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

569 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

584

585 changeContentY(-30);

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

587 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

602 }

603

604 void testChangeDelegateAtBottom()

605 {

606 scrollToBottom();

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

608 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

623

624 lvwph->setDelegate(otherDelegate);

625

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

627 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

642 }

643

644 void testSetEmptyHeaderAtTop()

645 {

646 lvwph->setHeader(nullptr);

647

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

649 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

660 }

661

662 void testSetEmptyHeaderAtBottom()

663 {

664 scrollToBottom();

665 lvwph->setHeader(nullptr);

666

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

668 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

682

683 scrollToTop();

684

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

686 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

697 }

698

699 void testSetEmptyHeaderWhenPartlyShownClipped()

700 {

701 scrollToBottom();

702 changeContentY(-30);

703 lvwph->setHeader(nullptr);

704

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

706 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

716 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

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

721

722 scrollToTop();

723

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

725 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

736 }

737

738 void testSetEmptyHeaderWhenPartlyShownNotClipped()

739 {

740 changeContentY(30);

741 lvwph->setHeader(nullptr);

742

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

744 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

758 }

759

760 void testSetNullDelegate()

761 {

762 lvwph->setDelegate(nullptr);

763

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

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

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

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

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

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

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

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

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

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

774 QVERIFY(lvwph->isAtYBeginning());

775 QVERIFY(lvwph->isAtYEnd());

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

777 }

778

779 void testInsertItems()

780 {

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

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

783

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

785 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

799 }

800

801 void testInsertItemsStealSectionItem()

802 {

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

804

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

806 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

819 }

820

821

822 void testInsertItemsOnNotShownPosition()

823 {

824 changeContentY(800);

825

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

827 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

843

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

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

846

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

848 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

864

865 scrollToTop();

866

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

868 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

882 }

883

884 void testInsertItemsAtEndOfViewport()

885 {

886 changeContentY(60);

887

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

889 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

905

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

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

908

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

910 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

926 }

927

928 void testInsertItemsBeforeValidIndex()

929 {

930 changeContentY(520);

931

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

933 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

938 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

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

949

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

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

952

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

954 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

959 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

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

970 }

971

972 void testInsertItemsBeforeViewport()

973 {

974 changeContentY(375);

975

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

977 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

993

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

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

996

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

998 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1014

1015 scrollToTop();

1016

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

1018 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

1032 }

1033

1034 void testInsertItemsAtBottom()

1035 {

1036 scrollToBottom();

1037

1038 QVERIFY(lvwph->isAtYEnd());

1039

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

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

1042

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

1044 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1062

1063 scrollToBottom();

1064

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

1066 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1078 QVERIFY(lvwph->isAtYEnd());

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

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

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

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

1083 }

1084

1085 void testInsertItemAtTop()

1086 {

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

1088

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

1090 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1102 QVERIFY(lvwph->isAtYBeginning());

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

1104 }

1105

1106 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1107 {

1108 scrollToBottom();

1109

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

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

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

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

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

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

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

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

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

1120

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

1122 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1137

1138 changeContentY(-1700);

1139

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

1141 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1151 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

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

1162 }

1163

1164 void testInsertToEmpty()

1165 {

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

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

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

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

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

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

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

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

1174

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

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

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

1178 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

1181 }

1182

1183 void testRemoveItemsAtTop()

1184 {

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

1186

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

1188 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1198 QVERIFY(lvwph->isAtYBeginning());

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

1200 }

1201

1202 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1203 {

1204 scrollToBottom();

1205

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

1207

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

1209 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

1219 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1220 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1221 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1222 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1223 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1224 }

1225

1226 void testRemoveLastItemsAtBottom()

1227 {

1228 scrollToBottom();

1229

1230 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));

1231

1232 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1233 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1234 verifyItem(0, -478., 240., true, "Regular", true);

1235 verifyItem(1, -238, 390., false, "Mild", true);

1236 verifyItem(2, 152, 390., false, "Bold", false);

1237 QCOMPARE(lvwph->m_minYExtent, 150.);

1238 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1239 QCOMPARE(lvwph->m_clipItem->clip(), false);

1240 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1241 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1242 QCOMPARE(lvwph->contentY(), 718.);

1243 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1244 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1245 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1246 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1247 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1248 }

1249

1250 void testRemoveItemOutOfViewport()

1251 {

1252 changeContentY(520);

1253

1254 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1255 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1256 verifyItem(0, -280., 240., true, "Regular", true);

1257 verifyItem(1, -40, 390., false, "Mild", true);

1258 verifyItem(2, 350, 390., false, "Bold", false);

1259 verifyItem(3, 740, 350., true, QString(), true);

1260 QCOMPARE(lvwph->m_minYExtent, 152.5);

1261 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1262 QCOMPARE(lvwph->m_clipItem->clip(), false);

1263 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1264 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1265 QCOMPARE(lvwph->contentY(), 520.);

1266 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1267 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1268 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1269 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1270 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1271

1272 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1273

1274 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1275 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1276 verifyItem(0, -230., 190., true, "Agressive", true);

1277 verifyItem(1, -40, 390., false, "Mild", true);

1278 verifyItem(2, 350, 390., false, "Bold", false);

1279 verifyItem(3, 740, 350., true, QString(), true);

1280 QCOMPARE(lvwph->m_minYExtent, -240.);

1281 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1282 QCOMPARE(lvwph->m_clipItem->clip(), false);

1283 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1284 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1285 QCOMPARE(lvwph->contentY(), 520.);

1286 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1287 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1288 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1289 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1290 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1291 }

1292

1293 void testRemoveFirstOfCategory()

1294 {

1295 changeContentY(520);

1296

1297 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1298 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1299 verifyItem(0, -280., 240., true, "Regular", true);

1300 verifyItem(1, -40, 390., false, "Mild", true);

1301 verifyItem(2, 350, 390., false, "Bold", false);

1302 verifyItem(3, 740, 350., true, QString(), true);

1303 QCOMPARE(lvwph->m_minYExtent, 152.5);

1304 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1305 QCOMPARE(lvwph->m_clipItem->clip(), false);

1306 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1307 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1308 QCOMPARE(lvwph->contentY(), 520.);

1309 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1310 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1311 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1312 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1313 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1314

1315 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1316

1317 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1318 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1319 verifyItem(0, -280., 240., true, "Regular", true);

1320 verifyItem(1, -40, 390., false, "Mild", true);

1321 verifyItem(2, 350, 390., false, "Bold", false);

1322 verifyItem(3, 740, 390., true, "Lazy", true);

1323 QCOMPARE(lvwph->m_minYExtent, 162.5);

1324 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1325 QCOMPARE(lvwph->m_clipItem->clip(), false);

1326 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1327 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1328 QCOMPARE(lvwph->contentY(), 520.);

1329 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1330 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1331 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1332 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1333 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1334 }

1335

1336 void testAddSecondToCulledCategoryOfTwo()

1337 {

1338 // Do some setup

1339 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1340 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1341

1342 changeContentY(200);

1343

1344 // Very the items are culled

1345 verifyItem(0, -150., 65., true, "Agressive", true);

1346 verifyItem(1, -85, 25., true, QString(), true);

1347

1348 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));

1349

1350 // Very the new item is there correctly

1351 verifyItem(0, -175., 65., true, "Agressive", true);

1352 verifyItem(1, -110, 25., true, QString(), true);

1353 verifyItem(2, -85, 25., true, QString(), true);

1354 }

1355

1356 void testMoveFirstItems()

1357 {

1358 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1359

1360 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1361 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1362 verifyItem(0, 50., 240., false, "Regular", false);

1363 verifyItem(1, 290., 190., false, "Agressive", false);

1364 verifyItem(2, 480., 390., false, "Mild", false);

1365 QCOMPARE(lvwph->m_minYExtent, 0.);

1366 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1367 QCOMPARE(lvwph->m_clipItem->clip(), false);

1368 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1369 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1370 QCOMPARE(lvwph->contentY(), 0.);

1371 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1372 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1373 }

1374

1375 void testMoveFirstOutOfVisibleItems()

1376 {

1377 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1378

1379 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1380 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1381 verifyItem(0, 50., 240., false, "Regular", false);

1382 verifyItem(1, 290., 390., false, "Mild", false);

1383 verifyItem(2, 680., 390., true, "Bold", true);

1384 QCOMPARE(lvwph->m_minYExtent, 0.);

1385 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1386 QCOMPARE(lvwph->m_clipItem->clip(), false);

1387 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1388 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1389 QCOMPARE(lvwph->contentY(), 0.);

1390 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1391 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1392 }

1393

1394 void testMoveFirstToLastAtBottom()

1395 {

1396 scrollToBottom();

1397

1398 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1399 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1400 verifyItem(0, -588., 390., true, "Bold", true);

1401 verifyItem(1, -198, 350., false, QString(), true);

1402 verifyItem(2, 152, 390., false, "Lazy", false);

1403 QCOMPARE(lvwph->m_minYExtent, 310.);

1404 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1405 QCOMPARE(lvwph->m_clipItem->clip(), false);

1406 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1407 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1408 QCOMPARE(lvwph->contentY(), 1458.);

1409 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1410 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1411 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1412 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1413 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1414

1415 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1416

1417 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1418 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1419 verifyItem(0, -588., 390., true, "Bold", true);

1420 verifyItem(1, -198, 350., false, QString(), true);

1421 verifyItem(2, 152, 390., false, "Lazy", false);

1422 verifyItem(3, 542, 190., true, "Agressive", true);

1423 QCOMPARE(lvwph->m_minYExtent, -160.);

1424 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1425 QCOMPARE(lvwph->m_clipItem->clip(), false);

1426 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1427 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1428 QCOMPARE(lvwph->contentY(), 1458.);

1429 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1430 QVERIFY(!lvwph->isAtYEnd());

1431 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1432 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1433 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1434 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1435 }

1436

1437 void testChangeSizeVisibleItemNotOnViewport()

1438 {

1439 changeContentY(490);

1440

1441 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1442 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1443 verifyItem(0, -440., 190., true, "Agressive", true);

1444 verifyItem(1, -250., 240., true, "Regular", true);

1445 verifyItem(2, -10, 390., false, "Mild", true);

1446 verifyItem(3, 380, 390., false, "Bold", false);

1447 verifyItem(4, 770, 350., true, QString(), true);

1448 QCOMPARE(lvwph->m_minYExtent, 0.);

1449 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1450 QCOMPARE(lvwph->m_clipItem->clip(), false);

1451 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1452 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1453 QCOMPARE(lvwph->contentY(), 490.);

1454 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1455 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1456 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1457 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[2]->m_item);

1458 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1459

1460 model->setProperty(1, "size", 100);

1461

1462 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1463 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1464 verifyItem(0, -340., 190., true, "Agressive", true);

1465 verifyItem(1, -150., 140., true, "Regular", true);

1466 verifyItem(2, -10, 390., false, "Mild", true);

1467 verifyItem(3, 380, 390., false, "Bold", false);

1468 verifyItem(4, 770, 350., true, QString(), true);

1469 QCOMPARE(lvwph->m_minYExtent, -100.);

1470 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1471 QCOMPARE(lvwph->m_clipItem->clip(), false);

1472 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1473 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1474 QCOMPARE(lvwph->contentY(), 490.);

1475 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1476 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1477 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1478 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[2]->m_item);

1479 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1480 }

1481

1482 void testShowHeaderHalfShown()

1483 {

1484 changeContentY(20);

1485

1486 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1487 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1488 verifyItem(0, 30., 190., false, "Agressive", false);

1489 verifyItem(1, 220, 240., false, "Regular", false);

1490 verifyItem(2, 460, 390., false, "Mild", false);

1491 QCOMPARE(lvwph->m_minYExtent, 0.);

1492 QCOMPARE(lvwph->m_clipItem->y(), 20.);

1493 QCOMPARE(lvwph->m_clipItem->clip(), false);

1494 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1495 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1496 QCOMPARE(lvwph->contentY(), 20.);

1497 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1498 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1499

1500 lvwph->showHeader();

1501

1502 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1503 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1504 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1505 verifyItem(0, -20., 190., false, "Agressive", true);

1506 verifyItem(1, 170, 240., false, "Regular", false);

1507 verifyItem(2, 410, 390., false, "Mild", false);

1508 QCOMPARE(lvwph->m_minYExtent, 20.);

1509 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1510 QCOMPARE(lvwph->m_clipItem->clip(), true);

1511 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1512 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1513 QCOMPARE(lvwph->contentY(), 0.);

1514 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1515 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1516 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1517 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1518 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1519

1520 scrollToTop();

1521

1522 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1523 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1524 verifyItem(0, 50., 190., false, "Agressive", false);

1525 verifyItem(1, 240., 240., false, "Regular", false);

1526 verifyItem(2, 480., 390., false, "Mild", false);

1527 QCOMPARE(lvwph->m_minYExtent, 20.);

1528 QCOMPARE(lvwph->m_clipItem->y(), -20.);

1529 QCOMPARE(lvwph->m_clipItem->clip(), false);

1530 QCOMPARE(lvwph->m_headerItem->y(), -20.);

1531 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1532 QCOMPARE(lvwph->contentY(), -20.);

1533 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1534 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1535 }

1536

1537 void testShowHeaderCloseToTheTop()

1538 {

1539 changeContentY(375);

1540

1541 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1542 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1543 verifyItem(0, -325., 190., true, "Agressive", true);

1544 verifyItem(1, -135, 240., false, "Regular", true);

1545 verifyItem(2, 105, 390., false, "Mild", false);

1546 verifyItem(3, 495, 390., false, "Bold", false);

1547 QCOMPARE(lvwph->m_minYExtent, 0.);

1548 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1549 QCOMPARE(lvwph->m_clipItem->clip(), false);

1550 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1551 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1552 QCOMPARE(lvwph->contentY(), 375.);

1553 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1554 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1555 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1556 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1557 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1558

1559 lvwph->showHeader();

1560

1561 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1562 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1563 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1564 verifyItem(0, -375., 190., true, "Agressive", true);

1565 verifyItem(1, -185, 240., false, "Regular", true);

1566 verifyItem(2, 55, 390., false, "Mild", false);

1567 verifyItem(3, 445, 390., false, "Bold", false);

1568 QCOMPARE(lvwph->m_minYExtent, 50.);

1569 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1570 QCOMPARE(lvwph->m_clipItem->clip(), true);

1571 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1572 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1573 QCOMPARE(lvwph->contentY(), 325.);

1574 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1575 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1576 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1577 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1578 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1579

1580 scrollToTop();

1581

1582 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1583 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1584 verifyItem(0, 50., 190., false, "Agressive", false);

1585 verifyItem(1, 240., 240., false, "Regular", false);

1586 verifyItem(2, 480., 390., false, "Mild", false);

1587 QCOMPARE(lvwph->m_minYExtent, 50.);

1588 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1589 QCOMPARE(lvwph->m_clipItem->clip(), false);

1590 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1591 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1592 QCOMPARE(lvwph->contentY(), -50.);

1593 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1594 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1595 }

1596

1597 void testShowHeaderAtBottom()

1598 {

1599 scrollToBottom();

1600

1601 lvwph->showHeader();

1602

1603 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1604 QTRY_VERIFY (lvwph->isAtYEnd());

1605 }

1606

1607 void growWindow()

1608 {

1609 view->rootObject()->setHeight(850);

1610

1611 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1612 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1613 verifyItem(0, 50., 190., false, "Agressive", false);

1614 verifyItem(1, 240., 240., false, "Regular", false);

1615 verifyItem(2, 480., 390., false, "Mild", false);

1616 verifyItem(3, 870., 390., true, "Bold", true);

1617 verifyItem(4, 1260., 350., true, QString(), true);

1618 QCOMPARE(lvwph->m_minYExtent, 0.);

1619 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1620 QCOMPARE(lvwph->m_clipItem->clip(), false);

1621 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1622 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1623 QCOMPARE(lvwph->contentY(), 0.);

1624 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1625 }

1626

1627 void growWindowAtBottom()

1628 {

1629 // Need a bunch small items at the bottom to trigger the problem

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, "Agressive"));

1635 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1636 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "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, "Regular"));

1641 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));

1642 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "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 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1649 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1650

1651 scrollToBottom();

1652

1653 view->rootObject()->setHeight(850);

1654

1655 QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);

1656 QCOMPARE(lvwph->m_firstVisibleIndex, 5);

1657 verifyItem(0, -660., 390., true, "Lazy", true);

1658 verifyItem(1, -270., 90., true, "Agressive", true);

1659 verifyItem(2, -180, 50., true, QString(), true);

1660 verifyItem(3, -130, 50., true, QString(), true);

1661 verifyItem(4, -80, 50., true, QString(), true);

1662 verifyItem(5, -30, 50., false, QString(), true);

1663 verifyItem(6, 20, 50., false, QString(), true);

1664 verifyItem(7, 70, 50., false, QString(), true);

1665 verifyItem(8, 120, 50., false, QString(), true);

1666 verifyItem(9, 170, 90., false, "Regular", false);

1667 verifyItem(10, 260, 50., false, QString(), true);

1668 verifyItem(11, 310, 50., false, QString(), true);

1669 verifyItem(12, 360, 50., false, QString(), true);

1670 verifyItem(13, 410, 50., false, QString(), true);

1671 verifyItem(14, 460, 50., false, QString(), true);

1672 verifyItem(15, 510, 90., false, "Agressive", false);

1673 verifyItem(16, 600, 50., false, QString(), true);

1674 verifyItem(17, 650, 50., false, QString(), true);

1675 verifyItem(18, 700, 50., false, QString(), true);

1676 verifyItem(19, 750, 50., false, QString(), true);

1677 verifyItem(20, 800, 50., false, QString(), true);

1678 QCOMPARE(lvwph->m_clipItem->y(), lvwph->contentY());

1679 QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - lvwph->contentY() + 50);

1680 QCOMPARE(lvwph->m_clipItem->clip(), false);

1681 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1682 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1683 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1684 }

1685

1686 void testCullOnBottomEdge()

1687 {

1688 changeContentY(240);

1689

1690 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1691 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1692 verifyItem(0, -190., 190., true, "Agressive", true);

1693 verifyItem(1, 0., 240., false, "Regular", false);

1694 verifyItem(2, 240., 390., false, "Mild", false);

1695 verifyItem(3, 630., 390., true, "Bold", true);

1696 QCOMPARE(lvwph->m_minYExtent, 0.);

1697 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1698 QCOMPARE(lvwph->m_clipItem->clip(), false);

1699 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1700 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1701 QCOMPARE(lvwph->contentY(), 240.);

1702 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1703 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1704 }

1705

1706 void testSectionItemCullOnFirstSectionItemTopEdge()

1707 {

1708 changeContentY(50);

1709

1710 verifyItem(0, 0., 190., false, "Agressive", false);

1711 verifyItem(1, 190., 240., false, "Regular", false);

1712 verifyItem(2, 430., 390., false, "Mild", false);

1713 QCOMPARE(lvwph->m_minYExtent, 0.);

1714 QCOMPARE(lvwph->m_clipItem->y(), 50.);

1715 QCOMPARE(lvwph->m_clipItem->clip(), false);

1716 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1717 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1718 QCOMPARE(lvwph->contentY(), 50.);

1719 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1720 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1721 }

1722

1723 void testSectionItemCullOnSecondSectionItemTopEdge()

1724 {

1725 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1726 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));

1727

1728 changeContentY(5);

1729

1730 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1731 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1732 verifyItem(0, 45., 90., false, "Agressive", false);

1733 verifyItem(1, 135., 50., false, QString(), false);

1734 verifyItem(2, 185., 150., false, QString(), false);

1735 verifyItem(3, 335., 240., false, "Regular", false);

1736 verifyItem(4, 575., 390., true, "Mild", true);

1737 QCOMPARE(lvwph->m_minYExtent, 0.);

1738 QCOMPARE(lvwph->m_clipItem->y(), 5.);

1739 QCOMPARE(lvwph->m_clipItem->clip(), false);

1740 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1741 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1742 QCOMPARE(lvwph->contentY(), 5.);

1743 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1744 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1745

1746 changeContentY(135);

1747

1748 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1749 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1750 verifyItem(0, -90., 90., true, "Agressive", true);

1751 verifyItem(1, 0., 50., false, QString(), false);

1752 verifyItem(2, 50., 150., false, QString(), false);

1753 verifyItem(3, 200., 240., false, "Regular", false);

1754 verifyItem(4, 440., 390., false, "Mild", false);

1755 QCOMPARE(lvwph->m_minYExtent, 0.);

1756 QCOMPARE(lvwph->m_clipItem->y(), 140.);

1757 QCOMPARE(lvwph->m_clipItem->clip(), false);

1758 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1759 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1760 QCOMPARE(lvwph->contentY(), 140.);

1761 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1762 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1763 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

1764 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1765 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1766 }

1767

1768 void testMaximizeVisibleArea()

1769 {

1770 bool res = lvwph->maximizeVisibleArea(2);

1771 QVERIFY(res);

1772 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1773

1774 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1775 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1776 verifyItem(0, -278., 190., true, "Agressive", true);

1777 verifyItem(1, -88., 240., false, "Regular", true);

1778 verifyItem(2, 152, 390., false, "Mild", false);

1779 verifyItem(3, 542, 390., true, "Bold", true);

1780 QCOMPARE(lvwph->m_minYExtent, 0.);

1781 QCOMPARE(lvwph->m_clipItem->y(), 328.);

1782 QCOMPARE(lvwph->m_clipItem->clip(), false);

1783 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1784 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1785 QCOMPARE(lvwph->contentY(), 328.);

1786 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1787 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1788 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1789 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1790 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1791 }

1792

1793 void testMaximizeVisibleAreaVisibleItems()

1794 {

1795 bool res = lvwph->maximizeVisibleArea(0);

1796 QVERIFY(res);

1797 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1798

1799 verifyInitialTopPosition();

1800

1801 res = lvwph->maximizeVisibleArea(1);

1802 QVERIFY(res);

1803 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1804

1805 verifyInitialTopPosition();

1806 }

1807

1808 void testMaximizeVisibleAreaInvalidIndexes()

1809 {

1810 bool res = lvwph->maximizeVisibleArea(-1);

1811 QVERIFY(!res);

1812 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1813

1814 verifyInitialTopPosition();

1815

1816 res = lvwph->maximizeVisibleArea(1000);

1817 QVERIFY(!res);

1818 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1819

1820 verifyInitialTopPosition();

1821

1822 res = lvwph->maximizeVisibleArea(3);

1823 QVERIFY(!res);

1824 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1825

1826 verifyInitialTopPosition();

1827 }

1828

1829 void testMaximizeVisibleAreaBigElement()

1830 {

1831 model->setProperty(2, "size", 4000);

1832 verifyItem(2, 480, 4040., false, "Mild", false);

1833

1834 bool res = lvwph->maximizeVisibleArea(2);

1835 QVERIFY(res);

1836 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1837

1838 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1839 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1840 verifyItem(0, -430., 190., true, "Agressive", true);

1841 verifyItem(1, -240., 240., true, "Regular", true);

1842 verifyItem(2, 0, 4040., false, "Mild", false);

1843 QCOMPARE(lvwph->m_minYExtent, 0.);

1844 QCOMPARE(lvwph->m_clipItem->y(), 480.);

1845 QCOMPARE(lvwph->m_clipItem->clip(), false);

1846 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1847 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1848 QCOMPARE(lvwph->contentY(), 480.);

1849 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1850 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1851 }

1852

1853 void testMaximizeVisibleAreaScrollDown()

1854 {

1855 changeContentY(350);

1856 bool res = lvwph->maximizeVisibleArea(1);

1857 QVERIFY(res);

1858 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1859

1860 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1861 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1862 verifyItem(0, -190., 190., true, "Agressive", true);

1863 verifyItem(1, 0., 240., false, "Regular", false);

1864 verifyItem(2, 240, 390., false, "Mild", false);

1865 verifyItem(3, 630, 390., true, "Bold", true);

1866 QCOMPARE(lvwph->m_minYExtent, 0.);

1867 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1868 QCOMPARE(lvwph->m_clipItem->clip(), false);

1869 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1870 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1871 QCOMPARE(lvwph->contentY(), 240.);

1872 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1873 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1874 }

1875

1876 void testMaximizeVisibleAreaScrollDownBigElement()

1877 {

1878 model->setProperty(1, "size", 1000);

1879 changeContentY(1150);

1880 bool res = lvwph->maximizeVisibleArea(1);

1881 QVERIFY(res);

1882 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1883

1884 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1885 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1886 verifyItem(0, -498., 1040., false, "Regular", true);

1887 verifyItem(1, 542., 390., true, "Mild", true);

1888 QCOMPARE(lvwph->m_minYExtent, 525.);

1889 QCOMPARE(lvwph->m_clipItem->y(), 738.);

1890 QCOMPARE(lvwph->m_clipItem->clip(), false);

1891 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1892 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1893 QCOMPARE(lvwph->contentY(), 738.);

1894 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1895 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1896 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1897 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1898 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1899 }

1900

1901 void testMaximizeVisibleAreaBigElementInTheMiddle()

1902 {

1903 model->setProperty(1, "size", 1000);

1904 changeContentY(650);

1905

1906 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1907 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1908 verifyItem(0, -410., 1040., false, "Regular", true);

1909 verifyItem(1, 630., 390., true, "Mild", true);

1910 QCOMPARE(lvwph->m_minYExtent, 525.);

1911 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1912 QCOMPARE(lvwph->m_clipItem->clip(), false);

1913 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1914 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1915 QCOMPARE(lvwph->contentY(), 650.);

1916 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1917 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1918 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1919 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1920 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1921

1922 bool res = lvwph->maximizeVisibleArea(1);

1923 QVERIFY(res);

1924 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1925

1926 QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);

1927 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1928 verifyItem(0, -410., 1040., false, "Regular", true);

1929 verifyItem(1, 630., 390., true, "Mild", true);

1930 QCOMPARE(lvwph->m_minYExtent, 525.);

1931 QCOMPARE(lvwph->m_clipItem->y(), 650.);

1932 QCOMPARE(lvwph->m_clipItem->clip(), false);

1933 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1934 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1935 QCOMPARE(lvwph->contentY(), 650.);

1936 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1937 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1938 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1939 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

1940 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1941 }

1942

1943 void testMaximizeVisibleAreaTopWithHalfPageHeader()

1944 {

1945 changeContentY(430);

1946 changeContentY(-30);

1947

1948 bool res = lvwph->maximizeVisibleArea(1);

1949 QVERIFY(res);

1950 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1951

1952 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1953 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1954 verifyItem(0, -190., 190., true, "Agressive", true);

1955 verifyItem(1, 0., 240., false, "Regular", false);

1956 verifyItem(2, 240, 390., false, "Mild", false);

1957 verifyItem(3, 630, 390., true, "Bold", true);

1958 QCOMPARE(lvwph->m_minYExtent, 0.);

1959 QCOMPARE(lvwph->m_clipItem->y(), 240.);

1960 QCOMPARE(lvwph->m_clipItem->clip(), false);

1961 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1962 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1963 QCOMPARE(lvwph->contentY(), 240.);

1964 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1965 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1966 }

1967

1968 void testMaximizeVisibleAreaBottomWithHalfPageHeader()

1969 {

1970 changeContentY(430);

1971 changeContentY(-30);

1972

1973 bool res = lvwph->maximizeVisibleArea(3);

1974 QVERIFY(res);

1975 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

1976

1977 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1978 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1979 verifyItem(0, -478., 240., true, "Regular", true);

1980 verifyItem(1, -238., 390., false, "Mild", true);

1981 verifyItem(2, 152, 390., false, "Bold", false);

1982 verifyItem(3, 542, 350., true, QString(), true);

1983 QCOMPARE(lvwph->m_minYExtent, 152.5);

1984 QCOMPARE(lvwph->m_clipItem->y(), 718.);

1985 QCOMPARE(lvwph->m_clipItem->clip(), false);

1986 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1987 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1988 QCOMPARE(lvwph->contentY(), 718.);

1989 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1990 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1991 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1992 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[1]->m_item);

1993 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1994 }

1995

1996 void testMaximizeVisibleAreaTopSecondSectionItemStickySection()

1997 {

1998 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));

1999 changeContentY(250);

2000 bool res = lvwph->maximizeVisibleArea(1);

2001 QVERIFY(res);

2002 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2003

2004 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2005 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2006 verifyItem(0, -100., 140., false, "Agressive", true);

2007 verifyItem(1, 40., 150., false, QString(), true);

2008 verifyItem(2, 190, 240., false, "Regular", false);

2009 verifyItem(3, 430, 390., false, "Mild", false);

2010 QCOMPARE(lvwph->m_minYExtent, 0.);

2011 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2012 QCOMPARE(lvwph->m_clipItem->clip(), false);

2013 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2014 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2015 QCOMPARE(lvwph->contentY(), 150.);

2016 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2017 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2018 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2019 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

2020 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2021

2022 changeContentY(20);

2023 res = lvwph->maximizeVisibleArea(1);

2024 QVERIFY(res);

2025 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2026

2027 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

2028 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2029 verifyItem(0, -100., 140., false, "Agressive", true);

2030 verifyItem(1, 40., 150., false, QString(), true);

2031 verifyItem(2, 190, 240., false, "Regular", false);

2032 verifyItem(3, 430, 390., false, "Mild", false);

2033 QCOMPARE(lvwph->m_minYExtent, 0.);

2034 QCOMPARE(lvwph->m_clipItem->y(), 150.);

2035 QCOMPARE(lvwph->m_clipItem->clip(), false);

2036 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2037 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2038 QCOMPARE(lvwph->contentY(), 150.);

2039 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2040 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2041 QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));

2042 QCOMPARE(sectionDelegate(lvwph->m_topSectionItem), lvwph->m_visibleItems[0]->m_item);

2043 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

2044 }

2045

2046 void testMaximizeVisibleAreaWithItemResize()

2047 {

2048 model->setProperty(0, "size", 1000);

2049

2050 bool res = lvwph->maximizeVisibleArea(1);

2051 QVERIFY(res);

2052 QTRY_VERIFY(!lvwph->m_contentYAnimation->isRunning());

2053

2054 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

2055 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2056 verifyItem(0, -738., 1040., false, "Agressive", true);

2057 verifyItem(1, 302., 240., false, "Regular", false);

2058 verifyItem(2, 542, 390., true, "Mild", true);

2059 QCOMPARE(lvwph->m_minYExtent, 0.);

2060 QCOMPARE(lvwph->m_clipItem->y(), 788.);

2061 QCOMPARE(lvwph->m_clipItem->clip(), false);

2062 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2063 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2064 QCOMPARE(lvwph->contentY(), 788.);

2065 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2066 }

2067

2068 void addingRemoveItemsShouldNotChangeContentY()

2069 {

2070 QSignalSpy spy(lvwph, &ListViewWithPageHeader::contentYChanged);

2071 QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 150), Q_ARG(QVariant, "Agressive"));

2072 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 6));

2073

2074 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2075 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2076 verifyItem(0, 50., 190., false, "Agressive", false);

2077 QCOMPARE(lvwph->m_minYExtent, 0.);

2078 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2079 QCOMPARE(lvwph->m_clipItem->clip(), false);

2080 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2081 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2082 QCOMPARE(lvwph->contentY(), 0.);

2083 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2084

2085 QCOMPARE(spy.count(), 0);

2086 }

2087

2088 void testDownAndUp()

2089 {

2090 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2091

2092 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2093 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2094 verifyItem(0, 50., 190., false, "Agressive", false);

2095 QCOMPARE(lvwph->m_minYExtent, 0.);

2096 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2097 QCOMPARE(lvwph->m_clipItem->clip(), false);

2098 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2099 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2100 QCOMPARE(lvwph->contentY(), 0.);

2101 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2102 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2103

2104 QTest::qWait(1);

2105 QCoreApplication::instance()->processEvents();

2106

2107 changeContentY(-15);

2108

2109 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2110 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2111 verifyItem(0, 65., 190., false, "Agressive", false);

2112 QCOMPARE(lvwph->m_minYExtent, 0.);

2113 QCOMPARE(lvwph->m_clipItem->y(), -15.);

2114 QCOMPARE(lvwph->m_clipItem->clip(), false);

2115 QCOMPARE(lvwph->m_headerItem->y(), -15.);

2116 QCOMPARE(lvwph->m_headerItem->height(), 65.);

2117 QCOMPARE(lvwph->contentY(), -15.);

2118 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2119 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2120

2121 changeContentY(25);

2122

2123 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2124 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2125 verifyItem(0, 40., 190., false, "Agressive", false);

2126 QCOMPARE(lvwph->m_minYExtent, 0.);

2127 QCOMPARE(lvwph->m_clipItem->y(), 10.);

2128 QCOMPARE(lvwph->m_clipItem->clip(), false);

2129 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2130 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2131 QCOMPARE(lvwph->contentY(), 10.);

2132 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2133 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2134

2135

2136 QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));

2137

2138 QTRY_COMPARE(lvwph->m_visibleItems.count(), 1);

2139 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

2140 verifyItem(0, 50., 190., false, "Agressive", false);

2141 QCOMPARE(lvwph->m_minYExtent, 0.);

2142 QCOMPARE(lvwph->m_clipItem->y(), 0.);

2143 QCOMPARE(lvwph->m_clipItem->clip(), false);

2144 QCOMPARE(lvwph->m_headerItem->y(), 0.);

2145 QCOMPARE(lvwph->m_headerItem->height(), 50.);

2146 QCOMPARE(lvwph->contentY(), 0.);

2147 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

2148 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

2149 }

2150

2151 void changeSectionProperty()

2152 {

2153 model->setProperty(1, "type", "Rojo");

2154 verifyItem(1, 240., 240., false, "Rojo", false);

2155

2156 model->setProperty(1, "type", "Agressive");

2157 verifyItem(1, 240., 200., false, QString(), true);

2158

2159 model->setProperty(1, "type", "Rojo");

2160 verifyItem(1, 240., 240., false, "Rojo", false);

2161

2162 model->setProperty(1, "type", "Mild");

2163 verifyItem(1, 240., 240., false, "Mild", false);

2164 verifyItem(2, 480., 350., false, QString(), false);

2165

2166 model->setProperty(1, "type", "Rojo");

2167 verifyItem(1, 240., 240., false, "Rojo", false);

2168 verifyItem(2, 480., 390., false, "Mild", false);

2169

2170 model->setProperty(2, "type", "Agressive");

2171 verifyItem(2, 480., 390., false, "Agressive", false);

2172

2173 model->setProperty(1, "type", "Agressive");

2174 verifyItem(1, 240., 200., false, QString(), true);

2175 verifyItem(2, 440., 350., false, QString(), false);

2176

2177 model->setProperty(1, "type", "Rojo");

2178 verifyItem(1, 240., 240., false, "Rojo", false);

2179 verifyItem(2, 480., 390., false, "Agressive", false);

2180 }

2181

2182 void firstItemSectionHeightChange()

2183 {

2184 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 5));

2185 model->setProperty(0, "type", "halfheight");

2186 verifyItem(0, 50., 170., false, "halfheight", false);

2187 }

2188

2189 void secondItemSectionHeightChange()

2190 {

2191 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 2), Q_ARG(QVariant, 4));

2192 model->setProperty(1, "type", "halfheight");

2193 verifyItem(0, 50., 190., false, "Agressive", false);

2194 verifyItem(1, 240., 220., false, "halfheight", false);

2195 }

2196

2197 void testInvalidSectionDelegate()

2198 {

2199 lvwph->setProperty("useBrokenSectionDelegateComponent", true);

2200 scrollToBottom();

2201 }

2202

2203private:

2204 QQuickView *view;

2205 ListViewWithPageHeader *lvwph;

2206 QQmlListModel *model;

2207 QQmlComponent *otherDelegate;

2208};

2209

2210QTEST_MAIN(ListViewWithPageHeaderTestSection)

2211

2212#include "listviewwithpageheadersectiontest.moc"