Debian Codegraph @

tests/auto/gui/itemmodels/qstandarditemmodel/tst_qstandarditemmodel.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
30 #include <QtTest/QtTest>
31
32 #include <QStandardItemModel>
33 #include <QTreeView>
34 #include <private/qtreeview_p.h>
35
36 class tst_QStandardItemModel : public QObject
37 {
38 Q_OBJECT
39
40 public:
41 tst_QStandardItemModel();
42
43 enum ModelChanged {
44 RowsAboutToBeInserted,
45 RowsInserted,
46 RowsAboutToBeRemoved,
47 RowsRemoved,
48 ColumnsAboutToBeInserted,
49 ColumnsInserted,
50 ColumnsAboutToBeRemoved,
51 ColumnsRemoved
52 };
53
54 public slots:
55 void init();
56 void cleanup();
57
58 protected slots:
59 void checkAboutToBeRemoved();
60 void checkRemoved();
61 void updateRowAboutToBeRemoved();
62
63 void rowsAboutToBeInserted(const QModelIndex &parent, int first, int last)
64 { modelChanged(RowsAboutToBeInserted, parent, first, last); }
65 void rowsInserted(const QModelIndex &parent, int first, int last)
66 { modelChanged(RowsInserted, parent, first, last); }
67 void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
68 { modelChanged(RowsAboutToBeRemoved, parent, first, last); }
69 void rowsRemoved(const QModelIndex &parent, int first, int last)
70 { modelChanged(RowsRemoved, parent, first, last); }
71 void columnsAboutToBeInserted(const QModelIndex &parent, int first, int last)
72 { modelChanged(ColumnsAboutToBeInserted, parent, first, last); }
73 void columnsInserted(const QModelIndex &parent, int first, int last)
74 { modelChanged(ColumnsInserted, parent, first, last); }
75 void columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
76 { modelChanged(ColumnsAboutToBeRemoved, parent, first, last); }
77 void columnsRemoved(const QModelIndex &parent, int first, int last)
78 { modelChanged(ColumnsRemoved, parent, first, last); }
79
80 void modelChanged(ModelChanged change, const QModelIndex &parent, int first, int last);
81
82 private slots:
83 void insertRow_data();
84 void insertRow();
85 void insertRows();
86 void insertRowsItems();
87 void insertRowInHierarcy();
88 void insertColumn_data();
89 void insertColumn();
90 void insertColumns();
91 void removeRows();
92 void removeColumns();
93 void setHeaderData();
94 void persistentIndexes();
95 void removingPersistentIndexes();
96 void updatingPersistentIndexes();
97
98 void checkChildren();
99 void data();
100 void clear();
101 void clearItemData();
102 void sort_data();
103 void sort();
104 void sortRole_data();
105 void sortRole();
106 void findItems();
107 void getSetHeaderItem();
108 void indexFromItem();
109 void itemFromIndex();
110 void getSetItemPrototype();
111 void getSetItemData();
112 void setHeaderLabels_data();
113 void setHeaderLabels();
114 void itemDataChanged();
115 void takeHeaderItem();
116 void useCase1();
117 void useCase2();
118 void useCase3();
119
120 void setNullChild();
121 void deleteChild();
122
123 void rootItemFlags();
124 #ifdef QT_BUILD_INTERNAL
125 void treeDragAndDrop();
126 #endif
127 void removeRowsAndColumns();
128
129 void itemRoleNames();
130 void getMimeDataWithInvalidModelIndex();
131 void supportedDragDropActions();
132
133 void taskQTBUG_45114_setItemData();
134 void setItemPersistentIndex();
135
136 private:
137 QStandardItemModel *m_model = nullptr;
138 QPersistentModelIndex persistent;
139 QVector<QModelIndex> rcParent = QVector<QModelIndex>(8);
140 QVector<int> rcFirst = QVector<int>(8, 0);
141 QVector<int> rcLast = QVector<int>(8, 0);
142 QVector<int> currentRoles;
143
144 //return true if models have the same structure, and all child have the same text
145 static bool compareModels(QStandardItemModel *model1, QStandardItemModel *model2);
146 //return true if models have the same structure, and all child have the same text
147 static bool compareItems(QStandardItem *item1, QStandardItem *item2);
148 };
149
150 static constexpr int defaultSize = 3;
151
152 Q_DECLARE_METATYPE(QStandardItem*)
153 Q_DECLARE_METATYPE(Qt::Orientation)
154
155 tst_QStandardItemModel::tst_QStandardItemModel()
156 {
157 qRegisterMetaType<QStandardItem*>("QStandardItem*");
158 qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
159 qRegisterMetaType<QAbstractItemModel::LayoutChangeHint>("QAbstractItemModel::LayoutChangeHint");
160 qRegisterMetaType<QList<QPersistentModelIndex>>("QList<QPersistentModelIndex>");
161 }
162
163 /*
164 This test usually uses a model with a 3x3 table
165 ---------------------------
166 | 0,0 | 0,1 | 0,2 |
167 ---------------------------
168 | 1,0 | 1,1 | 1,2 |
169 ---------------------------
170 | 2,0 | 2,1 | 2,2 |
171 ---------------------------
172 */
173 void tst_QStandardItemModel::init()
174 {
175 m_model = new QStandardItemModel(defaultSize, defaultSize);
176 connect(m_model, &QStandardItemModel::rowsAboutToBeInserted,
177 this, &tst_QStandardItemModel::rowsAboutToBeInserted);
178 connect(m_model, &QStandardItemModel::rowsInserted,
179 this, &tst_QStandardItemModel::rowsInserted);
180 connect(m_model, &QStandardItemModel::rowsAboutToBeRemoved,
181 this, &tst_QStandardItemModel::rowsAboutToBeRemoved);
182 connect(m_model, &QStandardItemModel::rowsRemoved,
183 this, &tst_QStandardItemModel::rowsRemoved);
184
185 connect(m_model, &QStandardItemModel::columnsAboutToBeInserted,
186 this, &tst_QStandardItemModel::columnsAboutToBeInserted);
187 connect(m_model, &QStandardItemModel::columnsInserted,
188 this, &tst_QStandardItemModel::columnsInserted);
189 connect(m_model, &QStandardItemModel::columnsAboutToBeRemoved,
190 this, &tst_QStandardItemModel::columnsAboutToBeRemoved);
191 connect(m_model, &QStandardItemModel::columnsRemoved,
192 this, &tst_QStandardItemModel::columnsRemoved);
193
194 connect(m_model, &QAbstractItemModel::dataChanged,
195 this, [this](const QModelIndex &, const QModelIndex &, const QVector<int> &roles)
196 {
197 currentRoles = roles;
198 });
199
200 rcFirst.fill(-1);
201 rcLast.fill(-1);
202 }
203
204 void tst_QStandardItemModel::cleanup()
205 {
206 m_model->disconnect(this);
207 delete m_model;
208 m_model = nullptr;
209 }
210
211 void tst_QStandardItemModel::insertRow_data()
212 {
213 QTest::addColumn<int>("insertRow");
214 QTest::addColumn<int>("expectedRow");
215
216 QTest::newRow("Insert less then 0") << -1 << 0;
217 QTest::newRow("Insert at 0") << 0 << 0;
218 QTest::newRow("Insert beyond count") << defaultSize+1 << defaultSize;
219 QTest::newRow("Insert at count") << defaultSize << defaultSize;
220 QTest::newRow("Insert in the middle") << 1 << 1;
221 }
222
223 void tst_QStandardItemModel::insertRow()
224 {
225 QFETCH(int, insertRow);
226 QFETCH(int, expectedRow);
227
228 QIcon icon;
229 // default all initial items to DisplayRole: "initalitem"
230 for (int r = 0; r < m_model->rowCount(); ++r) {
231 for (int c = 0; c < m_model->columnCount(); ++c) {
232 m_model->setData(m_model->index(r, c), "initialitem", Qt::DisplayRole);
233 }
234 }
235
236 // check that inserts changes rowCount
237 QCOMPARE(m_model->rowCount(), defaultSize);
238 m_model->insertRow(insertRow);
239 if (insertRow >= 0 && insertRow <= defaultSize) {
240 QCOMPARE(m_model->rowCount(), defaultSize + 1);
241
242 // check that signals were emitted with correct info
243 QCOMPARE(rcFirst[RowsAboutToBeInserted], expectedRow);
244 QCOMPARE(rcLast[RowsAboutToBeInserted], expectedRow);
245 QCOMPARE(rcFirst[RowsInserted], expectedRow);
246 QCOMPARE(rcLast[RowsInserted], expectedRow);
247
248 //check that the inserted item has different DisplayRole than initial items
249 QVERIFY(m_model->data(m_model->index(expectedRow, 0), Qt::DisplayRole).toString() != QLatin1String("initialitem"));
250 } else {
251 // We inserted something outside the bounds, do nothing
252 QCOMPARE(m_model->rowCount(), defaultSize);
253 QCOMPARE(rcFirst[RowsAboutToBeInserted], -1);
254 QCOMPARE(rcLast[RowsAboutToBeInserted], -1);
255 QCOMPARE(rcFirst[RowsInserted], -1);
256 QCOMPARE(rcLast[RowsInserted], -1);
257 }
258 }
259
260 void tst_QStandardItemModel::insertRows()
261 {
262 int rowCount = m_model->rowCount();
263 QCOMPARE(rowCount, defaultSize);
264
265 // insert custom header label
266 QString headerLabel = "custom";
267 m_model->setHeaderData(0, Qt::Vertical, headerLabel);
268
269 // insert one row
270 m_model->insertRows(0, 1);
271 QCOMPARE(m_model->rowCount(), rowCount + 1);
272 rowCount = m_model->rowCount();
273
274 // check header data has moved
275 QCOMPARE(m_model->headerData(1, Qt::Vertical).toString(), headerLabel);
276
277 // insert two rows
278 m_model->insertRows(0, 2);
279 QCOMPARE(m_model->rowCount(), rowCount + 2);
280
281 // check header data has moved
282 QCOMPARE(m_model->headerData(3, Qt::Vertical).toString(), headerLabel);
283
284 // do not assert on empty list
285 QStandardItem *si = m_model->invisibleRootItem();
286 si->insertRow(0, QList<QStandardItem*>());
287 si->insertRows(0, 0);
288 si->insertRows(0, QList<QStandardItem*>());
289 }
290
291 void tst_QStandardItemModel::insertRowsItems()
292 {
293 int rowCount = m_model->rowCount();
294
295 QList<QStandardItem *> items;
296 QStandardItemModel *m = m_model;
297 QStandardItem *hiddenRoot = m->invisibleRootItem();
298 for (int i = 0; i < 3; ++i)
299 items.append(new QStandardItem(QString::number(i + 10)));
300 hiddenRoot->appendRows(items);
301 QCOMPARE(m_model->rowCount(), rowCount + 3);
302 QCOMPARE(m_model->index(rowCount + 0, 0).data().toInt(), 10);
303 QCOMPARE(m_model->index(rowCount + 1, 0).data().toInt(), 11);
304 QCOMPARE(m_model->index(rowCount + 2, 0).data().toInt(), 12);
305 for (int i = rowCount; i < rowCount + 3; ++i) {
306 QVERIFY(m->item(i));
307 QCOMPARE(m->item(i)->model(), m_model);
308 }
309 }
310
311 void tst_QStandardItemModel::insertRowInHierarcy()
312 {
313 QVERIFY(m_model->insertRows(0, 1, QModelIndex()));
314 QVERIFY(m_model->insertColumns(0, 1, QModelIndex()));
315 QVERIFY(m_model->hasIndex(0, 0, QModelIndex()));
316
317 QModelIndex parent = m_model->index(0, 0, QModelIndex());
318 QVERIFY(parent.isValid());
319
320 QVERIFY(m_model->insertRows(0, 1, parent));
321 QVERIFY(m_model->insertColumns(0, 1, parent));
322 QVERIFY(m_model->hasIndex(0, 0, parent));
323
324 QModelIndex child = m_model->index(0, 0, parent);
325 QVERIFY(child.isValid());
326 }
327
328 void tst_QStandardItemModel::insertColumn_data()
329 {
330 QTest::addColumn<int>("insertColumn");
331 QTest::addColumn<int>("expectedColumn");
332
333 QTest::newRow("Insert less then 0") << -1 << 0;
334 QTest::newRow("Insert at 0") << 0 << 0;
335 QTest::newRow("Insert beyond count") << defaultSize+1 << defaultSize;
336 QTest::newRow("Insert at count") << defaultSize << defaultSize;
337 QTest::newRow("Insert in the middle") << 1 << 1;
338 }
339
340 void tst_QStandardItemModel::insertColumn()
341 {
342 QFETCH(int, insertColumn);
343 QFETCH(int, expectedColumn);
344
345 // default all initial items to DisplayRole: "initalitem"
346 for (int r = 0; r < m_model->rowCount(); ++r) {
347 for (int c = 0; c < m_model->columnCount(); ++c) {
348 m_model->setData(m_model->index(r, c), "initialitem", Qt::DisplayRole);
349 }
350 }
351
352 // check that inserts changes columnCount
353 QCOMPARE(m_model->columnCount(), defaultSize);
354 m_model->insertColumn(insertColumn);
355 if (insertColumn >= 0 && insertColumn <= defaultSize) {
356 QCOMPARE(m_model->columnCount(), defaultSize + 1);
357 // check that signals were emitted with correct info
358 QCOMPARE(rcFirst[ColumnsAboutToBeInserted], expectedColumn);
359 QCOMPARE(rcLast[ColumnsAboutToBeInserted], expectedColumn);
360 QCOMPARE(rcFirst[ColumnsInserted], expectedColumn);
361 QCOMPARE(rcLast[ColumnsInserted], expectedColumn);
362
363 //check that the inserted item has different DisplayRole than initial items
364 QVERIFY(m_model->data(m_model->index(0, expectedColumn), Qt::DisplayRole).toString() != QLatin1String("initialitem"));
365 } else {
366 // We inserted something outside the bounds, do nothing
367 QCOMPARE(m_model->columnCount(), defaultSize);
368 QCOMPARE(rcFirst[ColumnsAboutToBeInserted], -1);
369 QCOMPARE(rcLast[ColumnsAboutToBeInserted], -1);
370 QCOMPARE(rcFirst[ColumnsInserted], -1);
371 QCOMPARE(rcLast[ColumnsInserted], -1);
372 }
373
374 }
375
376 void tst_QStandardItemModel::insertColumns()
377 {
378 int columnCount = m_model->columnCount();
379 QCOMPARE(columnCount, defaultSize);
380
381 // insert custom header label
382 QString headerLabel = "custom";
383 m_model->setHeaderData(0, Qt::Horizontal, headerLabel);
384
385 // insert one column
386 m_model->insertColumns(0, 1);
387 QCOMPARE(m_model->columnCount(), columnCount + 1);
388 columnCount = m_model->columnCount();
389
390 // check header data has moved
391 QCOMPARE(m_model->headerData(1, Qt::Horizontal).toString(), headerLabel);
392
393 // insert two columns
394 m_model->insertColumns(0, 2);
395 QCOMPARE(m_model->columnCount(), columnCount + 2);
396
397 // check header data has moved
398 QCOMPARE(m_model->headerData(3, Qt::Horizontal).toString(), headerLabel);
399
400 // do not assert on empty list
401 QStandardItem *si = m_model->invisibleRootItem();
402 si->insertColumn(0, QList<QStandardItem*>());
403 si->insertColumns(0, 0);
404 }
405
406 void tst_QStandardItemModel::removeRows()
407 {
408 int rowCount = m_model->rowCount();
409 QCOMPARE(rowCount, defaultSize);
410
411 // insert custom header label
412 QString headerLabel = "custom";
413 m_model->setHeaderData(rowCount - 1, Qt::Vertical, headerLabel);
414
415 // remove one row
416 m_model->removeRows(0, 1);
417 QCOMPARE(m_model->rowCount(), rowCount - 1);
418 rowCount = m_model->rowCount();
419
420 // check header data has moved
421 QCOMPARE(m_model->headerData(rowCount - 1, Qt::Vertical).toString(), headerLabel);
422
423 // remove two rows
424 m_model->removeRows(0, 2);
425 QCOMPARE(m_model->rowCount(), rowCount - 2);
426 }
427
428 void tst_QStandardItemModel::removeColumns()
429 {
430 int columnCount = m_model->columnCount();
431 QCOMPARE(columnCount, defaultSize);
432
433 // insert custom header label
434 QString headerLabel = "custom";
435 m_model->setHeaderData(columnCount - 1, Qt::Horizontal, headerLabel);
436
437 // remove one column
438 m_model->removeColumns(0, 1);
439 QCOMPARE(m_model->columnCount(), columnCount - 1);
440 columnCount = m_model->columnCount();
441
442 // check header data has moved
443 QCOMPARE(m_model->headerData(columnCount - 1, Qt::Horizontal).toString(), headerLabel);
444
445 // remove two columns
446 m_model->removeColumns(0, 2);
447 QCOMPARE(m_model->columnCount(), columnCount - 2);
448 }
449
450
451 void tst_QStandardItemModel::setHeaderData()
452 {
453 for (int x = 0; x < 2; ++x) {
454 bool vertical = (x == 0);
455 int count = vertical ? m_model->rowCount() : m_model->columnCount();
456 QCOMPARE(count, defaultSize);
457 Qt::Orientation orient = vertical ? Qt::Vertical : Qt::Horizontal;
458
459 // check default values are ok
460 for (int i = 0; i < count; ++i)
461 QCOMPARE(m_model->headerData(i, orient).toString(), QString::number(i + 1));
462
463 QSignalSpy headerDataChangedSpy(
464 m_model, &QAbstractItemModel::headerDataChanged);
465 QSignalSpy dataChangedSpy(
466 m_model, &QAbstractItemModel::dataChanged);
467 // insert custom values and check
468 for (int i = 0; i < count; ++i) {
469 QString customString = QString("custom") + QString::number(i);
470 QCOMPARE(m_model->setHeaderData(i, orient, customString), true);
471 QCOMPARE(headerDataChangedSpy.count(), 1);
472 QCOMPARE(dataChangedSpy.count(), 0);
473 QVariantList args = headerDataChangedSpy.takeFirst();
474 QCOMPARE(qvariant_cast<Qt::Orientation>(args.at(0)), orient);
475 QCOMPARE(args.at(1).toInt(), i);
476 QCOMPARE(args.at(2).toInt(), i);
477 QCOMPARE(m_model->headerData(i, orient).toString(), customString);
478 QCOMPARE(m_model->setHeaderData(i, orient, customString), true);
479 QCOMPARE(headerDataChangedSpy.count(), 0);
480 QCOMPARE(dataChangedSpy.count(), 0);
481 }
482
483 //check read from invalid sections
484 QVERIFY(!m_model->headerData(count, orient).isValid());
485 QVERIFY(!m_model->headerData(-1, orient).isValid());
486 //check write to invalid section
487 QCOMPARE(m_model->setHeaderData(count, orient, "foo"), false);
488 QCOMPARE(m_model->setHeaderData(-1, orient, "foo"), false);
489 QVERIFY(!m_model->headerData(count, orient).isValid());
490 QVERIFY(!m_model->headerData(-1, orient).isValid());
491 }
492 }
493
494 void tst_QStandardItemModel::persistentIndexes()
495 {
496 QCOMPARE(m_model->rowCount(), defaultSize);
497 QCOMPARE(m_model->columnCount(), defaultSize);
498
499 // create a persisten index at 0,0
500 QPersistentModelIndex persistentIndex(m_model->index(0, 0));
501
502 // verify it is ok and at the correct spot
503 QVERIFY(persistentIndex.isValid());
504 QCOMPARE(persistentIndex.row(), 0);
505 QCOMPARE(persistentIndex.column(), 0);
506
507 // insert row and check that the persisten index has moved
508 QVERIFY(m_model->insertRow(0));
509 QVERIFY(persistentIndex.isValid());
510 QCOMPARE(persistentIndex.row(), 1);
511 QCOMPARE(persistentIndex.column(), 0);
512
513 // insert row after the persisten index and see that it stays the same
514 QVERIFY(m_model->insertRow(m_model->rowCount()));
515 QVERIFY(persistentIndex.isValid());
516 QCOMPARE(persistentIndex.row(), 1);
517 QCOMPARE(persistentIndex.column(), 0);
518
519 // insert column and check that the persisten index has moved
520 QVERIFY(m_model->insertColumn(0));
521 QVERIFY(persistentIndex.isValid());
522 QCOMPARE(persistentIndex.row(), 1);
523 QCOMPARE(persistentIndex.column(), 1);
524
525 // insert column after the persisten index and see that it stays the same
526 QVERIFY(m_model->insertColumn(m_model->columnCount()));
527 QVERIFY(persistentIndex.isValid());
528 QCOMPARE(persistentIndex.row(), 1);
529 QCOMPARE(persistentIndex.column(), 1);
530
531 // removes a row beyond the persistent index and see it stays the same
532 QVERIFY(m_model->removeRow(m_model->rowCount() - 1));
533 QVERIFY(persistentIndex.isValid());
534 QCOMPARE(persistentIndex.row(), 1);
535 QCOMPARE(persistentIndex.column(), 1);
536
537 // removes a column beyond the persistent index and see it stays the same
538 QVERIFY(m_model->removeColumn(m_model->columnCount() - 1));
539 QVERIFY(persistentIndex.isValid());
540 QCOMPARE(persistentIndex.row(), 1);
541 QCOMPARE(persistentIndex.column(), 1);
542
543 // removes a row before the persistent index and see it moves the same
544 QVERIFY(m_model->removeRow(0));
545 QVERIFY(persistentIndex.isValid());
546 QCOMPARE(persistentIndex.row(), 0);
547 QCOMPARE(persistentIndex.column(), 1);
548
549 // removes a column before the persistent index and see it moves the same
550 QVERIFY(m_model->removeColumn(0));
551 QVERIFY(persistentIndex.isValid());
552 QCOMPARE(persistentIndex.row(), 0);
553 QCOMPARE(persistentIndex.column(), 0);
554
555 // remove the row where the persistent index is, and see that it becomes invalid
556 QVERIFY(m_model->removeRow(0));
557 QVERIFY(!persistentIndex.isValid());
558
559 // remove the row where the persistent index is, and see that it becomes invalid
560 persistentIndex = m_model->index(0, 0);
561 QVERIFY(persistentIndex.isValid());
562 QVERIFY(m_model->removeColumn(0));
563 QVERIFY(!persistentIndex.isValid());
564 }
565
566 void tst_QStandardItemModel::checkAboutToBeRemoved()
567 {
568 QVERIFY(persistent.isValid());
569 }
570
571 void tst_QStandardItemModel::checkRemoved()
572 {
573 QVERIFY(!persistent.isValid());
574 }
575
576 void tst_QStandardItemModel::removingPersistentIndexes()
577 {
578 // add 10 rows and columns to model to make it big enough
579 QVERIFY(m_model->insertRows(0, 10));
580 QVERIFY(m_model->insertColumns(0, 10));
581
582 connect(m_model, &QAbstractItemModel::rowsAboutToBeRemoved,
583 this, &tst_QStandardItemModel::checkAboutToBeRemoved);
584 connect(m_model, &QAbstractItemModel::rowsRemoved,
585 this, &tst_QStandardItemModel::checkRemoved);
586 connect(m_model, &QAbstractItemModel::columnsAboutToBeRemoved,
587 this, &tst_QStandardItemModel::checkAboutToBeRemoved);
588 connect(m_model, &QAbstractItemModel::columnsRemoved,
589 this, &tst_QStandardItemModel::checkRemoved);
590
591
592 // test removeRow
593 // add child table 3x3 to parent index(0, 0)
594 QVERIFY(m_model->insertRows(0, 3, m_model->index(0, 0)));
595 QVERIFY(m_model->insertColumns(0, 3, m_model->index(0, 0)));
596
597 // set child to persistent and delete parent row
598 persistent = m_model->index(0, 0, m_model->index(0, 0));
599 QVERIFY(persistent.isValid());
600 QVERIFY(m_model->removeRow(0));
601
602 // set persistent to index(0, 0) and remove that row
603 persistent = m_model->index(0, 0);
604 QVERIFY(persistent.isValid());
605 QVERIFY(m_model->removeRow(0));
606
607
608 // test removeColumn
609 // add child table 3x3 to parent index (0, 0)
610 QVERIFY(m_model->insertRows(0, 3, m_model->index(0, 0)));
611 QVERIFY(m_model->insertColumns(0, 3, m_model->index(0, 0)));
612
613 // set child to persistent and delete parent column
614 persistent = m_model->index(0, 0, m_model->index(0, 0));
615 QVERIFY(persistent.isValid());
616 QVERIFY(m_model->removeColumn(0));
617
618 // set persistent to index(0, 0) and remove that column
619 persistent = m_model->index(0, 0);
620 QVERIFY(persistent.isValid());
621 QVERIFY(m_model->removeColumn(0));
622
623
624 disconnect(m_model, &QAbstractItemModel::rowsAboutToBeRemoved,
625 this, &tst_QStandardItemModel::checkAboutToBeRemoved);
626 disconnect(m_model, &QAbstractItemModel::rowsRemoved,
627 this, &tst_QStandardItemModel::checkRemoved);
628 disconnect(m_model, &QAbstractItemModel::columnsAboutToBeRemoved,
629 this, &tst_QStandardItemModel::checkAboutToBeRemoved);
630 disconnect(m_model, &QAbstractItemModel::columnsRemoved,
631 this, &tst_QStandardItemModel::checkRemoved);
632 }
633
634 void tst_QStandardItemModel::updateRowAboutToBeRemoved()
635 {
636 QModelIndex idx = m_model->index(0, 0);
637 QVERIFY(idx.isValid());
638 persistent = idx;
639 }
640
641 void tst_QStandardItemModel::updatingPersistentIndexes()
642 {
643 connect(m_model, &QAbstractItemModel::rowsAboutToBeRemoved,
644 this, &tst_QStandardItemModel::updateRowAboutToBeRemoved);
645
646 persistent = m_model->index(1, 0);
647 QVERIFY(persistent.isValid());
648 QVERIFY(m_model->removeRow(1));
649 QVERIFY(persistent.isValid());
650 QPersistentModelIndex tmp = m_model->index(0, 0);
651 QCOMPARE(persistent, tmp);
652
653 disconnect(m_model, &QAbstractItemModel::rowsAboutToBeRemoved,
654 this, &tst_QStandardItemModel::updateRowAboutToBeRemoved);
655 }
656
657 void tst_QStandardItemModel::modelChanged(ModelChanged change, const QModelIndex &parent,
658 int first, int last)
659 {
660 rcParent[change] = parent;
661 rcFirst[change] = first;
662 rcLast[change] = last;
663 }
664
665
666 void tst_QStandardItemModel::checkChildren()
667 {
668 QStandardItemModel model(0, 0);
669 QCOMPARE(model.rowCount(), 0);
670 QCOMPARE(model.columnCount(), 0);
671 QVERIFY(!model.hasChildren());
672
673 QVERIFY(model.insertRows(0, 1));
674 QVERIFY(!model.hasChildren());
675 QCOMPARE(model.rowCount(), 1);
676 QCOMPARE(model.columnCount(), 0);
677
678 QVERIFY(model.insertColumns(0, 1));
679 QVERIFY(model.hasChildren());
680 QCOMPARE(model.rowCount(), 1);
681 QCOMPARE(model.columnCount(), 1);
682
683 QModelIndex idx = model.index(0, 0);
684 QVERIFY(!model.hasChildren(idx));
685 QCOMPARE(model.rowCount(idx), 0);
686 QCOMPARE(model.columnCount(idx), 0);
687
688 QVERIFY(model.insertRows(0, 1, idx));
689 QVERIFY(!model.hasChildren(idx));
690 QCOMPARE(model.rowCount(idx), 1);
691 QCOMPARE(model.columnCount(idx), 0);
692
693 QVERIFY(model.insertColumns(0, 1, idx));
694 QVERIFY(model.hasChildren(idx));
695 QCOMPARE(model.rowCount(idx), 1);
696 QCOMPARE(model.columnCount(idx), 1);
697
698 QModelIndex idx2 = model.index(0, 0, idx);
699 QVERIFY(!model.hasChildren(idx2));
700 QCOMPARE(model.rowCount(idx2), 0);
701 QCOMPARE(model.columnCount(idx2), 0);
702
703 QVERIFY(model.removeRows(0, 1, idx));
704 QVERIFY(model.hasChildren());
705 QCOMPARE(model.rowCount(), 1);
706 QCOMPARE(model.columnCount(), 1);
707 QVERIFY(!model.hasChildren(idx));
708 QCOMPARE(model.rowCount(idx), 0);
709 QCOMPARE(model.columnCount(idx), 1);
710
711 QVERIFY(model.removeRows(0, 1));
712 QVERIFY(!model.hasChildren());
713 QCOMPARE(model.rowCount(), 0);
714 QCOMPARE(model.columnCount(), 1);
715
716 QVERIFY(!model.index(0,0).sibling(100,100).isValid());
717 }
718
719 void tst_QStandardItemModel::data()
720 {
721 currentRoles.clear();
722 // bad args
723 m_model->setData(QModelIndex(), "bla", Qt::DisplayRole);
724 QVERIFY(currentRoles.isEmpty());
725
726 QIcon icon;
727 for (int r = 0; r < m_model->rowCount(); ++r) {
728 for (int c = 0; c < m_model->columnCount(); ++c) {
729 m_model->setData(m_model->index(r,c), "initialitem", Qt::DisplayRole);
730 QCOMPARE(currentRoles, QVector<int>({Qt::DisplayRole, Qt::EditRole}));
731 m_model->setData(m_model->index(r,c), "tooltip", Qt::ToolTipRole);
732 QCOMPARE(currentRoles, QVector<int>{Qt::ToolTipRole});
733 m_model->setData(m_model->index(r,c), icon, Qt::DecorationRole);
734 QCOMPARE(currentRoles, QVector<int>{Qt::DecorationRole});
735 }
736 }
737
738 QCOMPARE(m_model->data(m_model->index(0, 0), Qt::DisplayRole).toString(), QLatin1String("initialitem"));
739 QCOMPARE(m_model->data(m_model->index(0, 0), Qt::ToolTipRole).toString(), QLatin1String("tooltip"));
740 const QMap<int, QVariant> itmData = m_model->itemData(m_model->index(0, 0));
741 QCOMPARE(itmData.value(Qt::DisplayRole), QLatin1String("initialitem"));
742 QCOMPARE(itmData.value(Qt::ToolTipRole), QLatin1String("tooltip"));
743 QVERIFY(!itmData.contains(Qt::UserRole - 1));
744 QVERIFY(m_model->itemData(QModelIndex()).isEmpty());
745 }
746
747 void tst_QStandardItemModel::clearItemData()
748 {
749 currentRoles.clear();
750 QVERIFY(!m_model->clearItemData(QModelIndex()));
751 QVERIFY(currentRoles.isEmpty());
752 const QModelIndex idx = m_model->index(0, 0);
753 const QMap<int, QVariant> oldData = m_model->itemData(idx);
754 m_model->setData(idx, QLatin1String("initialitem"), Qt::DisplayRole);
755 m_model->setData(idx, QLatin1String("tooltip"), Qt::ToolTipRole);
756 m_model->setData(idx, 5, Qt::UserRole);
757 currentRoles.clear();
758 QVERIFY(m_model->clearItemData(idx));
759 QCOMPARE(idx.data(Qt::UserRole), QVariant());
760 QCOMPARE(idx.data(Qt::ToolTipRole), QVariant());
761 QCOMPARE(idx.data(Qt::DisplayRole), QVariant());
762 QCOMPARE(idx.data(Qt::EditRole), QVariant());
763 QVERIFY(currentRoles.isEmpty());
764 m_model->setItemData(idx, oldData);
765 currentRoles.clear();
766 }
767
768 void tst_QStandardItemModel::clear()
769 {
770 QStandardItemModel model;
771 model.insertColumns(0, 10);
772 model.insertRows(0, 10);
773 QCOMPARE(model.columnCount(), 10);
774 QCOMPARE(model.rowCount(), 10);
775
776 QSignalSpy modelResetSpy(&model, &QStandardItemModel::modelReset);
777 QSignalSpy layoutChangedSpy(&model, &QStandardItemModel::layoutChanged);
778 QSignalSpy rowsRemovedSpy(&model, &QStandardItemModel::rowsRemoved);
779
780 QAbstractItemModelTester mt(&model);
781
782 model.clear();
783
784 QCOMPARE(modelResetSpy.count(), 1);
785 QCOMPARE(layoutChangedSpy.count(), 0);
786 QCOMPARE(rowsRemovedSpy.count(), 0);
787 QCOMPARE(model.index(0, 0), QModelIndex());
788 QCOMPARE(model.columnCount(), 0);
789 QCOMPARE(model.rowCount(), 0);
790 QCOMPARE(model.hasChildren(), false);
791 }
792
793 void tst_QStandardItemModel::sort_data()
794 {
795 QTest::addColumn<Qt::SortOrder>("sortOrder");
796 QTest::addColumn<QStringList>("initial");
797 QTest::addColumn<QStringList>("expected");
798
799 const QStringList unsorted(
800 {"delta", "yankee", "bravo", "lima", "charlie", "juliet",
801 "tango", "hotel", "uniform", "alpha", "echo", "golf",
802 "quebec", "foxtrot", "india", "romeo", "november",
803 "oskar", "zulu", "kilo", "whiskey", "mike", "papa",
804 "sierra", "xray" , "viktor"});
805 QStringList sorted = unsorted;
806
807 std::sort(sorted.begin(), sorted.end());
808 QTest::newRow("flat ascending") << Qt::AscendingOrder
809 << unsorted
810 << sorted;
811 std::reverse(sorted.begin(), sorted.end());
812 QTest::newRow("flat descending") << Qt::DescendingOrder
813 << unsorted
814 << sorted;
815 QStringList list;
816 for (int i = 1000; i < 2000; ++i)
817 list.append(QStringLiteral("Number: ") + QString::number(i));
818 QTest::newRow("large set ascending") << Qt::AscendingOrder << list << list;
819 }
820
821 void tst_QStandardItemModel::sort()
822 {
823 QFETCH(Qt::SortOrder, sortOrder);
824 QFETCH(QStringList, initial);
825 QFETCH(QStringList, expected);
826 // prepare model
827 QStandardItemModel model;
828 QVERIFY(model.insertRows(0, initial.count(), QModelIndex()));
829 QCOMPARE(model.rowCount(QModelIndex()), initial.count());
830 model.insertColumns(0, 1, QModelIndex());
831 QCOMPARE(model.columnCount(QModelIndex()), 1);
832 for (int row = 0; row < model.rowCount(QModelIndex()); ++row) {
833 QModelIndex index = model.index(row, 0, QModelIndex());
834 model.setData(index, initial.at(row), Qt::DisplayRole);
835 }
836
837 QSignalSpy layoutAboutToBeChangedSpy(
838 &model, &QStandardItemModel::layoutAboutToBeChanged);
839 QSignalSpy layoutChangedSpy(
840 &model, &QStandardItemModel::layoutChanged);
841
842 // sort
843 model.sort(0, sortOrder);
844
845 QCOMPARE(layoutAboutToBeChangedSpy.count(), 1);
846 QCOMPARE(layoutChangedSpy.count(), 1);
847
848 // make sure the model is sorted
849 for (int row = 0; row < model.rowCount(QModelIndex()); ++row) {
850 QModelIndex index = model.index(row, 0, QModelIndex());
851 QCOMPARE(model.data(index, Qt::DisplayRole).toString(), expected.at(row));
852 }
853 }
854
855 void tst_QStandardItemModel::sortRole_data()
856 {
857 QTest::addColumn<QStringList>("initialText");
858 QTest::addColumn<QVariantList>("initialData");
859 QTest::addColumn<Qt::ItemDataRole>("sortRole");
860 QTest::addColumn<Qt::SortOrder>("sortOrder");
861 QTest::addColumn<QStringList>("expectedText");
862 QTest::addColumn<QVariantList>("expectedData");
863
864 QTest::newRow("sort ascending with Qt::DisplayRole")
865 << (QStringList() << "b" << "a" << "c")
866 << (QVariantList() << 2 << 3 << 1)
867 << Qt::DisplayRole
868 << Qt::AscendingOrder
869 << (QStringList() << "a" << "b" << "c")
870 << (QVariantList() << 3 << 2 << 1);
871 QTest::newRow("sort ascending with Qt::UserRole")
872 << (QStringList() << "a" << "b" << "c")
873 << (QVariantList() << 3 << 2 << 1)
874 << Qt::UserRole
875 << Qt::AscendingOrder
876 << (QStringList() << "c" << "b" << "a")
877 << (QVariantList() << 1 << 2 << 3);
878 }
879
880 void tst_QStandardItemModel::sortRole()
881 {
882 QFETCH(QStringList, initialText);
883 QFETCH(QVariantList, initialData);
884 QFETCH(Qt::ItemDataRole, sortRole);
885 QFETCH(Qt::SortOrder, sortOrder);
886 QFETCH(QStringList, expectedText);
887 QFETCH(QVariantList, expectedData);
888
889 QStandardItemModel model;
890 for (int i = 0; i < initialText.count(); ++i) {
891 QStandardItem *item = new QStandardItem;
892 item->setText(initialText.at(i));
893 item->setData(initialData.at(i), Qt::UserRole);
894 model.appendRow(item);
895 }
896 model.setSortRole(sortRole);
897 model.sort(0, sortOrder);
898 for (int i = 0; i < expectedText.count(); ++i) {
899 QStandardItem *item = model.item(i);
900 QCOMPARE(item->text(), expectedText.at(i));
901 QCOMPARE(item->data(Qt::UserRole), expectedData.at(i));
902 }
903 }
904
905 void tst_QStandardItemModel::findItems()
906 {
907 QStandardItemModel model;
908 model.appendRow(new QStandardItem(QLatin1String("foo")));
909 model.appendRow(new QStandardItem(QLatin1String("bar")));
910 model.item(1)->appendRow(new QStandardItem(QLatin1String("foo")));
911 QList<QStandardItem*> matches;
912 matches = model.findItems(QLatin1String("foo"), Qt::MatchExactly|Qt::MatchRecursive, 0);
913 QCOMPARE(matches.count(), 2);
914 matches = model.findItems(QLatin1String("foo"), Qt::MatchExactly, 0);
915 QCOMPARE(matches.count(), 1);
916 matches = model.findItems(QLatin1String("food"), Qt::MatchExactly|Qt::MatchRecursive, 0);
917 QCOMPARE(matches.count(), 0);
918 matches = model.findItems(QLatin1String("foo"), Qt::MatchExactly|Qt::MatchRecursive, -1);
919 QCOMPARE(matches.count(), 0);
920 matches = model.findItems(QLatin1String("foo"), Qt::MatchExactly|Qt::MatchRecursive, 1);
921 QCOMPARE(matches.count(), 0);
922 }
923
924 void tst_QStandardItemModel::getSetHeaderItem()
925 {
926 QStandardItemModel model;
927
928 QCOMPARE(model.horizontalHeaderItem(0), nullptr);
929 QStandardItem *hheader = new QStandardItem();
930 model.setHorizontalHeaderItem(0, hheader);
931 QCOMPARE(model.columnCount(), 1);
932 QCOMPARE(model.horizontalHeaderItem(0), hheader);
933 QCOMPARE(hheader->model(), &model);
934 model.setHorizontalHeaderItem(0, nullptr);
935 QCOMPARE(model.horizontalHeaderItem(0), nullptr);
936
937 QCOMPARE(model.verticalHeaderItem(0), nullptr);
938 QStandardItem *vheader = new QStandardItem();
939 model.setVerticalHeaderItem(0, vheader);
940 QCOMPARE(model.rowCount(), 1);
941 QCOMPARE(model.verticalHeaderItem(0), vheader);
942 QCOMPARE(vheader->model(), &model);
943 model.setVerticalHeaderItem(0, nullptr);
944 QCOMPARE(model.verticalHeaderItem(0), nullptr);
945 }
946
947 void tst_QStandardItemModel::indexFromItem()
948 {
949 QStandardItemModel model;
950
951 QCOMPARE(model.indexFromItem(model.invisibleRootItem()), QModelIndex());
952
953 QStandardItem *item = new QStandardItem;
954 model.setItem(10, 20, item);
955 QCOMPARE(item->model(), &model);
956 QModelIndex itemIndex = model.indexFromItem(item);
957 QVERIFY(itemIndex.isValid());
958 QCOMPARE(itemIndex.row(), 10);
959 QCOMPARE(itemIndex.column(), 20);
960 QCOMPARE(itemIndex.parent(), QModelIndex());
961 QCOMPARE(itemIndex.model(), &model);
962
963 QStandardItem *child = new QStandardItem;
964 item->setChild(4, 2, child);
965 QModelIndex childIndex = model.indexFromItem(child);
966 QVERIFY(childIndex.isValid());
967 QCOMPARE(childIndex.row(), 4);
968 QCOMPARE(childIndex.column(), 2);
969 QCOMPARE(childIndex.parent(), itemIndex);
970
971 QStandardItem *dummy = new QStandardItem;
972 QModelIndex noSuchIndex = model.indexFromItem(dummy);
973 QVERIFY(!noSuchIndex.isValid());
974 delete dummy;
975
976 noSuchIndex = model.indexFromItem(nullptr);
977 QVERIFY(!noSuchIndex.isValid());
978 }
979
980 void tst_QStandardItemModel::itemFromIndex()
981 {
982 QStandardItemModel model;
983
984 QCOMPARE(model.itemFromIndex(QModelIndex()), nullptr);
985
986 QStandardItem *item = new QStandardItem;
987 model.setItem(10, 20, item);
988 QModelIndex itemIndex = model.index(10, 20, QModelIndex());
989 QVERIFY(itemIndex.isValid());
990 QCOMPARE(model.itemFromIndex(itemIndex), item);
991
992 QStandardItem *child = new QStandardItem;
993 item->setChild(4, 2, child);
994 QModelIndex childIndex = model.index(4, 2, itemIndex);
995 QVERIFY(childIndex.isValid());
996 QCOMPARE(model.itemFromIndex(childIndex), child);
997
998 QModelIndex noSuchIndex = model.index(99, 99, itemIndex);
999 QVERIFY(!noSuchIndex.isValid());
1000 }
1001
1002 class CustomItem : public QStandardItem
1003 {
1004 public:
1005 using QStandardItem::QStandardItem;
1006
1007 int type() const override { return UserType; }
1008 QStandardItem *clone() const override { return new CustomItem; }
1009 };
1010
1011 void tst_QStandardItemModel::getSetItemPrototype()
1012 {
1013 QStandardItemModel model;
1014 QCOMPARE(model.itemPrototype(), nullptr);
1015
1016 const CustomItem *proto = new CustomItem;
1017 model.setItemPrototype(proto);
1018 QCOMPARE(model.itemPrototype(), proto);
1019
1020 model.setRowCount(1);
1021 model.setColumnCount(1);
1022 QModelIndex index = model.index(0, 0, QModelIndex());
1023 model.setData(index, "foo");
1024 QStandardItem *item = model.itemFromIndex(index);
1025 QVERIFY(item != nullptr);
1026 QCOMPARE(item->type(), static_cast<int>(QStandardItem::UserType));
1027
1028 model.setItemPrototype(nullptr);
1029 QCOMPARE(model.itemPrototype(), nullptr);
1030 }
1031
1032 void tst_QStandardItemModel::getSetItemData()
1033 {
1034 QMap<int, QVariant> roles;
1035 QLatin1String text("text");
1036 roles.insert(Qt::DisplayRole, text);
1037 QLatin1String statusTip("statusTip");
1038 roles.insert(Qt::StatusTipRole, statusTip);
1039 QLatin1String toolTip("toolTip");
1040 roles.insert(Qt::ToolTipRole, toolTip);
1041 QLatin1String whatsThis("whatsThis");
1042 roles.insert(Qt::WhatsThisRole, whatsThis);
1043 QSize sizeHint(64, 48);
1044 roles.insert(Qt::SizeHintRole, sizeHint);
1045 QFont font;
1046 roles.insert(Qt::FontRole, font);
1047 Qt::Alignment textAlignment(Qt::AlignLeft|Qt::AlignVCenter);
1048 roles.insert(Qt::TextAlignmentRole, int(textAlignment));
1049 QColor backgroundColor(Qt::blue);
1050 roles.insert(Qt::BackgroundRole, backgroundColor);
1051 QColor textColor(Qt::green);
1052 roles.insert(Qt::ForegroundRole, textColor);
1053 Qt::CheckState checkState(Qt::PartiallyChecked);
1054 roles.insert(Qt::CheckStateRole, int(checkState));
1055 QLatin1String accessibleText("accessibleText");
1056 roles.insert(Qt::AccessibleTextRole, accessibleText);
1057 QLatin1String accessibleDescription("accessibleDescription");
1058 roles.insert(Qt::AccessibleDescriptionRole, accessibleDescription);
1059
1060 QStandardItemModel model;
1061 model.insertRows(0, 1);
1062 model.insertColumns(0, 1);
1063 QModelIndex idx = model.index(0, 0, QModelIndex());
1064
1065 QSignalSpy modelDataChangedSpy(
1066 &model, &QStandardItemModel::dataChanged);
1067 QVERIFY(model.setItemData(idx, roles));
1068 QCOMPARE(modelDataChangedSpy.count(), 1);
1069 QVERIFY(model.setItemData(idx, roles));
1070 QCOMPARE(modelDataChangedSpy.count(), 1); //it was already changed once
1071 QCOMPARE(model.itemData(idx), roles);
1072 }
1073
1074 void tst_QStandardItemModel::setHeaderLabels_data()
1075 {
1076 QTest::addColumn<int>("rows");
1077 QTest::addColumn<int>("columns");
1078 QTest::addColumn<Qt::Orientation>("orientation");
1079 QTest::addColumn<QStringList>("labels");
1080 QTest::addColumn<QStringList>("expectedLabels");
1081
1082 QTest::newRow("horizontal labels")
1083 << 1
1084 << 4
1085 << Qt::Horizontal
1086 << (QStringList() << "a" << "b" << "c" << "d")
1087 << (QStringList() << "a" << "b" << "c" << "d");
1088 QTest::newRow("vertical labels")
1089 << 4
1090 << 1
1091 << Qt::Vertical
1092 << (QStringList() << "a" << "b" << "c" << "d")
1093 << (QStringList() << "a" << "b" << "c" << "d");
1094 QTest::newRow("too few (horizontal)")
1095 << 1
1096 << 4
1097 << Qt::Horizontal
1098 << (QStringList() << "a" << "b")
1099 << (QStringList() << "a" << "b" << "3" << "4");
1100 QTest::newRow("too few (vertical)")
1101 << 4
1102 << 1
1103 << Qt::Vertical
1104 << (QStringList() << "a" << "b")
1105 << (QStringList() << "a" << "b" << "3" << "4");
1106 QTest::newRow("too many (horizontal)")
1107 << 1
1108 << 2
1109 << Qt::Horizontal
1110 << (QStringList() << "a" << "b" << "c" << "d")
1111 << (QStringList() << "a" << "b" << "c" << "d");
1112 QTest::newRow("too many (vertical)")
1113 << 2
1114 << 1
1115 << Qt::Vertical
1116 << (QStringList() << "a" << "b" << "c" << "d")
1117 << (QStringList() << "a" << "b" << "c" << "d");
1118 }
1119
1120 void tst_QStandardItemModel::setHeaderLabels()
1121 {
1122 QFETCH(int, rows);
1123 QFETCH(int, columns);
1124 QFETCH(Qt::Orientation, orientation);
1125 QFETCH(QStringList, labels);
1126 QFETCH(QStringList, expectedLabels);
1127 QStandardItemModel model(rows, columns);
1128 QSignalSpy columnsInsertedSpy(&model, &QAbstractItemModel::columnsInserted);
1129 QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
1130 if (orientation == Qt::Horizontal)
1131 model.setHorizontalHeaderLabels(labels);
1132 else
1133 model.setVerticalHeaderLabels(labels);
1134 for (int i = 0; i < expectedLabels.count(); ++i)
1135 QCOMPARE(model.headerData(i, orientation).toString(), expectedLabels.at(i));
1136 QCOMPARE(columnsInsertedSpy.count(),
1137 (orientation == Qt::Vertical) ? 0 : labels.count() > columns);
1138 QCOMPARE(rowsInsertedSpy.count(),
1139 (orientation == Qt::Horizontal) ? 0 : labels.count() > rows);
1140 }
1141
1142 void tst_QStandardItemModel::itemDataChanged()
1143 {
1144 QStandardItemModel model(6, 4);
1145 QStandardItem item;
1146 QSignalSpy dataChangedSpy(&model, &QStandardItemModel::dataChanged);
1147 QSignalSpy itemChangedSpy(&model, &QStandardItemModel::itemChanged);
1148
1149 model.setItem(0, &item);
1150 QCOMPARE(dataChangedSpy.count(), 1);
1151 QCOMPARE(itemChangedSpy.count(), 1);
1152 QModelIndex index = model.indexFromItem(&item);
1153 QList<QVariant> args;
1154 args = dataChangedSpy.takeFirst();
1155 QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), index);
1156 QCOMPARE(qvariant_cast<QModelIndex>(args.at(1)), index);
1157 args = itemChangedSpy.takeFirst();
1158 QCOMPARE(qvariant_cast<QStandardItem*>(args.at(0)), &item);
1159
1160 item.setData(QLatin1String("foo"), Qt::DisplayRole);
1161 QCOMPARE(dataChangedSpy.count(), 1);
1162 QCOMPARE(itemChangedSpy.count(), 1);
1163 args = dataChangedSpy.takeFirst();
1164 QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), index);
1165 QCOMPARE(qvariant_cast<QModelIndex>(args.at(1)), index);
1166 args = itemChangedSpy.takeFirst();
1167 QCOMPARE(qvariant_cast<QStandardItem*>(args.at(0)), &item);
1168
1169 item.setData(item.data(Qt::DisplayRole), Qt::DisplayRole);
1170 QCOMPARE(dataChangedSpy.count(), 0);
1171 QCOMPARE(itemChangedSpy.count(), 0);
1172
1173 item.setFlags(Qt::ItemIsEnabled);
1174 QCOMPARE(dataChangedSpy.count(), 1);
1175 QCOMPARE(itemChangedSpy.count(), 1);
1176 args = dataChangedSpy.takeFirst();
1177 QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), index);
1178 QCOMPARE(qvariant_cast<QModelIndex>(args.at(1)), index);
1179 args = itemChangedSpy.takeFirst();
1180 QCOMPARE(qvariant_cast<QStandardItem*>(args.at(0)), &item);
1181
1182 item.setFlags(item.flags());
1183 QCOMPARE(dataChangedSpy.count(), 0);
1184 QCOMPARE(itemChangedSpy.count(), 0);
1185 }
1186
1187 void tst_QStandardItemModel::takeHeaderItem()
1188 {
1189 QStandardItemModel model;
1190 // set header items
1191 QScopedPointer<QStandardItem> hheader(new QStandardItem());
1192 model.setHorizontalHeaderItem(0, hheader.get());
1193 QScopedPointer<QStandardItem> vheader(new QStandardItem());
1194 model.setVerticalHeaderItem(0, vheader.get());
1195 // take header items
1196 QCOMPARE(model.takeHorizontalHeaderItem(0), hheader.get());
1197 QCOMPARE(model.takeVerticalHeaderItem(0), vheader.get());
1198 QCOMPARE(hheader->model(), nullptr);
1199 QCOMPARE(vheader->model(), nullptr);
1200 QCOMPARE(model.takeHorizontalHeaderItem(0), nullptr);
1201 QCOMPARE(model.takeVerticalHeaderItem(0), nullptr);
1202 }
1203
1204 void tst_QStandardItemModel::useCase1()
1205 {
1206 const int rows = 5;
1207 const int columns = 8;
1208 QStandardItemModel model(rows, columns);
1209 for (int i = 0; i < model.rowCount(); ++i) {
1210 for (int j = 0; j < model.columnCount(); ++j) {
1211 QCOMPARE(model.item(i, j), nullptr);
1212
1213 QStandardItem *item = new QStandardItem();
1214 model.setItem(i, j, item);
1215 QCOMPARE(item->row(), i);
1216 QCOMPARE(item->column(), j);
1217 QCOMPARE(item->model(), &model);
1218
1219 QModelIndex index = model.indexFromItem(item);
1220 QCOMPARE(index, model.index(i, j, QModelIndex()));
1221 QStandardItem *sameItem = model.itemFromIndex(index);
1222 QCOMPARE(sameItem, item);
1223 }
1224 }
1225 }
1226
1227 static void createChildren(QStandardItemModel *model, QStandardItem *parent, int level)
1228 {
1229 if (level > 4)
1230 return;
1231 for (int i = 0; i < 4; ++i) {
1232 QCOMPARE(parent->rowCount(), i);
1233 parent->appendRow(QList<QStandardItem*>());
1234 for (int j = 0; j < parent->columnCount(); ++j) {
1235 QStandardItem *item = new QStandardItem();
1236 parent->setChild(i, j, item);
1237 QCOMPARE(item->row(), i);
1238 QCOMPARE(item->column(), j);
1239
1240 QModelIndex parentIndex = model->indexFromItem(parent);
1241 QModelIndex index = model->indexFromItem(item);
1242 QCOMPARE(index, model->index(i, j, parentIndex));
1243 QStandardItem *theItem = model->itemFromIndex(index);
1244 QCOMPARE(theItem, item);
1245 QStandardItem *theParent = model->itemFromIndex(parentIndex);
1246 QCOMPARE(theParent, (level == 0) ? static_cast<QStandardItem *>(nullptr) : parent);
1247 }
1248
1249 {
1250 QStandardItem *item = parent->child(i);
1251 item->setColumnCount(parent->columnCount());
1252 createChildren(model, item, level + 1);
1253 }
1254 }
1255 }
1256
1257 void tst_QStandardItemModel::useCase2()
1258 {
1259 QStandardItemModel model;
1260 model.setColumnCount(2);
1261 createChildren(&model, model.invisibleRootItem(), 0);
1262 }
1263
1264 void tst_QStandardItemModel::useCase3()
1265 {
1266 // create the tree structure first
1267 QStandardItem *childItem = nullptr;
1268 for (int i = 0; i < 100; ++i) {
1269 QStandardItem *item = new QStandardItem(QStringLiteral("item ") + QString::number(i));
1270 if (childItem)
1271 item->appendRow(childItem);
1272 childItem = item;
1273 }
1274
1275 // add to model as last step
1276 QStandardItemModel model;
1277 model.appendRow(childItem);
1278
1279 // make sure each item has the correct model and parent
1280 QStandardItem *parentItem = nullptr;
1281 while (childItem) {
1282 QCOMPARE(childItem->model(), &model);
1283 QCOMPARE(childItem->parent(), parentItem);
1284 parentItem = childItem;
1285 childItem = childItem->child(0);
1286 }
1287
1288 // take the item, make sure model is set to 0, but that parents are the same
1289 childItem = model.takeItem(0);
1290 {
1291 parentItem = nullptr;
1292 QStandardItem *item = childItem;
1293 while (item) {
1294 QCOMPARE(item->model(), nullptr);
1295 QCOMPARE(item->parent(), parentItem);
1296 parentItem = item;
1297 item = item->child(0);
1298 }
1299 }
1300 delete childItem;
1301 }
1302
1303 void tst_QStandardItemModel::setNullChild()
1304 {
1305 QStandardItemModel model;
1306 model.setColumnCount(2);
1307 createChildren(&model, model.invisibleRootItem(), 0);
1308 QStandardItem *item = model.item(0);
1309 QSignalSpy spy(&model, &QAbstractItemModel::dataChanged);
1310 item->setChild(0, nullptr);
1311 QCOMPARE(item->child(0), nullptr);
1312 QCOMPARE(spy.count(), 1);
1313 }
1314
1315 void tst_QStandardItemModel::deleteChild()
1316 {
1317 QStandardItemModel model;
1318 model.setColumnCount(2);
1319 createChildren(&model, model.invisibleRootItem(), 0);
1320 QStandardItem *item = model.item(0);
1321 QSignalSpy spy(&model, &QAbstractItemModel::dataChanged);
1322 delete item->child(0);
1323 QCOMPARE(item->child(0), nullptr);
1324 QCOMPARE(spy.count(), 1);
1325 }
1326
1327 void tst_QStandardItemModel::rootItemFlags()
1328 {
1329 QStandardItemModel model(6, 4);
1330 QCOMPARE(model.invisibleRootItem()->flags() , model.flags(QModelIndex()));
1331 QCOMPARE(model.invisibleRootItem()->flags() , Qt::ItemIsDropEnabled);
1332
1333 Qt::ItemFlags f = Qt::ItemIsDropEnabled | Qt::ItemIsEnabled;
1334 model.invisibleRootItem()->setFlags(f);
1335 QCOMPARE(model.invisibleRootItem()->flags() , f);
1336 QCOMPARE(model.invisibleRootItem()->flags() , model.flags(QModelIndex()));
1337
1338 #if QT_CONFIG(draganddrop)
1339 model.invisibleRootItem()->setDropEnabled(false);
1340 #endif
1341 QCOMPARE(model.invisibleRootItem()->flags() , Qt::ItemIsEnabled);
1342 QCOMPARE(model.invisibleRootItem()->flags() , model.flags(QModelIndex()));
1343 }
1344
1345 bool tst_QStandardItemModel::compareModels(QStandardItemModel *model1, QStandardItemModel *model2)
1346 {
1347 return compareItems(model1->invisibleRootItem(), model2->invisibleRootItem());
1348 }
1349
1350 bool tst_QStandardItemModel::compareItems(QStandardItem *item1, QStandardItem *item2)
1351 {
1352 if (!item1 && !item2)
1353 return true;
1354 if (!item1 || !item2)
1355 return false;
1356 if (item1->text() != item2->text()) {
1357 qDebug() << item1->text() << item2->text();
1358 return false;
1359 }
1360 if (item1->rowCount() != item2->rowCount()) {
1361 // qDebug() << "RowCount" << item1->text() << item1->rowCount() << item2->rowCount();
1362 return false;
1363 }
1364 if (item1->columnCount() != item2->columnCount()) {
1365 // qDebug() << "ColumnCount" << item1->text() << item1->columnCount() << item2->columnCount();
1366 return false;
1367 }
1368 for (int row = 0; row < item1->columnCount(); row++) {
1369 for (int col = 0; col < item1->columnCount(); col++) {
1370 if (!compareItems(item1->child(row, col), item2->child(row, col)))
1371 return false;
1372 }
1373 }
1374 return true;
1375 }
1376
1377 static QStandardItem *itemFromText(QStandardItem *parent, const QString &text)
1378 {
1379 QStandardItem *item = nullptr;
1380 for (int i = 0; i < parent->columnCount(); i++) {
1381 for (int j = 0; j < parent->rowCount(); j++) {
1382 QStandardItem *child = parent->child(j, i);
1383 if (!child)
1384 continue;
1385
1386 if (child->text() == text) {
1387 if (item)
1388 return nullptr;
1389 item = child;
1390 }
1391
1392 QStandardItem *candidate = itemFromText(child, text);
1393 if (candidate) {
1394 if (item)
1395 return nullptr;
1396 item = candidate;
1397 }
1398 }
1399 }
1400 return item;
1401 }
1402
1403 #ifdef QT_BUILD_INTERNAL
1404 static QModelIndex indexFromText(QStandardItemModel *model, const QString &text)
1405 {
1406 QStandardItem *item = itemFromText(model->invisibleRootItem(), text);
1407 /*QVERIFY(item);*/
1408 return model->indexFromItem(item);
1409 }
1410
1411
1412 struct FriendlyTreeView : public QTreeView
1413 {
1414 friend class tst_QStandardItemModel;
1415 Q_DECLARE_PRIVATE(QTreeView)
1416 };
1417 #endif
1418
1419 #ifdef QT_BUILD_INTERNAL
1420
1421 static void populateDragAndDropModel(QStandardItemModel &model, int nRow, int nCol)
1422 {
1423 const QString item = QStringLiteral("item ");
1424 const QString dash = QStringLiteral(" - ");
1425 for (int i = 0; i < nRow; ++i) {
1426 const QString iS = QString::number(i);
1427 QList<QStandardItem *> colItems1;
1428 for (int c = 0 ; c < nCol; c ++)
1429 colItems1 << new QStandardItem(item + iS + dash + QString::number(c));
1430 model.appendRow(colItems1);
1431
1432 for (int j = 0; j < nRow; ++j) {
1433 const QString jS = QString::number(j);
1434 QList<QStandardItem *> colItems2;
1435 for (int c = 0 ; c < nCol; c ++)
1436 colItems2 << new QStandardItem(item + iS + QLatin1Char('/') + jS + dash + QString::number(c));
1437 colItems1.at(0)->appendRow(colItems2);
1438
1439 for (int k = 0; k < nRow; ++k) {
1440 QList<QStandardItem *> colItems3;
1441 const QString kS = QString::number(k);
1442 for (int c = 0 ; c < nCol; c ++)
1443 colItems3 << new QStandardItem(item + iS + QLatin1Char('/') + jS
1444 + QLatin1Char('/') + kS
1445 + dash + QString::number(c));
1446 colItems2.at(0)->appendRow(colItems3);
1447 }
1448 }
1449 }
1450 }
1451
1452 void tst_QStandardItemModel::treeDragAndDrop()
1453 {
1454 const int nRow = 5;
1455 const int nCol = 3;
1456
1457 QStandardItemModel model;
1458 QStandardItemModel checkModel;
1459
1460 populateDragAndDropModel(model, nRow, nCol);
1461 populateDragAndDropModel(checkModel, nRow, nCol);
1462
1463 QVERIFY(compareModels(&model, &checkModel));
1464
1465 FriendlyTreeView view;
1466 view.setModel(&model);
1467 view.expandAll();
1468 view.show();
1469 #if QT_CONFIG(draganddrop)
1470 view.setDragDropMode(QAbstractItemView::InternalMove);
1471 #endif
1472 view.setSelectionMode(QAbstractItemView::ExtendedSelection);
1473
1474 QItemSelectionModel *selection = view.selectionModel();
1475
1476 //
1477 // step1 drag "item 1" and "item 2" into "item 4"
1478 //
1479 {
1480 selection->clear();
1481 selection->select(QItemSelection(indexFromText(&model, QString("item 1 - 0")),
1482 indexFromText(&model, QString("item 1 - %0").arg(nCol-1))), QItemSelectionModel::Select);
1483
1484 selection->select(QItemSelection(indexFromText(&model, QString("item 2 - 0")),
1485 indexFromText(&model, QString("item 2 - %0").arg(nCol-1))), QItemSelectionModel::Select);
1486
1487 //code based from QAbstractItemView::startDrag and QAbstractItemView::dropEvent
1488 QModelIndexList indexes = view.selectedIndexes();
1489 QMimeData *data = model.mimeData(indexes);
1490 if(model.dropMimeData(data, Qt::MoveAction, 0, 0, indexFromText(&model, "item 4 - 0")))
1491 view.d_func()->clearOrRemove();
1492 delete data;
1493
1494 QVERIFY(!compareModels(&model, &checkModel)); //the model must be different at this point
1495 QStandardItem *item4 = itemFromText(checkModel.invisibleRootItem(), "item 4 - 0");
1496 item4->insertRow(0, checkModel.takeRow(1));
1497 item4->insertRow(1, checkModel.takeRow(1));
1498 QVERIFY(compareModels(&model, &checkModel));
1499 }
1500
1501 //
1502 // step2 drag "item 3" and "item 3/0" into "item 4"
1503 //
1504 {
1505 selection->clear();
1506 selection->select(QItemSelection(indexFromText(&model, QString("item 3 - 0")),
1507 indexFromText(&model, QString("item 3 - %0").arg(nCol-1))), QItemSelectionModel::Select);
1508
1509 selection->select(QItemSelection(indexFromText(&model, QString("item 3/0 - 0")),
1510 indexFromText(&model, QString("item 3/0 - %0").arg(nCol-1))), QItemSelectionModel::Select);
1511
1512 //code based from QAbstractItemView::startDrag and QAbstractItemView::dropEvent
1513 QModelIndexList indexes = view.selectedIndexes();
1514 QMimeData *data = model.mimeData(indexes);
1515 if(model.dropMimeData(data, Qt::MoveAction, 0, 0, indexFromText(&model, "item 4 - 0")))
1516 view.d_func()->clearOrRemove();
1517 delete data;
1518
1519 QVERIFY(!compareModels(&model, &checkModel)); //the model must be different at this point
1520 QStandardItem *item4 = itemFromText(checkModel.invisibleRootItem(), "item 4 - 0");
1521 item4->insertRow(0, checkModel.takeRow(1));
1522
1523 QVERIFY(compareModels(&model, &checkModel));
1524 }
1525
1526 //
1527 // step2 drag "item 3" and "item 3/0/2" into "item 0/2"
1528 // ( remember "item 3" is now the first child of "item 4")
1529 //
1530 {
1531 selection->clear();
1532 selection->select(QItemSelection(indexFromText(&model, QString("item 3 - 0")),
1533 indexFromText(&model, QString("item 3 - %0").arg(nCol-1))), QItemSelectionModel::Select);
1534
1535 selection->select(QItemSelection(indexFromText(&model, QString("item 3/0/2 - 0")),
1536 indexFromText(&model, QString("item 3/0/2 - %0").arg(nCol-1))), QItemSelectionModel::Select);
1537
1538 //code based from QAbstractItemView::startDrag and QAbstractItemView::dropEvent
1539 QModelIndexList indexes = view.selectedIndexes();
1540 QMimeData *data = model.mimeData(indexes);
1541 if(model.dropMimeData(data, Qt::MoveAction, 0, 0, indexFromText(&model, "item 0/2 - 0")))
1542 view.d_func()->clearOrRemove();
1543 delete data;
1544
1545 QVERIFY(!compareModels(&model, &checkModel)); //the model must be different at this point
1546 QStandardItem *item02 = itemFromText(checkModel.invisibleRootItem(), "item 0/2 - 0");
1547 QStandardItem *item4 = itemFromText(checkModel.invisibleRootItem(), "item 4 - 0");
1548 item02->insertRow(0, item4->takeRow(0));
1549
1550 QVERIFY(compareModels(&model, &checkModel));
1551 }
1552 }
1553 #endif
1554
1555 void tst_QStandardItemModel::removeRowsAndColumns()
1556 {
1557 #define VERIFY_MODEL \
1558 for (int c = 0; c < col_list.count(); c++) \
1559 for (int r = 0; r < row_list.count(); r++) \
1560 QCOMPARE(model.item(r,c)->text() , row_list[r] + QLatin1Char('x') + col_list[c]);
1561
1562 QVector<QString> row_list = QString("1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20").split(',').toVector();
1563 QVector<QString> col_list = row_list;
1564 QStandardItemModel model;
1565 for (int c = 0; c < col_list.count(); c++)
1566 for (int r = 0; r < row_list.count(); r++)
1567 model.setItem(r, c, new QStandardItem(row_list[r] + QLatin1Char('x') + col_list[c]));
1568 VERIFY_MODEL
1569
1570 row_list.remove(3);
1571 model.removeRow(3);
1572 VERIFY_MODEL
1573
1574 col_list.remove(5);
1575 model.removeColumn(5);
1576 VERIFY_MODEL
1577
1578 row_list.remove(2, 5);
1579 model.removeRows(2, 5);
1580 VERIFY_MODEL
1581
1582 col_list.remove(1, 6);
1583 model.removeColumns(1, 6);
1584 VERIFY_MODEL
1585
1586 QList<QStandardItem *> row_taken = model.takeRow(6);
1587 QCOMPARE(row_taken.count(), col_list.count());
1588 for (int c = 0; c < col_list.count(); c++)
1589 QCOMPARE(row_taken[c]->text() , row_list[6] + QLatin1Char('x') + col_list[c]);
1590 row_list.remove(6);
1591 VERIFY_MODEL
1592
1593 QList<QStandardItem *> col_taken = model.takeColumn(10);
1594 QCOMPARE(col_taken.count(), row_list.count());
1595 for (int r = 0; r < row_list.count(); r++)
1596 QCOMPARE(col_taken[r]->text() , row_list[r] + QLatin1Char('x') + col_list[10]);
1597 col_list.remove(10);
1598 VERIFY_MODEL
1599 }
1600
1601 void tst_QStandardItemModel::itemRoleNames()
1602 {
1603 QVector<QString> row_list = QString("1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20").split(',').toVector();
1604 QVector<QString> col_list = row_list;
1605 QStandardItemModel model;
1606 for (int c = 0; c < col_list.count(); c++)
1607 for (int r = 0; r < row_list.count(); r++)
1608 model.setItem(r, c, new QStandardItem(row_list[r] + QLatin1Char('x') + col_list[c]));
1609 VERIFY_MODEL
1610
1611 QHash<int, QByteArray> newRoleNames;
1612 newRoleNames.insert(Qt::DisplayRole, "Name");
1613 newRoleNames.insert(Qt::DecorationRole, "Avatar");
1614 model.setItemRoleNames(newRoleNames);
1615 QCOMPARE(model.roleNames(), newRoleNames);
1616 VERIFY_MODEL
1617 }
1618
1619 void tst_QStandardItemModel::getMimeDataWithInvalidModelIndex()
1620 {
1621 QStandardItemModel model;
1622 QTest::ignoreMessage(QtWarningMsg, "QStandardItemModel::mimeData: No item associated with invalid index");
1623 QMimeData *data = model.mimeData(QModelIndexList() << QModelIndex());
1624 QVERIFY(!data);
1625 }
1626
1627 void tst_QStandardItemModel::supportedDragDropActions()
1628 {
1629 QStandardItemModel model;
1630 QCOMPARE(model.supportedDragActions(), Qt::CopyAction | Qt::MoveAction);
1631 QCOMPARE(model.supportedDropActions(), Qt::CopyAction | Qt::MoveAction);
1632 }
1633
1634 void tst_QStandardItemModel::taskQTBUG_45114_setItemData()
1635 {
1636 QStandardItemModel model;
1637 QSignalSpy spy(&model, &QStandardItemModel::itemChanged);
1638
1639 QStandardItem *item = new QStandardItem("item");
1640 item->setData(1, Qt::UserRole + 1);
1641 item->setData(2, Qt::UserRole + 2);
1642 model.appendRow(item);
1643
1644 QModelIndex index = item->index();
1645 QCOMPARE(model.itemData(index).size(), 3);
1646
1647 QCOMPARE(spy.count(), 0);
1648
1649 QMap<int, QVariant> roles;
1650
1651 roles.insert(Qt::UserRole + 1, 1);
1652 roles.insert(Qt::UserRole + 2, 2);
1653 model.setItemData(index, roles);
1654
1655 QCOMPARE(spy.count(), 0);
1656
1657 roles.insert(Qt::UserRole + 1, 1);
1658 roles.insert(Qt::UserRole + 2, 2);
1659 roles.insert(Qt::UserRole + 3, QVariant());
1660 model.setItemData(index, roles);
1661
1662 QCOMPARE(spy.count(), 0);
1663
1664 roles.clear();
1665 roles.insert(Qt::UserRole + 1, 10);
1666 roles.insert(Qt::UserRole + 3, 12);
1667 model.setItemData(index, roles);
1668
1669 QCOMPARE(spy.count(), 1);
1670 QMap<int, QVariant> itemRoles = model.itemData(index);
1671
1672 QCOMPARE(itemRoles.size(), 4);
1673 QCOMPARE(itemRoles[Qt::UserRole + 1].toInt(), 10);
1674 QCOMPARE(itemRoles[Qt::UserRole + 2].toInt(), 2);
1675 QCOMPARE(itemRoles[Qt::UserRole + 3].toInt(), 12);
1676
1677 roles.clear();
1678 roles.insert(Qt::UserRole + 3, 1);
1679 model.setItemData(index, roles);
1680
1681 QCOMPARE(spy.count(), 2);
1682
1683 roles.clear();
1684 roles.insert(Qt::UserRole + 3, QVariant());
1685 model.setItemData(index, roles);
1686
1687 QCOMPARE(spy.count(), 3);
1688
1689 itemRoles = model.itemData(index);
1690 QCOMPARE(itemRoles.size(), 3);
1691 QVERIFY(!itemRoles.keys().contains(Qt::UserRole + 3));
1692 }
1693
1694 void tst_QStandardItemModel::setItemPersistentIndex()
1695 {
1696 QPersistentModelIndex persistentIndex;
1697 // setItem on an already existing item should not destroy the persistent index
1698 QStandardItemModel m;
1699 persistentIndex = m.index(0, 0);
1700 QVERIFY(!persistentIndex.isValid());
1701
1702 m.setItem(0, 0, new QStandardItem);
1703 persistentIndex = m.index(0, 0);
1704 QVERIFY(persistentIndex.isValid());
1705 QCOMPARE(persistentIndex.row(), 0);
1706 QCOMPARE(persistentIndex.column(), 0);
1707
1708 m.setItem(0, 0, new QStandardItem);
1709 QVERIFY(persistentIndex.isValid());
1710
1711 m.setItem(0, 0, nullptr);
1712 QVERIFY(!persistentIndex.isValid());
1713 }
1714
1715 QTEST_MAIN(tst_QStandardItemModel)
1716 #include "tst_qstandarditemmodel.moc"