Debian Codegraph @

tests/auto/quick/qquickrepeater/tst_qquickrepeater.cpp

raw
1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see https://www.qt.io/terms-conditions. For further
15 ** information use the contact form at https://www.qt.io/contact-us.
16 **
17 ** GNU General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU
19 ** General Public License version 3 as published by the Free Software
20 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
21 ** included in the packaging of this file. Please review the following
22 ** information to ensure the GNU General Public License requirements will
23 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
24 **
25 ** $QT_END_LICENSE$
26 **
27 ****************************************************************************/
28
29 #include <QtTest/QtTest>
30 #include <QtTest/QSignalSpy>
31 #include <QtQml/qqmlengine.h>
32 #include <QtQuick/qquickview.h>
33 #include <QtQml/qqmlcontext.h>
34 #include <QtQml/qqmlexpression.h>
35 #include <QtQml/qqmlincubator.h>
36 #include <private/qquickrepeater_p.h>
37 #include <QtQuick/private/qquicktext_p.h>
38 #include <QtQmlModels/private/qqmllistmodel_p.h>
39 #include <QtQmlModels/private/qqmlobjectmodel_p.h>
40 #include <QtGui/qstandarditemmodel.h>
41
42 #include "../../shared/util.h"
43 #include "../shared/viewtestutil.h"
44 #include "../shared/visualtestutil.h"
45
46 using namespace QQuickViewTestUtil;
47 using namespace QQuickVisualTestUtil;
48
49
50 class tst_QQuickRepeater : public QQmlDataTest
51 {
52 Q_OBJECT
53 public:
54 tst_QQuickRepeater();
55
56 private slots:
57 void numberModel();
58 void objectList_data();
59 void objectList();
60 void stringList();
61 void dataModel_adding();
62 void dataModel_removing();
63 void dataModel_changes();
64 void itemModel();
65 void resetModel();
66 void modelChanged();
67 void modelReset();
68 void modelCleared();
69 void properties();
70 void asynchronous();
71 void initParent();
72 void dynamicModelCrash();
73 void visualItemModelCrash();
74 void invalidContextCrash();
75 void jsArrayChange();
76 void clearRemovalOrder();
77 void destroyCount();
78 void stackingOrder();
79 void objectModel();
80 void QTBUG54859_asynchronousMove();
81 void package();
82 void ownership();
83 void requiredProperties();
84 void contextProperties();
85 };
86
87 class TestObject : public QObject
88 {
89 Q_OBJECT
90
91 Q_PROPERTY(bool error READ error WRITE setError)
92 Q_PROPERTY(bool useModel READ useModel NOTIFY useModelChanged)
93
94 public:
95 TestObject() : QObject(), mError(true), mUseModel(false) {}
96
97 bool error() const { return mError; }
98 void setError(bool err) { mError = err; }
99
100 bool useModel() const { return mUseModel; }
101 void setUseModel(bool use) { mUseModel = use; emit useModelChanged(); }
102
103 signals:
104 void useModelChanged();
105
106 private:
107 bool mError;
108 bool mUseModel;
109 };
110
111 tst_QQuickRepeater::tst_QQuickRepeater()
112 {
113 }
114
115 void tst_QQuickRepeater::numberModel()
116 {
117 QQuickView *window = createView();
118
119 QQmlContext *ctxt = window->rootContext();
120 ctxt->setContextProperty("testData", 5);
121 TestObject *testObject = new TestObject;
122 ctxt->setContextProperty("testObject", testObject);
123
124 window->setSource(testFileUrl("intmodel.qml"));
125 qApp->processEvents();
126
127 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
128 QVERIFY(repeater != nullptr);
129 QCOMPARE(repeater->parentItem()->childItems().count(), 5+1);
130
131 QVERIFY(!repeater->itemAt(-1));
132 for (int i=0; i<repeater->count(); i++)
133 QCOMPARE(repeater->itemAt(i), repeater->parentItem()->childItems().at(i));
134 QVERIFY(!repeater->itemAt(repeater->count()));
135
136 QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
137 QVERIFY(!testObject->error());
138
139 ctxt->setContextProperty("testData", std::numeric_limits<int>::max());
140 QCOMPARE(repeater->parentItem()->childItems().count(), 1);
141
142 ctxt->setContextProperty("testData", -1234);
143 QCOMPARE(repeater->parentItem()->childItems().count(), 1);
144
145 delete testObject;
146 delete window;
147 }
148
149 void tst_QQuickRepeater::objectList_data()
150 {
151 QTest::addColumn<QUrl>("filename");
152
153 QTest::newRow("normal") << testFileUrl("objlist.qml");
154 QTest::newRow("required") << testFileUrl("objlist_required.qml");
155 }
156
157 class MyObject : public QObject
158 {
159 Q_OBJECT
160 Q_PROPERTY(int idx READ idx CONSTANT)
161 public:
162 MyObject(int i) : QObject(), m_idx(i) {}
163
164 int idx() const { return m_idx; }
165
166 int m_idx;
167 };
168
169 void tst_QQuickRepeater::objectList()
170 {
171 QFETCH(QUrl, filename);
172 QQuickView *window = createView();
173 QObjectList data;
174 for (int i=0; i<100; i++)
175 data << new MyObject(i);
176
177 QQmlContext *ctxt = window->rootContext();
178 ctxt->setContextProperty("testData", QVariant::fromValue(data));
179
180 window->setSource(filename);
181 qApp->processEvents();
182
183 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
184 QVERIFY(repeater != nullptr);
185 QCOMPARE(repeater->property("errors").toInt(), 0);//If this fails either they are out of order or can't find the object's data
186 QCOMPARE(repeater->property("instantiated").toInt(), 100);
187
188 QVERIFY(!repeater->itemAt(-1));
189 for (int i=0; i<data.count(); i++)
190 QCOMPARE(repeater->itemAt(i), repeater->parentItem()->childItems().at(i));
191 QVERIFY(!repeater->itemAt(data.count()));
192
193 QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
194 QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
195 ctxt->setContextProperty("testData", QVariant::fromValue(data));
196 QCOMPARE(addedSpy.count(), data.count());
197 QCOMPARE(removedSpy.count(), data.count());
198
199 qDeleteAll(data);
200 delete window;
201 }
202
203 /*
204 The Repeater element creates children at its own position in its parent's
205 stacking order. In this test we insert a repeater between two other Text
206 elements to test this.
207 */
208 void tst_QQuickRepeater::stringList()
209 {
210 QQuickView *window = createView();
211
212 QStringList data;
213 data << "One";
214 data << "Two";
215 data << "Three";
216 data << "Four";
217
218 QQmlContext *ctxt = window->rootContext();
219 ctxt->setContextProperty("testData", data);
220
221 window->setSource(testFileUrl("repeater1.qml"));
222 qApp->processEvents();
223
224 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
225 QVERIFY(repeater != nullptr);
226
227 QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
228 QVERIFY(container != nullptr);
229
230 QCOMPARE(container->childItems().count(), data.count() + 3);
231
232 bool saw_repeater = false;
233 for (int i = 0; i < container->childItems().count(); ++i) {
234
235 if (i == 0) {
236 QQuickText *name = qobject_cast<QQuickText*>(container->childItems().at(i));
237 QVERIFY(name != nullptr);
238 QCOMPARE(name->text(), QLatin1String("Zero"));
239 } else if (i == container->childItems().count() - 2) {
240 // The repeater itself
241 QQuickRepeater *rep = qobject_cast<QQuickRepeater*>(container->childItems().at(i));
242 QCOMPARE(rep, repeater);
243 saw_repeater = true;
244 continue;
245 } else if (i == container->childItems().count() - 1) {
246 QQuickText *name = qobject_cast<QQuickText*>(container->childItems().at(i));
247 QVERIFY(name != nullptr);
248 QCOMPARE(name->text(), QLatin1String("Last"));
249 } else {
250 QQuickText *name = qobject_cast<QQuickText*>(container->childItems().at(i));
251 QVERIFY(name != nullptr);
252 QCOMPARE(name->text(), data.at(i-1));
253 }
254 }
255 QVERIFY(saw_repeater);
256
257 delete window;
258 }
259
260 void tst_QQuickRepeater::dataModel_adding()
261 {
262 QQuickView *window = createView();
263 QQmlContext *ctxt = window->rootContext();
264 TestObject *testObject = new TestObject;
265 ctxt->setContextProperty("testObject", testObject);
266
267 QaimModel testModel;
268 ctxt->setContextProperty("testData", &testModel);
269 window->setSource(testFileUrl("repeater2.qml"));
270 qApp->processEvents();
271
272 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
273 QVERIFY(repeater != nullptr);
274 QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
275 QVERIFY(container != nullptr);
276
277 QVERIFY(!repeater->itemAt(0));
278
279 QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
280 QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
281
282 // add to empty model
283 testModel.addItem("two", "2");
284 QCOMPARE(repeater->itemAt(0), container->childItems().at(0));
285 QCOMPARE(countSpy.count(), 1); countSpy.clear();
286 QCOMPARE(addedSpy.count(), 1);
287 QCOMPARE(addedSpy.at(0).at(0).toInt(), 0);
288 QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(0));
289 addedSpy.clear();
290
291 // insert at start
292 testModel.insertItem(0, "one", "1");
293 QCOMPARE(repeater->itemAt(0), container->childItems().at(0));
294 QCOMPARE(countSpy.count(), 1); countSpy.clear();
295 QCOMPARE(addedSpy.count(), 1);
296 QCOMPARE(addedSpy.at(0).at(0).toInt(), 0);
297 QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(0));
298 addedSpy.clear();
299
300 // insert at end
301 testModel.insertItem(2, "four", "4");
302 QCOMPARE(repeater->itemAt(2), container->childItems().at(2));
303 QCOMPARE(countSpy.count(), 1); countSpy.clear();
304 QCOMPARE(addedSpy.count(), 1);
305 QCOMPARE(addedSpy.at(0).at(0).toInt(), 2);
306 QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(2));
307 addedSpy.clear();
308
309 // insert in middle
310 testModel.insertItem(2, "three", "3");
311 QCOMPARE(repeater->itemAt(2), container->childItems().at(2));
312 QCOMPARE(countSpy.count(), 1); countSpy.clear();
313 QCOMPARE(addedSpy.count(), 1);
314 QCOMPARE(addedSpy.at(0).at(0).toInt(), 2);
315 QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(2));
316 addedSpy.clear();
317
318 //insert in middle multiple
319 int childItemsSize = container->childItems().size();
320 QList<QPair<QString, QString> > multiData;
321 multiData << qMakePair(QStringLiteral("five"), QStringLiteral("5")) << qMakePair(QStringLiteral("six"), QStringLiteral("6")) << qMakePair(QStringLiteral("seven"), QStringLiteral("7"));
322 testModel.insertItems(1, multiData);
323 QCOMPARE(countSpy.count(), 1);
324 QCOMPARE(addedSpy.count(), 3);
325 QCOMPARE(container->childItems().size(), childItemsSize + 3);
326 QCOMPARE(repeater->itemAt(2), container->childItems().at(2));
327 addedSpy.clear();
328 countSpy.clear();
329
330 delete testObject;
331 addedSpy.clear();
332 countSpy.clear();
333 delete window;
334 }
335
336 void tst_QQuickRepeater::dataModel_removing()
337 {
338 QQuickView *window = createView();
339 QQmlContext *ctxt = window->rootContext();
340 TestObject *testObject = new TestObject;
341 ctxt->setContextProperty("testObject", testObject);
342
343 QaimModel testModel;
344 testModel.addItem("one", "1");
345 testModel.addItem("two", "2");
346 testModel.addItem("three", "3");
347 testModel.addItem("four", "4");
348 testModel.addItem("five", "5");
349
350 ctxt->setContextProperty("testData", &testModel);
351 window->setSource(testFileUrl("repeater2.qml"));
352 qApp->processEvents();
353
354 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
355 QVERIFY(repeater != nullptr);
356 QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
357 QVERIFY(container != nullptr);
358 QCOMPARE(container->childItems().count(), repeater->count()+1);
359
360 QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
361 QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
362
363 // remove at start
364 QQuickItem *item = repeater->itemAt(0);
365 QCOMPARE(item, container->childItems().at(0));
366
367 testModel.removeItem(0);
368 QVERIFY(repeater->itemAt(0) != item);
369 QCOMPARE(countSpy.count(), 1); countSpy.clear();
370 QCOMPARE(removedSpy.count(), 1);
371 QCOMPARE(removedSpy.at(0).at(0).toInt(), 0);
372 QCOMPARE(removedSpy.at(0).at(1).value<QQuickItem*>(), item);
373 removedSpy.clear();
374
375 // remove at end
376 int lastIndex = testModel.count()-1;
377 item = repeater->itemAt(lastIndex);
378 QCOMPARE(item, container->childItems().at(lastIndex));
379
380 testModel.removeItem(lastIndex);
381 QVERIFY(repeater->itemAt(lastIndex) != item);
382 QCOMPARE(countSpy.count(), 1); countSpy.clear();
383 QCOMPARE(removedSpy.count(), 1);
384 QCOMPARE(removedSpy.at(0).at(0).toInt(), lastIndex);
385 QCOMPARE(removedSpy.at(0).at(1).value<QQuickItem*>(), item);
386 removedSpy.clear();
387
388 // remove from middle
389 item = repeater->itemAt(1);
390 QCOMPARE(item, container->childItems().at(1));
391
392 testModel.removeItem(1);
393 QVERIFY(repeater->itemAt(lastIndex) != item);
394 QCOMPARE(countSpy.count(), 1); countSpy.clear();
395 QCOMPARE(removedSpy.count(), 1);
396 QCOMPARE(removedSpy.at(0).at(0).toInt(), 1);
397 QCOMPARE(removedSpy.at(0).at(1).value<QQuickItem*>(), item);
398 removedSpy.clear();
399
400 delete testObject;
401 delete window;
402 }
403
404 void tst_QQuickRepeater::dataModel_changes()
405 {
406 QQuickView *window = createView();
407 QQmlContext *ctxt = window->rootContext();
408 TestObject *testObject = new TestObject;
409 ctxt->setContextProperty("testObject", testObject);
410
411 QaimModel testModel;
412 testModel.addItem("one", "1");
413 testModel.addItem("two", "2");
414 testModel.addItem("three", "3");
415
416 ctxt->setContextProperty("testData", &testModel);
417 window->setSource(testFileUrl("repeater2.qml"));
418 qApp->processEvents();
419
420 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
421 QVERIFY(repeater != nullptr);
422 QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
423 QVERIFY(container != nullptr);
424 QCOMPARE(container->childItems().count(), repeater->count()+1);
425
426 // Check that model changes are propagated
427 QQuickText *text = findItem<QQuickText>(window->rootObject(), "myName", 1);
428 QVERIFY(text);
429 QCOMPARE(text->text(), QString("two"));
430
431 testModel.modifyItem(1, "Item two", "_2");
432 text = findItem<QQuickText>(window->rootObject(), "myName", 1);
433 QVERIFY(text);
434 QCOMPARE(text->text(), QString("Item two"));
435
436 text = findItem<QQuickText>(window->rootObject(), "myNumber", 1);
437 QVERIFY(text);
438 QCOMPARE(text->text(), QString("_2"));
439
440 delete testObject;
441 delete window;
442 }
443
444 void tst_QQuickRepeater::itemModel()
445 {
446 QQuickView *window = createView();
447 QQmlContext *ctxt = window->rootContext();
448 TestObject *testObject = new TestObject;
449 ctxt->setContextProperty("testObject", testObject);
450
451 window->setSource(testFileUrl("itemlist.qml"));
452 qApp->processEvents();
453
454 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
455 QVERIFY(repeater != nullptr);
456
457 QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
458 QVERIFY(container != nullptr);
459
460 QCOMPARE(container->childItems().count(), 1);
461
462 testObject->setUseModel(true);
463 QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
464 QVERIFY(!testObject->error());
465
466 QCOMPARE(container->childItems().count(), 4);
467 QCOMPARE(qobject_cast<QObject*>(container->childItems().at(0))->objectName(), QLatin1String("item1"));
468 QCOMPARE(qobject_cast<QObject*>(container->childItems().at(1))->objectName(), QLatin1String("item2"));
469 QCOMPARE(qobject_cast<QObject*>(container->childItems().at(2))->objectName(), QLatin1String("item3"));
470 QCOMPARE(container->childItems().at(3), repeater);
471
472 QMetaObject::invokeMethod(window->rootObject(), "switchModel");
473 QCOMPARE(container->childItems().count(), 3);
474 QCOMPARE(qobject_cast<QObject*>(container->childItems().at(0))->objectName(), QLatin1String("item4"));
475 QCOMPARE(qobject_cast<QObject*>(container->childItems().at(1))->objectName(), QLatin1String("item5"));
476 QCOMPARE(container->childItems().at(2), repeater);
477
478 testObject->setUseModel(false);
479 QCOMPARE(container->childItems().count(), 1);
480
481 delete testObject;
482 delete window;
483 }
484
485 void tst_QQuickRepeater::resetModel()
486 {
487 QQuickView *window = createView();
488
489 QStringList dataA;
490 for (int i=0; i<10; i++)
491 dataA << QString::number(i);
492
493 QQmlContext *ctxt = window->rootContext();
494 ctxt->setContextProperty("testData", dataA);
495 window->setSource(testFileUrl("repeater1.qml"));
496 qApp->processEvents();
497 QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
498 QVERIFY(repeater != nullptr);
499 QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
500 QVERIFY(container != nullptr);
501
502 QCOMPARE(repeater->count(), dataA.count());
503 for (int i=0; i<repeater->count(); i++)
504 QCOMPARE(repeater->itemAt(i), container->childItems().at(i+1)); // +1 to skip first Text object
505
506 QSignalSpy modelChangedSpy(repeater, SIGNAL(modelChanged()));
507 QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
508 QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
509 QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
510
511 QStringList dataB;
512 for (int i=0; i<20; i++)
513 dataB << QString::number(i);
514
515 // reset context property
516 ctxt->setContextProperty("testData", dataB);
517 QCOMPARE(repeater->count(), dataB.count());
518
519 QCOMPARE(modelChangedSpy.count(), 1);
520 QCOMPARE(countSpy.count(), 1);
521 QCOMPARE(removedSpy.count(), dataA.count());
522 QCOMPARE(addedSpy.count(), dataB.count());
523 for (int i=0; i<dataB.count(); i++) {
524 QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
525 QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
526 }
527 modelChangedSpy.clear();
528 countSpy.clear();
529 removedSpy.clear();
530 addedSpy.clear();
531
532 // reset via setModel()
533 repeater->setModel(dataA);
534 QCOMPARE(repeater->count(), dataA.count());
535
536 QCOMPARE(modelChangedSpy.count(), 1);
537 QCOMPARE(countSpy.count(), 1);
538 QCOMPARE(removedSpy.count(), dataB.count());
539 QCOMPARE(addedSpy.count(), dataA.count());
540 for (int i=0; i<dataA.count(); i++) {
541 QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
542 QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
543 }
544
545 modelChangedSpy.clear();
546 countSpy.clear();
547 removedSpy.clear();
548 addedSpy.clear();
549
550 delete window;
551 }
552
553 // QTBUG-17156
554 void tst_QQuickRepeater::modelChanged()
555 {
556 QQmlEngine engine;
557 QQmlComponent component(&engine, testFileUrl("modelChanged.qml"));
558
559 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
560 QVERIFY(rootObject);
561 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
562 QVERIFY(repeater);
563
564 repeater->setModel(4);
565 QCOMPARE(repeater->count(), 4);
566 QCOMPARE(repeater->property("itemsCount").toInt(), 4);
567 QCOMPARE(repeater->property("itemsFound").toList().count(), 4);
568
569 repeater->setModel(10);
570 QCOMPARE(repeater->count(), 10);
571 QCOMPARE(repeater->property("itemsCount").toInt(), 10);
572 QCOMPARE(repeater->property("itemsFound").toList().count(), 10);
573
574 delete rootObject;
575 }
576
577 void tst_QQuickRepeater::modelReset()
578 {
579 QaimModel model;
580
581 QQmlEngine engine;
582 QQmlContext *ctxt = engine.rootContext();
583 ctxt->setContextProperty("testData", &model);
584
585 QQmlComponent component(&engine, testFileUrl("repeater2.qml"));
586 QScopedPointer<QObject> object(component.create());
587 QQuickItem *rootItem = qobject_cast<QQuickItem *>(object.data());
588 QVERIFY(rootItem);
589
590 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootItem, "repeater");
591 QVERIFY(repeater != nullptr);
592 QQuickItem *container = findItem<QQuickItem>(rootItem, "container");
593 QVERIFY(container != nullptr);
594
595 QCOMPARE(repeater->count(), 0);
596
597 QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
598 QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
599 QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
600
601
602 QList<QPair<QString, QString> > items = QList<QPair<QString, QString> >()
603 << qMakePair(QString::fromLatin1("one"), QString::fromLatin1("1"))
604 << qMakePair(QString::fromLatin1("two"), QString::fromLatin1("2"))
605 << qMakePair(QString::fromLatin1("three"), QString::fromLatin1("3"));
606
607 model.resetItems(items);
608
609 QCOMPARE(countSpy.count(), 1);
610 QCOMPARE(removedSpy.count(), 0);
611 QCOMPARE(addedSpy.count(), items.count());
612 for (int i = 0; i< items.count(); i++) {
613 QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
614 QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
615 }
616
617 countSpy.clear();
618 addedSpy.clear();
619
620 model.reset();
621 QCOMPARE(countSpy.count(), 0);
622 QCOMPARE(removedSpy.count(), 3);
623 QCOMPARE(addedSpy.count(), 3);
624 for (int i = 0; i< items.count(); i++) {
625 QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
626 QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
627 }
628
629 addedSpy.clear();
630 removedSpy.clear();
631
632 items.append(qMakePair(QString::fromLatin1("four"), QString::fromLatin1("4")));
633 items.append(qMakePair(QString::fromLatin1("five"), QString::fromLatin1("5")));
634
635 model.resetItems(items);
636 QCOMPARE(countSpy.count(), 1);
637 QCOMPARE(removedSpy.count(), 3);
638 QCOMPARE(addedSpy.count(), 5);
639 for (int i = 0; i< items.count(); i++) {
640 QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
641 QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
642 }
643
644 countSpy.clear();
645 addedSpy.clear();
646 removedSpy.clear();
647
648 items.clear();
649 model.resetItems(items);
650 QCOMPARE(countSpy.count(), 1);
651 QCOMPARE(removedSpy.count(), 5);
652 QCOMPARE(addedSpy.count(), 0);
653 }
654
655 // QTBUG-46828
656 void tst_QQuickRepeater::modelCleared()
657 {
658 QQmlEngine engine;
659 QQmlComponent component(&engine, testFileUrl("modelCleared.qml"));
660
661 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
662 QVERIFY(rootObject);
663
664 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
665 QVERIFY(repeater);
666
667 // verify no error messages when the model is cleared and the items are destroyed
668 QQmlTestMessageHandler messageHandler;
669 repeater->setModel(0);
670 QVERIFY2(messageHandler.messages().isEmpty(), qPrintable(messageHandler.messageString()));
671
672 delete rootObject;
673 }
674
675 void tst_QQuickRepeater::properties()
676 {
677 QQmlEngine engine;
678 QQmlComponent component(&engine, testFileUrl("properties.qml"));
679
680 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
681 QVERIFY(rootObject);
682
683 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
684 QVERIFY(repeater);
685
686 QSignalSpy modelSpy(repeater, SIGNAL(modelChanged()));
687 repeater->setModel(3);
688 QCOMPARE(modelSpy.count(),1);
689 repeater->setModel(3);
690 QCOMPARE(modelSpy.count(),1);
691
692 QSignalSpy delegateSpy(repeater, SIGNAL(delegateChanged()));
693
694 QQmlComponent rectComponent(&engine);
695 rectComponent.setData("import QtQuick 2.0; Rectangle {}", QUrl::fromLocalFile(""));
696
697 repeater->setDelegate(&rectComponent);
698 QCOMPARE(delegateSpy.count(),1);
699 repeater->setDelegate(&rectComponent);
700 QCOMPARE(delegateSpy.count(),1);
701
702 delete rootObject;
703 }
704
705 void tst_QQuickRepeater::asynchronous()
706 {
707 QQuickView *window = createView();
708 window->show();
709 QQmlIncubationController controller;
710 window->engine()->setIncubationController(&controller);
711
712 window->setSource(testFileUrl("asyncloader.qml"));
713
714 QQuickItem *rootObject = qobject_cast<QQuickItem*>(window->rootObject());
715 QVERIFY(rootObject);
716
717 QQuickItem *container = findItem<QQuickItem>(rootObject, "container");
718 QVERIFY(!container);
719 while (!container) {
720 bool b = false;
721 controller.incubateWhile(&b);
722 container = findItem<QQuickItem>(rootObject, "container");
723 }
724
725 QQuickRepeater *repeater = nullptr;
726 while (!repeater) {
727 bool b = false;
728 controller.incubateWhile(&b);
729 repeater = findItem<QQuickRepeater>(rootObject, "repeater");
730 }
731
732 // items will be created one at a time
733 // the order is incubator/model specific
734 for (int i = 9; i >= 0; --i) {
735 QString name("delegate");
736 name += QString::number(i);
737 QVERIFY(findItem<QQuickItem>(container, name) == nullptr);
738 QQuickItem *item = nullptr;
739 while (!item) {
740 bool b = false;
741 controller.incubateWhile(&b);
742 item = findItem<QQuickItem>(container, name);
743 }
744 }
745
746 {
747 bool b = true;
748 controller.incubateWhile(&b);
749 }
750
751 // verify positioning
752 for (int i = 0; i < 10; ++i) {
753 QString name("delegate");
754 name += QString::number(i);
755 QQuickItem *item = findItem<QQuickItem>(container, name);
756 QTRY_COMPARE(item->y(), i * 50.0);
757 }
758
759 delete window;
760 }
761
762 void tst_QQuickRepeater::initParent()
763 {
764 QQmlEngine engine;
765 QQmlComponent component(&engine, testFileUrl("initparent.qml"));
766
767 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
768 QVERIFY(rootObject);
769
770 QCOMPARE(qvariant_cast<QQuickItem*>(rootObject->property("parentItem")), rootObject);
771 }
772
773 void tst_QQuickRepeater::dynamicModelCrash()
774 {
775 QQmlEngine engine;
776 QQmlComponent component(&engine, testFileUrl("dynamicmodelcrash.qml"));
777
778 // Don't crash
779 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
780 QVERIFY(rootObject);
781
782 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "rep");
783 QVERIFY(repeater);
784 QVERIFY(qvariant_cast<QObject *>(repeater->model()) == 0);
785 }
786
787 void tst_QQuickRepeater::visualItemModelCrash()
788 {
789 // This used to crash because the model would get
790 // deleted before the repeater, leading to double-deletion
791 // of the items.
792 QQuickView *window = createView();
793 window->setSource(testFileUrl("visualitemmodel.qml"));
794 qApp->processEvents();
795 delete window;
796 }
797
798 class BadModel : public QAbstractListModel
799 {
800 public:
801 ~BadModel()
802 {
803 beginResetModel();
804 endResetModel();
805 }
806
807 QVariant data(const QModelIndex &, int) const { return QVariant(); }
808 int rowCount(const QModelIndex &) const { return 0; }
809 };
810
811
812 void tst_QQuickRepeater::invalidContextCrash()
813 {
814 QQmlEngine engine;
815 QQmlComponent component(&engine, testFileUrl("invalidContextCrash.qml"));
816
817 BadModel* model = new BadModel;
818 engine.rootContext()->setContextProperty("badModel", model);
819
820 QScopedPointer<QObject> root(component.create());
821 QCOMPARE(root->children().count(), 1);
822 QObject *repeater = root->children().first();
823
824 // Make sure the model comes first in the child list, so it will be
825 // deleted first and then the repeater. During deletion the QML context
826 // has been deleted already and is invalid.
827 model->setParent(root.data());
828 repeater->setParent(nullptr);
829 repeater->setParent(root.data());
830
831 QCOMPARE(root->children().count(), 2);
832 QCOMPARE(root->children().at(0), model);
833 QCOMPARE(root->children().at(1), repeater);
834
835 // Delete the root object, which will invalidate/delete the QML context
836 // and then delete the child QObjects, which may try to access the context.
837 root.reset(nullptr);
838 }
839
840 void tst_QQuickRepeater::jsArrayChange()
841 {
842 QQmlEngine engine;
843 QQmlComponent component(&engine);
844 component.setData("import QtQuick 2.4; Repeater {}", QUrl());
845
846 QScopedPointer<QQuickRepeater> repeater(qobject_cast<QQuickRepeater *>(component.create()));
847 QVERIFY(!repeater.isNull());
848
849 QSignalSpy spy(repeater.data(), SIGNAL(modelChanged()));
850 QVERIFY(spy.isValid());
851
852 QJSValue array1 = engine.newArray(3);
853 QJSValue array2 = engine.newArray(3);
854 for (int i = 0; i < 3; ++i) {
855 array1.setProperty(i, i);
856 array2.setProperty(i, i);
857 }
858
859 repeater->setModel(QVariant::fromValue(array1));
860 QCOMPARE(spy.count(), 1);
861
862 // no change
863 repeater->setModel(QVariant::fromValue(array2));
864 QCOMPARE(spy.count(), 1);
865 }
866
867 void tst_QQuickRepeater::clearRemovalOrder()
868 {
869 // Here, we're going to test that when the model is cleared, item removal
870 // signals are sent in a sensible order that gives us correct indices.
871 // (QTBUG-42243)
872 QQmlEngine engine;
873 QQmlComponent component(&engine, testFileUrl("clearremovalorder.qml"));
874
875 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
876 QVERIFY(rootObject);
877
878 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
879 QVERIFY(repeater);
880 QCOMPARE(repeater->count(), 3);
881
882 QQmlListModel *model = rootObject->findChild<QQmlListModel*>("secondModel");
883 QVERIFY(model);
884 QCOMPARE(model->count(), 0);
885
886 // Now change the model
887 QSignalSpy removedSpy(repeater, &QQuickRepeater::itemRemoved);
888 repeater->setModel(QVariant::fromValue(model));
889
890 // we should have 0 items, and 3 removal signals.
891 QCOMPARE(repeater->count(), 0);
892 QCOMPARE(removedSpy.count(), 3);
893
894 // column 1 is for the items, we won't bother verifying these. just look at
895 // the indices and make sure they're sane.
896 QCOMPARE(removedSpy.at(0).at(0).toInt(), 2);
897 QCOMPARE(removedSpy.at(1).at(0).toInt(), 1);
898 QCOMPARE(removedSpy.at(2).at(0).toInt(), 0);
899
900 delete rootObject;
901 }
902
903 void tst_QQuickRepeater::destroyCount()
904 {
905 QQmlEngine engine;
906 QQmlComponent component(&engine, testFileUrl("destroycount.qml"));
907
908 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
909 QVERIFY(rootObject);
910
911 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
912 QVERIFY(repeater);
913
914 repeater->setProperty("model", QVariant::fromValue<int>(3));
915 QCOMPARE(repeater->property("componentCount").toInt(), 3);
916 repeater->setProperty("model", QVariant::fromValue<int>(0));
917 QCOMPARE(repeater->property("componentCount").toInt(), 0);
918 repeater->setProperty("model", QVariant::fromValue<int>(4));
919 QCOMPARE(repeater->property("componentCount").toInt(), 4);
920
921 QStringListModel model;
922 repeater->setProperty("model", QVariant::fromValue<QStringListModel *>(&model));
923 QCOMPARE(repeater->property("componentCount").toInt(), 0);
924 QStringList list;
925 list << "1" << "2" << "3" << "4";
926 model.setStringList(list);
927 QCOMPARE(repeater->property("componentCount").toInt(), 4);
928 model.insertRows(2,1);
929 QModelIndex index = model.index(2);
930 model.setData(index, QVariant::fromValue<QString>(QStringLiteral("foobar")));
931 QCOMPARE(repeater->property("componentCount").toInt(), 5);
932
933 model.removeRows(2,1);
934 QCOMPARE(model.rowCount(), 4);
935 QCOMPARE(repeater->property("componentCount").toInt(), 4);
936 }
937
938 void tst_QQuickRepeater::stackingOrder()
939 {
940 QQmlEngine engine;
941 QQmlComponent component(&engine, testFileUrl("stackingorder.qml"));
942
943 QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
944 QVERIFY(rootObject);
945
946 QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
947 QVERIFY(repeater);
948 int count = 1;
949 do {
950 bool stackingOrderOk = rootObject->property("stackingOrderOk").toBool();
951 QVERIFY(stackingOrderOk);
952 repeater->setModel(QVariant(++count));
953 } while (count < 3);
954 }
955
956 static bool compareObjectModel(QQuickRepeater *repeater, QQmlObjectModel *model)
957 {
958 if (repeater->count() != model->count())
959 return false;
960 for (int i = 0; i < repeater->count(); ++i) {
961 if (repeater->itemAt(i) != model->get(i))
962 return false;
963 }
964 return true;
965 }
966
967 void tst_QQuickRepeater::objectModel()
968 {
969 QQmlEngine engine;
970 QQmlComponent component(&engine, testFileUrl("objectmodel.qml"));
971
972 QQuickItem *positioner = qobject_cast<QQuickItem *>(component.create());
973 QVERIFY(positioner);
974
975 QQuickRepeater *repeater = findItem<QQuickRepeater>(positioner, "repeater");
976 QVERIFY(repeater);
977
978 QQmlObjectModel *model = repeater->model().value<QQmlObjectModel *>();
979 QVERIFY(model);
980
981 QVERIFY(repeater->itemAt(0));
982 QVERIFY(repeater->itemAt(1));
983 QVERIFY(repeater->itemAt(2));
984 QCOMPARE(repeater->itemAt(0)->property("color").toString(), QColor("red").name());
985 QCOMPARE(repeater->itemAt(1)->property("color").toString(), QColor("green").name());
986 QCOMPARE(repeater->itemAt(2)->property("color").toString(), QColor("blue").name());
987
988 QQuickItem *item0 = new QQuickItem(positioner);
989 item0->setSize(QSizeF(20, 20));
990 model->append(item0);
991 QCOMPARE(model->count(), 4);
992 QVERIFY(compareObjectModel(repeater, model));
993
994 QQuickItem *item1 = new QQuickItem(positioner);
995 item1->setSize(QSizeF(20, 20));
996 model->insert(0, item1);
997 QCOMPARE(model->count(), 5);
998 QVERIFY(compareObjectModel(repeater, model));
999
1000 model->move(1, 2, 3);
1001 QVERIFY(compareObjectModel(repeater, model));
1002
1003 model->remove(2, 2);
1004 QCOMPARE(model->count(), 3);
1005 QVERIFY(compareObjectModel(repeater, model));
1006
1007 model->clear();
1008 QCOMPARE(model->count(), 0);
1009 QCOMPARE(repeater->count(), 0);
1010
1011 delete positioner;
1012 }
1013
1014 class Ctrl : public QObject
1015 {
1016 Q_OBJECT
1017 public:
1018
1019 Q_INVOKABLE void wait()
1020 {
1021 QTest::qWait(200);
1022 }
1023 };
1024
1025 void tst_QQuickRepeater::QTBUG54859_asynchronousMove()
1026 {
1027 Ctrl ctrl;
1028 QQuickView* view = createView();
1029 view->rootContext()->setContextProperty("ctrl", &ctrl);
1030 view->setSource(testFileUrl("asynchronousMove.qml"));
1031 view->show();
1032 QQuickItem* item = view->rootObject();
1033
1034
1035 QTRY_COMPARE(item->property("finished"), QVariant(true));
1036 }
1037
1038 void tst_QQuickRepeater::package()
1039 {
1040 QQmlEngine engine;
1041 QQmlComponent component(&engine, testFileUrl("package.qml"));
1042
1043 QScopedPointer<QObject>o(component.create()); // don't crash!
1044 QVERIFY(o != nullptr);
1045
1046 {
1047 QQuickRepeater *repeater1 = qobject_cast<QQuickRepeater*>(qmlContext(o.data())->contextProperty("repeater1").value<QObject*>());
1048 QVERIFY(repeater1);
1049 QCOMPARE(repeater1->count(), 1);
1050 QCOMPARE(repeater1->itemAt(0)->objectName(), "firstItem");
1051 }
1052
1053 {
1054 QQuickRepeater *repeater2 = qobject_cast<QQuickRepeater*>(qmlContext(o.data())->contextProperty("repeater2").value<QObject*>());
1055 QVERIFY(repeater2);
1056 QCOMPARE(repeater2->count(), 1);
1057 QCOMPARE(repeater2->itemAt(0)->objectName(), "secondItem");
1058 }
1059
1060 {
1061 QQmlComponent component(&engine, testFileUrl("package2.qml"));
1062 QScopedPointer<QObject> root(component.create());
1063 QVERIFY(root != nullptr);
1064 bool returnedValue = false;
1065 // calling setup should not crash
1066 QMetaObject::invokeMethod(root.get(), "setup", Q_RETURN_ARG(bool, returnedValue));
1067 QVERIFY(returnedValue);
1068 }
1069 }
1070
1071 void tst_QQuickRepeater::ownership()
1072 {
1073 QQmlEngine engine;
1074
1075 QQmlComponent component(&engine, testFileUrl("ownership.qml"));
1076
1077 QScopedPointer<QAbstractItemModel> aim(new QStandardItemModel);
1078 QPointer<QAbstractItemModel> modelGuard(aim.data());
1079 QQmlEngine::setObjectOwnership(aim.data(), QQmlEngine::JavaScriptOwnership);
1080 {
1081 QJSValue wrapper = engine.newQObject(aim.data());
1082 }
1083
1084 QScopedPointer<QObject> repeater(component.create());
1085 QVERIFY(!repeater.isNull());
1086
1087 QVERIFY(!QQmlData::keepAliveDuringGarbageCollection(aim.data()));
1088
1089 repeater->setProperty("model", QVariant::fromValue<QObject*>(aim.data()));
1090
1091 QVERIFY(!QQmlData::keepAliveDuringGarbageCollection(aim.data()));
1092
1093 engine.collectGarbage();
1094 QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
1095
1096 QVERIFY(modelGuard);
1097
1098 QScopedPointer<QQmlComponent> delegate(new QQmlComponent(&engine));
1099 delegate->setData(QByteArrayLiteral("import QtQuick 2.0\nItem{}"), dataDirectoryUrl().resolved(QUrl("inline.qml")));
1100 QPointer<QQmlComponent> delegateGuard(delegate.data());
1101 QQmlEngine::setObjectOwnership(delegate.data(), QQmlEngine::JavaScriptOwnership);
1102 {
1103 QJSValue wrapper = engine.newQObject(delegate.data());
1104 }
1105
1106 QVERIFY(!QQmlData::keepAliveDuringGarbageCollection(delegate.data()));
1107
1108 repeater->setProperty("delegate", QVariant::fromValue<QObject*>(delegate.data()));
1109
1110 QVERIFY(!QQmlData::keepAliveDuringGarbageCollection(delegate.data()));
1111
1112 engine.collectGarbage();
1113 QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
1114
1115 QVERIFY(delegateGuard);
1116
1117 repeater->setProperty("model", QVariant());
1118 repeater->setProperty("delegate", QVariant());
1119
1120 QVERIFY(delegateGuard);
1121 QVERIFY(modelGuard);
1122
1123 delegate.take();
1124 aim.take();
1125
1126 engine.collectGarbage();
1127 QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
1128
1129 QVERIFY(!delegateGuard);
1130 QVERIFY(!modelGuard);
1131 }
1132
1133 void tst_QQuickRepeater::requiredProperties()
1134 {
1135 QTest::ignoreMessage(QtMsgType::QtInfoMsg, "apples0");
1136 QTest::ignoreMessage(QtMsgType::QtInfoMsg, "oranges1");
1137 QTest::ignoreMessage(QtMsgType::QtInfoMsg, "pears2");
1138 QQmlEngine engine;
1139
1140 QQmlComponent component(&engine, testFileUrl("requiredProperty.qml"));
1141 QScopedPointer<QObject> o {component.create()};
1142 QVERIFY(o);
1143 }
1144
1145 void tst_QQuickRepeater::contextProperties()
1146 {
1147 QQmlEngine engine;
1148
1149 QQmlComponent component(&engine, testFileUrl("contextProperty.qml"));
1150 QScopedPointer<QObject> o {component.create()};
1151 QVERIFY(o);
1152
1153 auto *root = qobject_cast<QQuickItem *>(o.get());
1154 QVERIFY(root);
1155
1156 QQueue<QQuickItem *> items;
1157 items.append(root);
1158
1159 while (!items.isEmpty()) {
1160 QQuickItem *item = items.dequeue();
1161 QQmlContextData *data = QQmlContextData::get(qmlContext(item));
1162 QVERIFY(!data->hasExtraObject);
1163 for (QQuickItem *child : item->childItems())
1164 items.enqueue(child);
1165 }
1166 }
1167
1168 QTEST_MAIN(tst_QQuickRepeater)
1169
1170 #include "tst_qquickrepeater.moc"