tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp · unity8

git.iko.soy/unity8

on 90e24ca help sign in

unity8/tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp

1532 lines 60 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 ListViewWithPageHeaderTest : public QObject

28{

29 Q_OBJECT

31private Q_SLOTS:

33 void initTestCase()

34 {

35 }

37 void init()

38 {

39 view = new QQuickView();

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

41 view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test.qml"));

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

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

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

45 QVERIFY(lvwph);

46 QVERIFY(model);

47 QVERIFY(otherDelegate);

48 view->show();

49 QTest::qWaitForWindowExposed(view);

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

52 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

53 verifyItem(0, 50., 150., false);

54 verifyItem(1, 200., 200., false);

55 verifyItem(2, 400., 350., false);

56 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

64 }

66 void cleanup()

67 {

68 delete view;

69 }

71 void verifyItem(int visibleIndex, qreal pos, qreal height, bool culled)

72 {

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

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

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

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

77 }

79 void changeContentY(qreal change)

80 {

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

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

83 const qreal jump = 25;

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

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

86 QTest::qWait(0);

87 }

88 } else {

89 const qreal jump = -25;

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

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

92 QTest::qWait(0);

93 }

94 }

95 lvwph->setContentY(dest);

96 QTest::qWait(0);

97 }

99 void scrollToTop()

100 {

101 const qreal jump = -25;

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

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

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

105 } else {

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

107 }

108 QTest::qWait(0);

109 }

110 }

111

112 void scrollToBottom()

113 {

114 const qreal jump = 25;

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

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

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

118 } else {

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

120 }

121 QTest::qWait(0);

122 }

123 }

124

125 void testCreationDeletion()

126 {

127 // Nothing, init/cleanup already tests this

128 }

129

130 void testDrag1PixelUp()

131 {

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

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

134 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

135 verifyItem(0, 49., 150., false);

136 verifyItem(1, 199., 200., false);

137 verifyItem(2, 399., 350., false);

138 verifyItem(3, 749., 350., true);

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

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

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

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

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

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

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

146 }

147

148 void testHeaderDetachDragDown()

149 {

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

151 QTest::qWait(100);

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

153 QTest::qWait(100);

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

155 QTest::qWait(100);

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

157 QTest::qWait(100);

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

159 QTest::qWait(100);

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

161 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

162 verifyItem(0, 55., 150., false);

163 verifyItem(1, 205., 200., false);

164 verifyItem(2, 405., 350., false);

165 verifyItem(3, 755., 350., true);

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

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

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

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

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

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

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

173

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

175

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

177 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

178 verifyItem(0, 50., 150., false);

179 verifyItem(1, 200., 200., false);

180 verifyItem(2, 400., 350., false);

181 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

189 }

190

191 void testDrag375PixelUp()

192 {

193 changeContentY(375);

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

195 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

196 verifyItem(0, -325., 150., true);

197 verifyItem(1, -175, 200., false);

198 verifyItem(2, 25, 350., false);

199 verifyItem(3, 375, 350., false);

200 verifyItem(4, 725, 350., true);

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

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

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

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

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

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

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

208 }

209

210 void testDrag520PixelUp()

211 {

212 changeContentY(520);

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

214 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

215 verifyItem(0, -320., 200., true);

216 verifyItem(1, -120, 350., false);

217 verifyItem(2, 230, 350., false);

218 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

226 }

227

228 void testDragHeaderUpThenShow()

229 {

230 changeContentY(120);

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

232 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

233 verifyItem(0, -70., 150., false);

234 verifyItem(1, 80., 200., false);

235 verifyItem(2, 280., 350., false);

236 verifyItem(3, 630., 350., true);

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

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

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

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

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

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

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

244

245 changeContentY(-30);

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

247 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

248 verifyItem(0, -70., 150., false);

249 verifyItem(1, 80., 200., false);

250 verifyItem(2, 280., 350., false);

251 verifyItem(3, 630., 350., true);

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

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

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

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

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

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

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

259 }

260

261 void testDragHeaderUpThenShowWithoutHidingTotally()

262 {

263 changeContentY(10);

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

265 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

266 verifyItem(0, 40., 150., false);

267 verifyItem(1, 190., 200., false);

268 verifyItem(2, 390., 350., false);

269 verifyItem(3, 740., 350., true);

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

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

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

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

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

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

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

277

278 changeContentY(-1);

279

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

281 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

282 verifyItem(0, 41., 150., false);

283 verifyItem(1, 191., 200., false);

284 verifyItem(2, 391., 350., false);

285 verifyItem(3, 741., 350., true);

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

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

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

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

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

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

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

293 }

294

295 void testPositionAtBeginningIndex0Visible()

296 {

297 changeContentY(375);

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

299 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

300 verifyItem(0, -325., 150., true);

301 verifyItem(1, -175, 200., false);

302 verifyItem(2, 25, 350., false);

303 verifyItem(3, 375, 350., false);

304 verifyItem(4, 725, 350., true);

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

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

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

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

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

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

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

312

313 lvwph->positionAtBeginning();

314

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

316 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

317 verifyItem(0, 50., 150., false);

318 verifyItem(1, 200., 200., false);

319 verifyItem(2, 400., 350., false);

320 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

328 }

329

330 void testPositionAtBeginningIndex0NotVisible()

331 {

332 changeContentY(520);

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

334 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

335 verifyItem(0, -320., 200., true);

336 verifyItem(1, -120, 350., false);

337 verifyItem(2, 230, 350., false);

338 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

346

347 lvwph->positionAtBeginning();

348

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

350 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

351 verifyItem(0, 50., 150., false);

352 verifyItem(1, 200., 200., false);

353 verifyItem(2, 400., 350., false);

354 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

362 }

363

364 void testIndex0GrowOnScreen()

365 {

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

367 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

368 verifyItem(0, 50., 150., false);

369 verifyItem(1, 200., 200., false);

370 verifyItem(2, 400., 350., false);

371 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

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., 400., false);

385 verifyItem(1, 450., 200., false);

386 verifyItem(2, 650., 350., 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 }

395

396 void testIndex0GrowOffScreen()

397 {

398 changeContentY(375);

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

400 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

401 verifyItem(0, -325., 150., true);

402 verifyItem(1, -175, 200., false);

403 verifyItem(2, 25, 350., false);

404 verifyItem(3, 375, 350., false);

405 verifyItem(4, 725, 350., true);

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

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

415

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

417 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

418 verifyItem(0, -575., 400., true);

419 verifyItem(1, -175, 200., false);

420 verifyItem(2, 25, 350., false);

421 verifyItem(3, 375, 350., false);

422 verifyItem(4, 725, 350., true);

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

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

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

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

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

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

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

430

431 scrollToTop();

432

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

434 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

435 verifyItem(0, 50., 400., false);

436 verifyItem(1, 450, 200., false);

437 verifyItem(2, 650, 350., true);

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

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

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

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

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

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

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

445

446 changeContentY(30);

447

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

449 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

450 verifyItem(0, 20., 400., false);

451 verifyItem(1, 420, 200., false);

452 verifyItem(2, 620, 350., true);

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

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

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

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

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

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

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

460 }

461

462 void testIndex0GrowNotCreated()

463 {

464 changeContentY(520);

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

466 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

467 verifyItem(0, -320., 200., true);

468 verifyItem(1, -120, 350., false);

469 verifyItem(2, 230, 350., false);

470 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

478

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

480

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

482 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

483 verifyItem(0, -320., 200., true);

484 verifyItem(1, -120, 350., false);

485 verifyItem(2, 230, 350., false);

486 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

494

495 scrollToTop();

496

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

498 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

499 verifyItem(0, 50., 400., false);

500 verifyItem(1, 450, 200., false);

501 verifyItem(2, 650, 350., true);

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

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

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

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

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

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

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

509 }

510

511 void testShowHideShowHeaderAtBottom()

512 {

513 scrollToBottom();

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

515 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

516 verifyItem(0, -508., 350., true);

517 verifyItem(1, -158, 350., false);

518 verifyItem(2, 192, 350., false);

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

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

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

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

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

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

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

526

527 changeContentY(-30);

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

529 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

530 verifyItem(0, -508., 350., true);

531 verifyItem(1, -158, 350., false);

532 verifyItem(2, 192, 350., false);

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

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

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

536 QCOMPARE(lvwph->m_headerItem->y(), 1208.);

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

538 QCOMPARE(lvwph->contentY(), 1228.);

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

540

541 changeContentY(30);

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

543 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

544 verifyItem(0, -508., 350., true);

545 verifyItem(1, -158, 350., false);

546 verifyItem(2, 192, 350., false);

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

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

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

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

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

552 QCOMPARE(lvwph->contentY(), 1258.);

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

554

555 changeContentY(-30);

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

557 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

558 verifyItem(0, -508., 350., true);

559 verifyItem(1, -158, 350., false);

560 verifyItem(2, 192, 350., false);

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

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

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

564 QCOMPARE(lvwph->m_headerItem->y(), 1208.);

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

566 QCOMPARE(lvwph->contentY(), 1228.);

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

568 }

569

570 void testChangeDelegateAtBottom()

571 {

572 scrollToBottom();

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

574 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

575 verifyItem(0, -508., 350., true);

576 verifyItem(1, -158, 350., false);

577 verifyItem(2, 192, 350., false);

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

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

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

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

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

583 QCOMPARE(lvwph->contentY(), 1258.);

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

585

586 lvwph->setDelegate(otherDelegate);

587

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

589 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

590 verifyItem(0, 50., 35., false);

591 verifyItem(1, 85, 35., false);

592 verifyItem(2, 120, 35., false);

593 verifyItem(3, 155, 35., false);

594 verifyItem(4, 190, 35., false);

595 verifyItem(5, 225, 35., false);

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

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

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

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

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

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

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

603 }

604

605 void testGrowHeaderAtTop()

606 {

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

608 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

609 verifyItem(0, 50., 150., false);

610 verifyItem(1, 200., 200., false);

611 verifyItem(2, 400., 350., false);

612 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

620

621 lvwph->m_headerItem->setHeight(100);

622

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

624 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

625 verifyItem(0, 100., 150., false);

626 verifyItem(1, 250., 200., false);

627 verifyItem(2, 450., 350., false);

628 verifyItem(3, 800., 350., true);

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

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

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

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

633 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

636 }

637

638 void testGrowHeaderAtBottom()

639 {

640 scrollToBottom();

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

642 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

643 verifyItem(0, -508., 350., true);

644 verifyItem(1, -158, 350., false);

645 verifyItem(2, 192, 350., false);

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

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

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

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

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

651 QCOMPARE(lvwph->contentY(), 1258.);

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

653

654 lvwph->m_headerItem->setHeight(100);

655

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

657 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

658 verifyItem(0, -508., 350., true);

659 verifyItem(1, -158, 350., false);

660 verifyItem(2, 192, 350., false);

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

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

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

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

665 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

668

669 changeContentY(-30);

670

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

672 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

673 verifyItem(0, -508., 350., true);

674 verifyItem(1, -158, 350., false);

675 verifyItem(2, 192, 350., false);

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

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

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

679 QCOMPARE(lvwph->m_headerItem->y(), 1158.);

680 QCOMPARE(lvwph->m_headerItem->height(), 100.);

681 QCOMPARE(lvwph->contentY(), 1228.);

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

683

684

685 scrollToTop();

686

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

688 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

689 verifyItem(0, 100., 150., false);

690 verifyItem(1, 250., 200., false);

691 verifyItem(2, 450., 350., false);

692 verifyItem(3, 800., 350., true);

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

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

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

696 QCOMPARE(lvwph->m_headerItem->y(), -50.);

697 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

700 }

701

702 void testGrowHeaderPartlyShown()

703 {

704 scrollToBottom();

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

706 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

707 verifyItem(0, -508., 350., true);

708 verifyItem(1, -158, 350., false);

709 verifyItem(2, 192, 350., false);

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

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

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

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

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

715 QCOMPARE(lvwph->contentY(), 1258.);

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

717

718 changeContentY(-30);

719

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

721 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

722 verifyItem(0, -508., 350., true);

723 verifyItem(1, -158, 350., false);

724 verifyItem(2, 192, 350., false);

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

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

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

728 QCOMPARE(lvwph->m_headerItem->y(), 1208.);

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

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

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

732

733 lvwph->m_headerItem->setHeight(100);

734

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

736 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

737 verifyItem(0, -508., 350., true);

738 verifyItem(1, -158, 350., false);

739 verifyItem(2, 192, 350., false);

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

741 QCOMPARE(lvwph->m_clipItem->y(), 1308.);

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

743 QCOMPARE(lvwph->m_headerItem->y(), 1208.);

744 QCOMPARE(lvwph->m_headerItem->height(), 100.);

745 QCOMPARE(lvwph->contentY(), 1228.);

746 QCOMPARE(lvwph->m_headerItemShownHeight, 80.);

747

748 scrollToTop();

749

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

751 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

752 verifyItem(0, 100., 150., false);

753 verifyItem(1, 250., 200., false);

754 verifyItem(2, 450., 350., false);

755 verifyItem(3, 800., 350., true);

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

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

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

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

760 QCOMPARE(lvwph->m_headerItem->height(), 100.);

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

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

763 }

764

765 void testShrinkHeaderMoreThanPartlyShown()

766 {

767 scrollToBottom();

768 lvwph->m_headerItem->setHeight(100);

769 changeContentY(-30);

770

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

772 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

773 verifyItem(0, -508., 350., true);

774 verifyItem(1, -158, 350., false);

775 verifyItem(2, 192, 350., false);

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

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

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

779 QCOMPARE(lvwph->m_headerItem->y(), 1158.);

780 QCOMPARE(lvwph->m_headerItem->height(), 100.);

781 QCOMPARE(lvwph->contentY(), 1228.);

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

783

784 lvwph->m_headerItem->setHeight(50);

785

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

787 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

788 verifyItem(0, -508., 350., true);

789 verifyItem(1, -158, 350., false);

790 verifyItem(2, 192, 350., false);

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

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

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

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

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

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

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

798 QTRY_VERIFY(lvwph->isAtYEnd());

799

800 scrollToTop();

801

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

803 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

804 verifyItem(0, 50., 150., false);

805 verifyItem(1, 200., 200., false);

806 verifyItem(2, 400., 350., false);

807 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

815 }

816

817 void testSetEmptyHeaderAtTop()

818 {

819 lvwph->setHeader(nullptr);

820

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

822 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

823 verifyItem(0, 0., 150., false);

824 verifyItem(1, 150., 200., false);

825 verifyItem(2, 350., 350., false);

826 verifyItem(3, 700., 350., true);

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

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

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

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

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

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

833 }

834

835 void testSetEmptyHeaderAtBottom()

836 {

837 scrollToBottom();

838 lvwph->setHeader(nullptr);

839

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

841 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

842 verifyItem(0, -508., 350., true);

843 verifyItem(1, -158, 350., false);

844 verifyItem(2, 192, 350., false);

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

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

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

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

849 QCOMPARE(lvwph->contentY(), 1258.);

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

851

852 scrollToTop();

853

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

855 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

856 verifyItem(0, 0., 150., false);

857 verifyItem(1, 150., 200., false);

858 verifyItem(2, 350., 350., false);

859 verifyItem(3, 700., 350., true);

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

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

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

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

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

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

866 }

867

868 void testSetEmptyHeaderWhenPartlyShownClipped()

869 {

870 scrollToBottom();

871 changeContentY(-30);

872 lvwph->setHeader(nullptr);

873

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

875 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

876 verifyItem(0, -508., 350., true);

877 verifyItem(1, -158, 350., false);

878 verifyItem(2, 192, 350., false);

879 QCOMPARE(lvwph->m_minYExtent, -720.);

880 QCOMPARE(lvwph->m_clipItem->y(), 1228.);

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

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

883 QCOMPARE(lvwph->contentY(), 1228.);

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

885 QTRY_VERIFY(lvwph->isAtYEnd());

886

887 scrollToTop();

888

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

890 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

891 verifyItem(0, 0., 150., false);

892 verifyItem(1, 150., 200., false);

893 verifyItem(2, 350., 350., false);

894 verifyItem(3, 700., 350., true);

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

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

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

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

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

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

901 }

902

903 void testSetEmptyHeaderWhenPartlyShownNotClipped()

904 {

905 changeContentY(30);

906 lvwph->setHeader(nullptr);

907

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

909 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

910 verifyItem(0, -30., 150., false);

911 verifyItem(1, 120., 200., false);

912 verifyItem(2, 320., 350., false);

913 verifyItem(3, 670., 350., true);

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

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

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

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

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

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

920 }

921

922 void testSetNullDelegate()

923 {

924 lvwph->setDelegate(nullptr);

925

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

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

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

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

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

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

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

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

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

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

936 QVERIFY(lvwph->isAtYBeginning());

937 QVERIFY(lvwph->isAtYEnd());

938 }

939

940 void testInsertItems()

941 {

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

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

944

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

946 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

947 verifyItem(0, 50., 150., false);

948 verifyItem(1, 200., 125., false);

949 verifyItem(2, 325., 100., false);

950 verifyItem(3, 425., 200., false);

951 verifyItem(4, 625., 350., true);

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

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

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

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

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

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

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

959 }

960

961 void testInsertItemsOnNotShownPosition()

962 {

963 changeContentY(700);

964

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

966 QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);

967 verifyItem(0, -300., 350., false);

968 verifyItem(1, 50, 350., false);

969 verifyItem(2, 400, 350., false);

970 verifyItem(3, 750, 350., true);

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

972 QCOMPARE(lvwph->m_clipItem->y(), 700.);

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

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

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

976 QCOMPARE(lvwph->contentY(), 700.);

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

978

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

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

981

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

983 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

984 verifyItem(0, -300., 350., false);

985 verifyItem(1, 50, 350., false);

986 verifyItem(2, 400, 350., false);

987 verifyItem(3, 750, 350., true);

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

989 QCOMPARE(lvwph->m_clipItem->y(), 700.);

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

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

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

993 QCOMPARE(lvwph->contentY(), 700.);

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

995

996 scrollToTop();

997

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

999 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1000 verifyItem(0, 50., 150., false);

1001 verifyItem(1, 200., 125., false);

1002 verifyItem(2, 325., 100., false);

1003 verifyItem(3, 425., 200., false);

1004 verifyItem(4, 625., 350., true);

1005 QTRY_COMPARE(lvwph->m_minYExtent, 225.);

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

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

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

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

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

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

1012 }

1013

1014 void testInsertItemsAtEndOfViewport()

1015 {

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

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

1018

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

1020 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1021 verifyItem(0, 50., 150., false);

1022 verifyItem(1, 200., 200., false);

1023 verifyItem(2, 400., 350., false);

1024 verifyItem(3, 750., 125., true);

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

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

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

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

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

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

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

1032 }

1033

1034 void testInsertItemsBeforeValidIndex()

1035 {

1036 changeContentY(520);

1037

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

1039 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1040 verifyItem(0, -320., 200., true);

1041 verifyItem(1, -120, 350., false);

1042 verifyItem(2, 230, 350., false);

1043 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

1051

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

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

1054

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

1056 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1057 verifyItem(0, -320., 200., true);

1058 verifyItem(1, -120, 350., false);

1059 verifyItem(2, 230, 350., false);

1060 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

1068 }

1069

1070 void testInsertItemsBeforeViewport()

1071 {

1072 changeContentY(375);

1073

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

1075 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1076 verifyItem(0, -325., 150., true);

1077 verifyItem(1, -175, 200., false);

1078 verifyItem(2, 25, 350., false);

1079 verifyItem(3, 375, 350., false);

1080 verifyItem(4, 725, 350., true);

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

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

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

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

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

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

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

1088

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

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

1091

1092 int i = 0;

1093 while(i < 10 && lvwph->m_visibleItems.count() != 5) {

1094 qDebug() << "Loop" << i;

1095 Q_FOREACH(ListViewWithPageHeader::ListItem *item, lvwph->m_visibleItems)

1096 qDebug() << item->m_item;

1097 QTest::qWait(1000);

1098 ++i;

1099 }

1100 qDebug() << "Before compare";

1101 Q_FOREACH(ListViewWithPageHeader::ListItem *item, lvwph->m_visibleItems)

1102 qDebug() << item->m_item;

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

1104 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1105 verifyItem(0, -275., 100., true);

1106 verifyItem(1, -175, 200., false);

1107 verifyItem(2, 25, 350., false);

1108 verifyItem(3, 375, 350., false);

1109 verifyItem(4, 725, 350., true);

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

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

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

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

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

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

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

1117

1118 scrollToTop();

1119

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

1121 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1122 verifyItem(0, 50., 150., false);

1123 verifyItem(1, 200., 125., false);

1124 verifyItem(2, 325., 100., false);

1125 verifyItem(3, 425., 200., false);

1126 verifyItem(4, 625., 350., true);

1127 QCOMPARE(lvwph->m_minYExtent, 225.);

1128 QCOMPARE(lvwph->m_clipItem->y(), -225.);

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

1130 QCOMPARE(lvwph->m_headerItem->y(), -225.);

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

1132 QCOMPARE(lvwph->contentY(), -225.);

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

1134 }

1135

1136 void testInsertItemsAtBottom()

1137 {

1138 scrollToBottom();

1139

1140 QVERIFY(lvwph->isAtYEnd());

1141

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

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

1144

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

1146 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1147 verifyItem(0, -508., 350., true);

1148 verifyItem(1, -158, 350., false);

1149 verifyItem(2, 192, 350., false);

1150 verifyItem(3, 542, 125., true);

1151 verifyItem(4, 667, 100., true);

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

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

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(), 1258.);

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

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

1160

1161 scrollToBottom();

1162

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

1164 QCOMPARE(lvwph->m_firstVisibleIndex, 4);

1165 verifyItem(0, -383., 350., true);

1166 verifyItem(1, -33, 350., false);

1167 verifyItem(2, 317, 125., false);

1168 verifyItem(3, 442, 100., false);

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

1170 QCOMPARE(lvwph->m_clipItem->y(), 1483.);

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

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

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

1174 QCOMPARE(lvwph->contentY(), 1483.);

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

1176 QVERIFY(lvwph->isAtYEnd());

1177 }

1178

1179 void testInsertItemAtTop()

1180 {

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

1182

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

1184 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1185 verifyItem(0, 50., 75., false);

1186 verifyItem(1, 125., 150., false);

1187 verifyItem(2, 275., 200., false);

1188 verifyItem(3, 475., 350., false);

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

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

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

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

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

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

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

1196 QVERIFY(lvwph->isAtYBeginning());

1197 }

1198

1199 void testInsertItem10SmallItemsAtTopWhenAtBottom()

1200 {

1201 scrollToBottom();

1202

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

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

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

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

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

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

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

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

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

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

1213

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

1215 QCOMPARE(lvwph->m_firstVisibleIndex, 13);

1216 verifyItem(0, -508., 350., true);

1217 verifyItem(1, -158, 350., false);

1218 verifyItem(2, 192, 350., false);

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

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

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

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

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

1224 QCOMPARE(lvwph->contentY(), 1258.);

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

1226

1227 changeContentY(-1700);

1228

1229 int i = 0;

1230 while(i < 10 && lvwph->m_visibleItems.count() != 12) {

1231 qDebug() << "Loop" << i;

1232 Q_FOREACH(ListViewWithPageHeader::ListItem *item, lvwph->m_visibleItems)

1233 qDebug() << item->m_item;

1234 QTest::qWait(1000);

1235 ++i;

1236 }

1237 qDebug() << "Before compare";

1238 Q_FOREACH(ListViewWithPageHeader::ListItem *item, lvwph->m_visibleItems)

1239 qDebug() << item->m_item;

1240 QTRY_COMPARE(lvwph->m_visibleItems.count(), 12);

1241 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1242 verifyItem(0, -308., 75., true);

1243 verifyItem(1, -233., 75., true);

1244 verifyItem(2, -158., 75., true);

1245 verifyItem(3, -83., 75., true);

1246 verifyItem(4, -8., 75., false);

1247 verifyItem(5, 67., 75., false);

1248 verifyItem(6, 142., 75., false);

1249 verifyItem(7, 217., 75., false);

1250 verifyItem(8, 292., 75., false);

1251 verifyItem(9, 367., 75., false);

1252 verifyItem(10, 442., 150., false);

1253 verifyItem(11, 592., 200., true);

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

1255 QCOMPARE(lvwph->m_clipItem->y(), -392.);

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

1257 QCOMPARE(lvwph->m_headerItem->y(), -442.);

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

1259 QCOMPARE(lvwph->contentY(), -442.);

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

1261 }

1262

1263 void testRemoveItemsAtTop()

1264 {

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

1266

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

1268 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1269 verifyItem(0, 50., 350., false);

1270 verifyItem(1, 400., 350., false);

1271 verifyItem(2, 750., 350., true);

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

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

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

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

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

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

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

1279 QVERIFY(lvwph->isAtYBeginning());

1280 }

1281

1282 void testRemoveNonCreatedItemsAtTopWhenAtBottom()

1283 {

1284 scrollToBottom();

1285

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

1287

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

1289 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1290 verifyItem(0, -508., 350., true);

1291 verifyItem(1, -158, 350., false);

1292 verifyItem(2, 192, 350., false);

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

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

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

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

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

1298 QCOMPARE(lvwph->contentY(), 1258.);

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

1300 }

1301

1302 void testRemoveLastItemsAtBottom()

1303 {

1304 scrollToBottom();

1305

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

1307

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

1309 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1310 verifyItem(0, -358., 200., true);

1311 verifyItem(1, -158, 350., false);

1312 verifyItem(2, 192, 350., false);

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

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

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

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

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

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

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

1320 }

1321

1322 void testRemoveItemOutOfViewport()

1323 {

1324 changeContentY(520);

1325

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

1327 QCOMPARE(lvwph->m_firstVisibleIndex, 1);

1328 verifyItem(0, -320., 200., true);

1329 verifyItem(1, -120, 350., false);

1330 verifyItem(2, 230, 350., false);

1331 verifyItem(3, 580, 350., true);

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

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

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

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

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

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

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

1339

1340

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

1342

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

1344 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1345 verifyItem(0, -270., 150., true);

1346 verifyItem(1, -120., 350., false);

1347 verifyItem(2, 230, 350., false);

1348 verifyItem(3, 580, 350., true);

1349 QCOMPARE(lvwph->m_minYExtent, -200.);

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

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

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

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

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

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

1356 }

1357

1358 void testMoveFirstItems()

1359 {

1360 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));

1361

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

1363 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1364 verifyItem(0, 50., 200., false);

1365 verifyItem(1, 250., 150., false);

1366 verifyItem(2, 400., 350., false);

1367 verifyItem(3, 750., 350., true);

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

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

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

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

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

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

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

1375

1376 }

1377

1378 void testMoveFirstOutOfVisibleItems()

1379 {

1380 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));

1381

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

1383 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1384 verifyItem(0, 50., 200., false);

1385 verifyItem(1, 250., 350., false);

1386 verifyItem(2, 600., 350., true);

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

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

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

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

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

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

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

1394

1395 }

1396

1397 void testMoveFirstToLastAtBottom()

1398 {

1399 scrollToBottom();

1400

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

1402 QCOMPARE(lvwph->m_firstVisibleIndex, 3);

1403 verifyItem(0, -508., 350., true);

1404 verifyItem(1, -158, 350., false);

1405 verifyItem(2, 192, 350., false);

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

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

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

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

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

1411 QCOMPARE(lvwph->contentY(), 1258.);

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

1413

1414 QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));

1415

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

1417 QCOMPARE(lvwph->m_firstVisibleIndex, 2);

1418 verifyItem(0, -508., 350., true);

1419 verifyItem(1, -158, 350., false);

1420 verifyItem(2, 192, 350., false);

1421 verifyItem(3, 542, 150., true);

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

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

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

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

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

1427 QCOMPARE(lvwph->contentY(), 1258.);

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

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

1430 }

1431

1432 void testChangeSizeVisibleItemNotOnViewport()

1433 {

1434 changeContentY(440);

1435

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

1437 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1438 verifyItem(0, -390., 150., true);

1439 verifyItem(1, -240., 200., true);

1440 verifyItem(2, -40, 350., false);

1441 verifyItem(3, 310, 350., false);

1442 verifyItem(4, 660, 350., true);

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

1444 QCOMPARE(lvwph->m_clipItem->y(), 440.);

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

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

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

1448 QCOMPARE(lvwph->contentY(), 440.);

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

1450

1451 model->setProperty(1, "size", 100);

1452

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

1454 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1455 verifyItem(0, -290., 150., true);

1456 verifyItem(1, -140., 100., true);

1457 verifyItem(2, -40, 350., false);

1458 verifyItem(3, 310, 350., false);

1459 verifyItem(4, 660, 350., true);

1460 QCOMPARE(lvwph->m_minYExtent, -100.);

1461 QCOMPARE(lvwph->m_clipItem->y(), 440.);

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

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

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

1465 QCOMPARE(lvwph->contentY(), 440.);

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

1467 }

1468

1469 void testShowHeaderCloseToTheTop()

1470 {

1471 changeContentY(375);

1472

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

1474 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1475 verifyItem(0, -325., 150., true);

1476 verifyItem(1, -175, 200., false);

1477 verifyItem(2, 25, 350., false);

1478 verifyItem(3, 375, 350., false);

1479 verifyItem(4, 725, 350., true);

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

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

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

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

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

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

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

1487

1488 lvwph->showHeader();

1489

1490 QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());

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

1492 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1493 verifyItem(0, -375., 150., true);

1494 verifyItem(1, -225, 200., true);

1495 verifyItem(2, -25, 350., false);

1496 verifyItem(3, 325, 350., false);

1497 verifyItem(4, 675, 350., true);

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

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

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

1501 QCOMPARE(lvwph->m_headerItem->y(), 325.);

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

1503 QCOMPARE(lvwph->contentY(), 325.);

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

1505

1506 scrollToTop();

1507

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

1509 QCOMPARE(lvwph->m_firstVisibleIndex, 0);

1510 verifyItem(0, 50., 150., false);

1511 verifyItem(1, 200., 200., false);

1512 verifyItem(2, 400., 350., false);

1513 verifyItem(3, 750., 350., true);

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

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

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

1517 QCOMPARE(lvwph->m_headerItem->y(), -50.);

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

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

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

1521 }

1522

1523private:

1524 QQuickView *view;

1525 ListViewWithPageHeader *lvwph;

1526 QQuickListModel *model;

1527 QQmlComponent *otherDelegate;

1528};

1529

1530QTEST_MAIN(ListViewWithPageHeaderTest)

1531

1532#include "listviewwithpageheadertest.moc"