tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp · unity8

git.iko.soy/unity8

on 46b72d9 help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp

1468 lines 66 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 <QtTestGui>

23#include <private/qquicklistmodel_p.h>

24#include <private/qquickanimation_p.h>

25#include <private/qquickitem_p.h>

27class ListViewWithPageHeaderTestSection : public QObject

28{

29 Q_OBJECT

31private:

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

33 {

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

35 ListViewWithPageHeader::ListItem *item = lvwph->m_visibleItems[visibleIndex];

36 QTRY_COMPARE(item->y(), pos);

37 QTRY_COMPARE(item->height(), height);

38 QCOMPARE(QQuickItemPrivate::get(item->m_item)->culled, culled);

39 QCOMPARE(section(item->m_sectionItem), sectionHeader);

40 if (!sectionHeader.isNull()) {

41 QCOMPARE(QQuickItemPrivate::get(item->m_sectionItem)->culled, sectionHeaderCulled);

42 }

43 }

45 void changeContentY(qreal change)

46 {

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

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

49 const qreal jump = 25;

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

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

52 QTest::qWait(1);

53 }

54 } else {

55 const qreal jump = -25;

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

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

58 QTest::qWait(1);

59 }

60 }

61 lvwph->setContentY(dest);

62 QTest::qWait(1);

63 }

65 void scrollToTop()

66 {

67 const qreal jump = -25;

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

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

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

71 } else {

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

73 }

74 QTest::qWait(1);

75 }

76 }

78 void scrollToBottom()

79 {

80 const qreal jump = 25;

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

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

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

84 } else {

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

86 }

87 QTest::qWait(1);

88 }

89 }

91 void verifyInitialTopPosition()

92 {

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

94 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

106 }

107

108 QString section(QQuickItem *item)

109 {

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

111 }

112

113private Q_SLOTS:

114

115 void initTestCase()

116 {

117 }

118

119 void init()

120 {

121 view = new QQuickView();

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

123 view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test_section.qml"));

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

125 model = view->rootObject()->findChild<QQuickListModel*>();

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

127 QVERIFY(lvwph);

128 QVERIFY(model);

129 QVERIFY(otherDelegate);

130 view->show();

131 QTest::qWaitForWindowExposed(view);

132

133 verifyInitialTopPosition();

134 }

135

136 void cleanup()

137 {

138 delete view;

139 }

140

141 void testCreationDeletion()

142 {

143 // Nothing, init/cleanup already tests this

144 }

145

146 void testDrag1PixelUp()

147 {

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

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

150 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

162 }

163

164 void testHeaderDetachDragDown()

165 {

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

167 QTest::qWait(100);

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

169 QTest::qWait(100);

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

171 QTest::qWait(100);

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

173 QTest::qWait(100);

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

175 QTest::qWait(100);

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

177 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

189

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

191

192 verifyInitialTopPosition();

193 }

194

195 void testDrag375PixelUp()

196 {

197 changeContentY(375);

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

199 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

214 }

215

216 void testDrag520PixelUp()

217 {

218 changeContentY(520);

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

220 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

225 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

235 }

236

237 void testDragHeaderUpThenShow()

238 {

239 changeContentY(120);

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

241 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

256

257 changeContentY(-30);

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

259 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

274 }

275

276 void testDragHeaderUpThenShowWithoutHidingTotally()

277 {

278 changeContentY(10);

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

280 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

292

293 changeContentY(-1);

294

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

296 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

308 }

309

310 void testPositionAtBeginningIndex0Visible()

311 {

312 changeContentY(375);

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

314 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

329

330 lvwph->positionAtBeginning();

331

332 verifyInitialTopPosition();

333 }

334

335 void testPositionAtBeginningIndex0NotVisible()

336 {

337 changeContentY(520);

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

339 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

344 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

354

355 lvwph->positionAtBeginning();

356

357 verifyInitialTopPosition();

358 }

359

360 void testIndex0GrowOnScreen()

361 {

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

363

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

365 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

377 }

378

379 void testIndex0GrowOffScreen()

380 {

381 changeContentY(375);

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

383 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

398

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

400

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

402 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

417

418 scrollToTop();

419

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

421 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

433

434 changeContentY(30);

435

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

437 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

449 }

450

451 void testIndex0GrowNotCreated()

452 {

453 changeContentY(520);

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

455 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

460 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

470

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

472

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

474 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

479 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

489

490 scrollToTop();

491

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

493 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

505 }

506

507 void testShowHideShowHeaderAtBottom()

508 {

509 scrollToBottom();

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

511 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

525

526 changeContentY(-30);

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

528 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

542

543 changeContentY(30);

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

545 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

559

560 changeContentY(-30);

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

562 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

576 }

577

578 void testChangeDelegateAtBottom()

579 {

580 scrollToBottom();

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

582 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

596

597 lvwph->setDelegate(otherDelegate);

598

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

600 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

615 }

616

617 void testSetEmptyHeaderAtTop()

618 {

619 lvwph->setHeader(nullptr);

620

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

622 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

633 }

634

635 void testSetEmptyHeaderAtBottom()

636 {

637 scrollToBottom();

638 lvwph->setHeader(nullptr);

639

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

641 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

654

655 scrollToTop();

656

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

658 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

669 }

670

671 void testSetEmptyHeaderWhenPartlyShownClipped()

672 {

673 scrollToBottom();

674 changeContentY(-30);

675 lvwph->setHeader(nullptr);

676

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

678 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

688 QTRY_VERIFY(lvwph->isAtYEnd());

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

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

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

692

693 scrollToTop();

694

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

696 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

707 }

708

709 void testSetEmptyHeaderWhenPartlyShownNotClipped()

710 {

711 changeContentY(30);

712 lvwph->setHeader(nullptr);

713

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

715 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

728 }

729

730 void testSetNullDelegate()

731 {

732 lvwph->setDelegate(nullptr);

733

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

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

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

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

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

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

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

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

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

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

744 QVERIFY(lvwph->isAtYBeginning());

745 QVERIFY(lvwph->isAtYEnd());

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

747 }

748

749 void testInsertItems()

750 {

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

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

753

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

755 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

769 }

770

771 void testInsertItemsStealSectionItem()

772 {

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

774

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

776 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

789 }

790

791

792 void testInsertItemsOnNotShownPosition()

793 {

794 changeContentY(800);

795

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

797 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

812

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

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

815

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

817 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

832

833 scrollToTop();

834

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

836 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

850 }

851

852 void testInsertItemsAtEndOfViewport()

853 {

854 changeContentY(60);

855

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

857 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

872

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

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

875

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

877 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

892 }

893

894 void testInsertItemsBeforeValidIndex()

895 {

896 changeContentY(520);

897

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

899 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

904 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

914

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

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

917

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

919 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

924 QCOMPARE(lvwph->m_minYExtent, 837.5);

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

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

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

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

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

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

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

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

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

934 }

935

936 void testInsertItemsBeforeViewport()

937 {

938 changeContentY(375);

939

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

941 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

956

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

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

959

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

961 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

976

977 scrollToTop();

978

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

980 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

994 }

995

996 void testInsertItemsAtBottom()

997 {

998 scrollToBottom();

999

1000 QVERIFY(lvwph->isAtYEnd());

1001

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

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

1004

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

1006 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1023

1024 scrollToBottom();

1025

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

1027 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

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

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

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

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

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

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

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

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

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

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

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

1039 QVERIFY(lvwph->isAtYEnd());

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

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

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

1043 }

1044

1045 void testInsertItemAtTop()

1046 {

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

1048

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

1050 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

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

1062 QVERIFY(lvwph->isAtYBeginning());

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

1064 }

1065

1066 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1067 {

1068 scrollToBottom();

1069

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

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

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

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

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

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

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

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

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

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

1080

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

1082 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

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

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

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

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

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

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

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

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

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

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

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

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

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

1096

1097 changeContentY(-1700);

1098

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

1100 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

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

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

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

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

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

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

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

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

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

1110 QCOMPARE(lvwph->m_minYExtent, 980.5);

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

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

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

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

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

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

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

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

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

1120 }

1121

1122 void testRemoveItemsAtTop()

1123 {

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

1125

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

1127 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

1137 QVERIFY(lvwph->isAtYBeginning());

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

1139 }

1140

1141 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1142 {

1143 scrollToBottom();

1144

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

1146

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

1148 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

1162 }

1163

1164 void testRemoveLastItemsAtBottom()

1165 {

1166 scrollToBottom();

1167

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

1169

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

1171 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

1185 }

1186

1187 void testRemoveItemOutOfViewport()

1188 {

1189 changeContentY(520);

1190

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

1192 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

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

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

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

1197 QCOMPARE(lvwph->m_minYExtent, 152.5);

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

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

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

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

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

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

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

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

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

1207

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

1209

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

1211 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

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

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

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

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

1216 QCOMPARE(lvwph->m_minYExtent, -240.);

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

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

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

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

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

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

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

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

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

1226 }

1227

1228 void testRemoveFirstOfCategory()

1229 {

1230 changeContentY(520);

1231

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

1233 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

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

1235 verifyItem(1, -40, 390., false, "Mild", true);

1236 verifyItem(2, 350, 390., false, "Bold", false);

1237 verifyItem(3, 740, 350., true, QString(), true);

1238 QCOMPARE(lvwph->m_minYExtent, 152.5);

1239 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1240 QCOMPARE(lvwph->m_clipItem->clip(), false);

1241 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1242 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1243 QCOMPARE(lvwph->contentY(), 520.);

1244 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1245 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1246 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1247 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1248

1249 QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));

1250

1251 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1252 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1253 verifyItem(0, -280., 240., true, "Regular", true);

1254 verifyItem(1, -40, 390., false, "Mild", true);

1255 verifyItem(2, 350, 390., false, "Bold", false);

1256 verifyItem(3, 740, 390., true, "Lazy", true);

1257 QCOMPARE(lvwph->m_minYExtent, 162.5);

1258 QCOMPARE(lvwph->m_clipItem->y(), 520.);

1259 QCOMPARE(lvwph->m_clipItem->clip(), false);

1260 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1261 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1262 QCOMPARE(lvwph->contentY(), 520.);

1263 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1264 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1265 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1266 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1267 }

1268

1269 void testMoveFirstItems()

1270 {

1271 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1272

1273 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1274 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1275 verifyItem(0, 50., 240., false, "Regular", false);

1276 verifyItem(1, 290., 190., false, "Agressive", false);

1277 verifyItem(2, 480., 390., false, "Mild", false);

1278 QCOMPARE(lvwph->m_minYExtent, 0.);

1279 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1280 QCOMPARE(lvwph->m_clipItem->clip(), false);

1281 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1282 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1283 QCOMPARE(lvwph->contentY(), 0.);

1284 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1285 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1286 }

1287

1288 void testMoveFirstOutOfVisibleItems()

1289 {

1290 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1291

1292 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1293 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1294 verifyItem(0, 50., 240., false, "Regular", false);

1295 verifyItem(1, 290., 390., false, "Mild", false);

1296 verifyItem(2, 680., 390., true, "Bold", true);

1297 QCOMPARE(lvwph->m_minYExtent, 0.);

1298 QCOMPARE(lvwph->m_clipItem->y(), 0.);

1299 QCOMPARE(lvwph->m_clipItem->clip(), false);

1300 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1301 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1302 QCOMPARE(lvwph->contentY(), 0.);

1303 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1304 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1305 }

1306

1307 void testMoveFirstToLastAtBottom()

1308 {

1309 scrollToBottom();

1310

1311 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1312 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1313 verifyItem(0, -588., 390., true, "Bold", true);

1314 verifyItem(1, -198, 350., false, QString(), true);

1315 verifyItem(2, 152, 390., false, "Lazy", false);

1316 QCOMPARE(lvwph->m_minYExtent, 310.);

1317 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1318 QCOMPARE(lvwph->m_clipItem->clip(), false);

1319 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1320 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1321 QCOMPARE(lvwph->contentY(), 1458.);

1322 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1323 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1324 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1325 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1326

1327 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1328

1329 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1330 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1331 verifyItem(0, -588., 390., true, "Bold", true);

1332 verifyItem(1, -198, 350., false, QString(), true);

1333 verifyItem(2, 152, 390., false, "Lazy", false);

1334 verifyItem(3, 542, 190., true, "Agressive", true);

1335 QCOMPARE(lvwph->m_minYExtent, -160.);

1336 QCOMPARE(lvwph->m_clipItem->y(), 1458.);

1337 QCOMPARE(lvwph->m_clipItem->clip(), false);

1338 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1339 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1340 QCOMPARE(lvwph->contentY(), 1458.);

1341 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1342 QVERIFY(!lvwph->isAtYEnd());

1343 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1344 QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));

1345 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1346 }

1347

1348 void testChangeSizeVisibleItemNotOnViewport()

1349 {

1350 changeContentY(490);

1351

1352 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1353 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1354 verifyItem(0, -440., 190., true, "Agressive", true);

1355 verifyItem(1, -250., 240., true, "Regular", true);

1356 verifyItem(2, -10, 390., false, "Mild", true);

1357 verifyItem(3, 380, 390., false, "Bold", false);

1358 verifyItem(4, 770, 350., true, QString(), true);

1359 QCOMPARE(lvwph->m_minYExtent, 0.);

1360 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1361 QCOMPARE(lvwph->m_clipItem->clip(), false);

1362 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1363 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1364 QCOMPARE(lvwph->contentY(), 490.);

1365 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1366 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1367 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1368 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1369

1370 model->setProperty(1, "size", 100);

1371

1372 QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);

1373 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1374 verifyItem(0, -340., 190., true, "Agressive", true);

1375 verifyItem(1, -150., 140., true, "Regular", true);

1376 verifyItem(2, -10, 390., false, "Mild", true);

1377 verifyItem(3, 380, 390., false, "Bold", false);

1378 verifyItem(4, 770, 350., true, QString(), true);

1379 QCOMPARE(lvwph->m_minYExtent, -100.);

1380 QCOMPARE(lvwph->m_clipItem->y(), 490.);

1381 QCOMPARE(lvwph->m_clipItem->clip(), false);

1382 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1383 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1384 QCOMPARE(lvwph->contentY(), 490.);

1385 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1386 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1387 QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));

1388 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1389 }

1390

1391 void testShowHeaderCloseToTheTop()

1392 {

1393 changeContentY(375);

1394

1395 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1396 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1397 verifyItem(0, -325., 190., true, "Agressive", true);

1398 verifyItem(1, -135, 240., false, "Regular", true);

1399 verifyItem(2, 105, 390., false, "Mild", false);

1400 verifyItem(3, 495, 390., false, "Bold", false);

1401 QCOMPARE(lvwph->m_minYExtent, 0.);

1402 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1403 QCOMPARE(lvwph->m_clipItem->clip(), false);

1404 QCOMPARE(lvwph->m_headerItem->y(), 0.);

1405 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1406 QCOMPARE(lvwph->contentY(), 375.);

1407 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;

1408 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1409 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1410 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1411

1412 lvwph->showHeader();

1413

1414 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1415 QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);

1416 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1417 verifyItem(0, -375., 190., true, "Agressive", true);

1418 verifyItem(1, -185, 240., false, "Regular", true);

1419 verifyItem(2, 55, 390., false, "Mild", false);

1420 verifyItem(3, 445, 390., false, "Bold", false);

1421 QCOMPARE(lvwph->m_minYExtent, 50.);

1422 QCOMPARE(lvwph->m_clipItem->y(), 375.);

1423 QCOMPARE(lvwph->m_clipItem->clip(), true);

1424 QCOMPARE(lvwph->m_headerItem->y(), 325.);

1425 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1426 QCOMPARE(lvwph->contentY(), 325.);

1427 QCOMPARE(lvwph->m_headerItemShownHeight, 50.);

1428 QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1429 QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));

1430 QCOMPARE(lvwph->m_topSectionItem->y(), 0.);

1431

1432 scrollToTop();

1433

1434 QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);

1435 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1436 verifyItem(0, 50., 190., false, "Agressive", false);

1437 verifyItem(1, 240., 240., false, "Regular", false);

1438 verifyItem(2, 480., 390., false, "Mild", false);

1439 QCOMPARE(lvwph->m_minYExtent, 50.);

1440 QCOMPARE(lvwph->m_clipItem->y(), -50.);

1441 QCOMPARE(lvwph->m_clipItem->clip(), false);

1442 QCOMPARE(lvwph->m_headerItem->y(), -50.);

1443 QCOMPARE(lvwph->m_headerItem->height(), 50.);

1444 QCOMPARE(lvwph->contentY(), -50.);

1445 QCOMPARE(lvwph->m_headerItemShownHeight, 0.);

1446 QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);

1447 }

1448

1449 void testShowHeaderAtBottom()

1450 {

1451 scrollToBottom();

1452

1453 lvwph->showHeader();

1454

1455 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

1456 QVERIFY (lvwph->isAtYEnd());

1457 }

1458

1459private:

1460 QQuickView *view;

1461 ListViewWithPageHeader *lvwph;

1462 QQuickListModel *model;

1463 QQmlComponent *otherDelegate;

1464};

1465

1466QTEST_MAIN(ListViewWithPageHeaderTestSection)

1467

1468#include "listviewwithpageheadertestsection.moc"