1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
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 http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file. Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42
43 #include <QtTest/QtTest>
44 #include <QtGui/QtGui>
45 #include <qeventloop.h>
46 #include <qlist.h>
47
48 #include <qlistwidget.h>
49 #include <private/qlistwidget_p.h>
50
51 //TESTED_CLASS=
52 //TESTED_FILES=
53
54 class tst_QListWidget : public QObject
55 {
56 Q_OBJECT
57
58 public:
59 tst_QListWidget();
60 ~tst_QListWidget();
61
62 enum ModelChanged {
63 RowsAboutToBeInserted,
64 RowsInserted,
65 RowsAboutToBeRemoved,
66 RowsRemoved,
67 ColumnsAboutToBeInserted,
68 ColumnsInserted,
69 ColumnsAboutToBeRemoved,
70 ColumnsRemoved
71 };
72
73 public slots:
74 void initTestCase();
75 void cleanupTestCase();
76 void init();
77 void cleanup();
78
79 private slots:
80 void addItem();
81 void addItem2();
82 void addItems();
83 void openPersistentEditor();
84 void closePersistentEditor();
85 void count();
86 void currentItem();
87 void setCurrentItem_data();
88 void setCurrentItem();
89 void currentRow();
90 void setCurrentRow_data();
91 void setCurrentRow();
92 void editItem_data();
93 void editItem();
94 void findItems();
95 void insertItem_data();
96 void insertItem();
97 void insertItems_data();
98 void insertItems();
99 void moveItemsPriv_data();
100 void moveItemsPriv();
101
102 void itemAssignment();
103 void item_data();
104 void item();
105 void takeItem_data();
106 void takeItem();
107 void setItemHidden();
108 void selectedItems_data();
109 void selectedItems();
110 void removeItems_data();
111 void removeItems();
112 void itemStreaming_data();
113 void itemStreaming();
114 void sortItems_data();
115 void sortItems();
116 void sortHiddenItems();
117 void sortHiddenItems_data();
118 void closeEditor();
119 void setData_data();
120 void setData();
121 void insertItemsWithSorting_data();
122 void insertItemsWithSorting();
123 void changeDataWithSorting_data();
124 void changeDataWithSorting();
125 void itemData();
126 void itemWidget();
127 #ifndef Q_WS_MAC
128 void fastScroll();
129 #endif
130 void insertUnchanged();
131 void setSortingEnabled();
132 void task199503_crashWhenCleared();
133 void task217070_scrollbarsAdjusted();
134 void task258949_keypressHangup();
135 void QTBUG8086_currentItemChangedOnClick();
136 void QTBUG14363_completerWithAnyKeyPressedEditTriggers();
137
138
139 protected slots:
rowsAboutToBeInserted(const QModelIndex & parent,int first,int last)140 void rowsAboutToBeInserted(const QModelIndex &parent, int first, int last)
141 { modelChanged(RowsAboutToBeInserted, parent, first, last); }
rowsInserted(const QModelIndex & parent,int first,int last)142 void rowsInserted(const QModelIndex &parent, int first, int last)
143 { modelChanged(RowsInserted, parent, first, last); }
rowsAboutToBeRemoved(const QModelIndex & parent,int first,int last)144 void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
145 { modelChanged(RowsAboutToBeRemoved, parent, first, last); }
rowsRemoved(const QModelIndex & parent,int first,int last)146 void rowsRemoved(const QModelIndex &parent, int first, int last)
147 { modelChanged(RowsRemoved, parent, first, last); }
columnsAboutToBeInserted(const QModelIndex & parent,int first,int last)148 void columnsAboutToBeInserted(const QModelIndex &parent, int first, int last)
149 { modelChanged(ColumnsAboutToBeInserted, parent, first, last); }
columnsInserted(const QModelIndex & parent,int first,int last)150 void columnsInserted(const QModelIndex &parent, int first, int last)
151 { modelChanged(ColumnsInserted, parent, first, last); }
columnsAboutToBeRemoved(const QModelIndex & parent,int first,int last)152 void columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
153 { modelChanged(ColumnsAboutToBeRemoved, parent, first, last); }
columnsRemoved(const QModelIndex & parent,int first,int last)154 void columnsRemoved(const QModelIndex &parent, int first, int last)
155 { modelChanged(ColumnsRemoved, parent, first, last); }
156
157 void modelChanged(ModelChanged change, const QModelIndex &parent, int first, int last);
158
159 private:
160 QListWidget *testWidget;
161 QVector<QModelIndex> rcParent;
162 QVector<int> rcFirst;
163 QVector<int> rcLast;
164
165 void populate();
166 void checkDefaultValues();
167 };
168
169
170 typedef QList<int> IntList;
171 Q_DECLARE_METATYPE(IntList)
Q_DECLARE_METATYPE(QVariantList)172 Q_DECLARE_METATYPE(QVariantList)
173
174 tst_QListWidget::tst_QListWidget(): testWidget(0), rcParent(8), rcFirst(8,0), rcLast(8,0)
175 {
176 }
177
~tst_QListWidget()178 tst_QListWidget::~tst_QListWidget()
179 {
180 }
181
initTestCase()182 void tst_QListWidget::initTestCase()
183 {
184 testWidget = new QListWidget();
185 testWidget->show();
186
187 connect(testWidget->model(), SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)),
188 this, SLOT(rowsAboutToBeInserted(QModelIndex, int, int)));
189 connect(testWidget->model(), SIGNAL(rowsInserted(QModelIndex, int, int)),
190 this, SLOT(rowsInserted(QModelIndex, int, int)));
191 connect(testWidget->model(), SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)),
192 this, SLOT(rowsAboutToBeRemoved(QModelIndex, int, int)));
193 connect(testWidget->model(), SIGNAL(rowsRemoved(QModelIndex, int, int)),
194 this, SLOT(rowsRemoved(QModelIndex, int, int)));
195
196 connect(testWidget->model(), SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)),
197 this, SLOT(columnsAboutToBeInserted(QModelIndex, int, int)));
198 connect(testWidget->model(), SIGNAL(columnsInserted(QModelIndex, int, int)),
199 this, SLOT(columnsInserted(QModelIndex, int, int)));
200 connect(testWidget->model(), SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)),
201 this, SLOT(columnsAboutToBeRemoved(QModelIndex, int, int)));
202 connect(testWidget->model(), SIGNAL(columnsRemoved(QModelIndex, int, int)),
203 this, SLOT(columnsRemoved(QModelIndex, int, int)));
204
205 checkDefaultValues();
206 }
207
cleanupTestCase()208 void tst_QListWidget::cleanupTestCase()
209 {
210 delete testWidget;
211 }
212
init()213 void tst_QListWidget::init()
214 {
215 testWidget->clear();
216
217 if (testWidget->viewport()->children().count() > 0) {
218 QEventLoop eventLoop;
219 for (int i=0; i < testWidget->viewport()->children().count(); ++i)
220 connect(testWidget->viewport()->children().at(i), SIGNAL(destroyed()), &eventLoop, SLOT(quit()));
221 QTimer::singleShot(100, &eventLoop, SLOT(quit()));
222 eventLoop.exec();
223 }
224 }
225
checkDefaultValues()226 void tst_QListWidget::checkDefaultValues()
227 {
228 QCOMPARE(testWidget->currentItem(), (QListWidgetItem *)0);
229 QCOMPARE(testWidget->currentRow(), -1);
230 QCOMPARE(testWidget->count(), 0);
231 }
232
cleanup()233 void tst_QListWidget::cleanup()
234 {
235 }
236
populate()237 void tst_QListWidget::populate()
238 {
239 addItem();
240 addItem2();
241 addItems();
242 setItemHidden();
243
244 testWidget->setCurrentIndex(testWidget->model()->index(0,0));
245
246 // setCurrentItem();
247 // setCurrentRow();
248 }
249
addItem()250 void tst_QListWidget::addItem()
251 {
252 int count = testWidget->count();
253 QString label = QString("%1").arg(count);
254 testWidget->addItem(label);
255 QCOMPARE(testWidget->count(), ++count);
256 QCOMPARE(testWidget->item(testWidget->count()-1)->text(), label);
257 }
258
addItem2()259 void tst_QListWidget::addItem2()
260 {
261 int count = testWidget->count();
262
263 // Boundary Checking
264 testWidget->addItem(0);
265 QCOMPARE(testWidget->count(), count);
266
267 QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(count));
268 item->setFlags(item->flags() | Qt::ItemIsEditable);
269 testWidget->addItem(item);
270 QCOMPARE(testWidget->count(), ++count);
271 QCOMPARE(testWidget->item(testWidget->count()-1), item);
272 QCOMPARE(testWidget->isItemHidden(item), false);
273 }
274
addItems()275 void tst_QListWidget::addItems()
276 {
277 int count = testWidget->count();
278
279 // Boundary Checking
280 testWidget->addItems(QStringList());
281 QCOMPARE(testWidget->count(), count);
282
283 QStringList stringList;
284 QString label = QString("%1").arg(count);
285 stringList << QString("%1").arg(testWidget->count() + 1)
286 << QString("%1").arg(testWidget->count() + 2)
287 << QString("%1").arg(testWidget->count() + 3)
288 << label;
289 testWidget->addItems(stringList);
290 QCOMPARE(testWidget->count(), count + stringList.count());
291 QCOMPARE(testWidget->item(testWidget->count()-1)->text(), label);
292 }
293
294
openPersistentEditor()295 void tst_QListWidget::openPersistentEditor()
296 {
297 // Boundary checking
298 testWidget->openPersistentEditor(0);
299 QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count()));
300 testWidget->openPersistentEditor(item);
301
302 int childCount = testWidget->viewport()->children().count();
303 testWidget->addItem(item);
304 testWidget->openPersistentEditor(item);
305 QCOMPARE(childCount + 1, testWidget->viewport()->children().count());
306 }
307
closePersistentEditor()308 void tst_QListWidget::closePersistentEditor()
309 {
310 #if defined(Q_OS_SYMBIAN)
311 //give the Symbian app start event queue time to clear
312 QTest::qWait(1000);
313 #endif
314
315 // Boundary checking
316 int childCount = testWidget->viewport()->children().count();
317 testWidget->closePersistentEditor(0);
318 QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count()));
319 testWidget->closePersistentEditor(item);
320 QCOMPARE(childCount, testWidget->viewport()->children().count());
321
322 // Create something
323 testWidget->addItem(item);
324 testWidget->openPersistentEditor(item);
325
326 // actual test
327 childCount = testWidget->viewport()->children().count();
328 testWidget->closePersistentEditor(item);
329 // Spin the event loop and hopefully it will die.
330 QEventLoop eventLoop;
331 for (int i=0; i < childCount; ++i)
332 connect(testWidget->viewport()->children().at(i), SIGNAL(destroyed()), &eventLoop, SLOT(quit()));
333 QTimer::singleShot(100, &eventLoop, SLOT(quit()));
334 eventLoop.exec();
335 QCOMPARE(testWidget->viewport()->children().count(), childCount - 1);
336 }
337
setItemHidden()338 void tst_QListWidget::setItemHidden()
339 {
340 // Boundary checking
341 testWidget->setItemHidden(0, true);
342 testWidget->setItemHidden(0, false);
343
344 int totalHidden = 0;
345 for (int i = 0; i < testWidget->model()->rowCount(); ++i)
346 if (testWidget->isItemHidden(testWidget->item(i)))
347 totalHidden++;
348
349 QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count()));
350 testWidget->addItem(item);
351
352 // Check that nothing else changed
353 int newTotal = 0;
354 for (int i = 0; i < testWidget->model()->rowCount(); ++i)
355 if (testWidget->isItemHidden(testWidget->item(i)))
356 newTotal++;
357 QCOMPARE(newTotal, totalHidden);
358
359 testWidget->setItemHidden(item, true);
360 QCOMPARE(testWidget->isItemHidden(item), true);
361
362 // Check that nothing else changed
363 newTotal = 0;
364 for (int i = 0; i < testWidget->model()->rowCount(); ++i)
365 if (testWidget->isItemHidden(testWidget->item(i)))
366 newTotal++;
367 QCOMPARE(newTotal, totalHidden + 1);
368
369 testWidget->setItemHidden(item, false);
370 QCOMPARE(testWidget->isItemHidden(item), false);
371
372 // Check that nothing else changed
373 newTotal = 0;
374 for (int i = 0; i < testWidget->model()->rowCount(); ++i)
375 if (testWidget->isItemHidden(testWidget->item(i)))
376 newTotal++;
377 QCOMPARE(newTotal, totalHidden);
378
379 testWidget->setItemHidden(item, true);
380 }
381
setCurrentItem_data()382 void tst_QListWidget::setCurrentItem_data()
383 {
384 QTest::addColumn<int>("fill");
385 QTest::newRow("HasItems: 0") << 0;
386 QTest::newRow("HasItems: 1") << 1;
387 QTest::newRow("HasItems: 2") << 2;
388 QTest::newRow("HasItems: 3") << 3;
389 }
390
setCurrentItem()391 void tst_QListWidget::setCurrentItem()
392 {
393 QFETCH(int, fill);
394 for (int i = 0; i < fill; ++i)
395 testWidget->addItem(QString("%1").arg(i));
396
397 // Boundary checking
398 testWidget->setCurrentItem((QListWidgetItem *)0);
399 QCOMPARE((QListWidgetItem *)0, testWidget->currentItem());
400 QListWidgetItem item;
401 testWidget->setCurrentItem(&item);
402 QCOMPARE((QListWidgetItem *)0, testWidget->currentItem());
403
404 // Make sure that currentItem changes to what is passed into setCurrentItem
405 for (int i = 0; i < testWidget->count(); ++i) {
406 testWidget->setCurrentItem(testWidget->item(i));
407 for (int j = 0; j < testWidget->count(); ++j) {
408 testWidget->setCurrentItem(testWidget->item(j));
409 QCOMPARE(testWidget->item(j), testWidget->currentItem());
410 }
411 }
412 }
413
setCurrentRow_data()414 void tst_QListWidget::setCurrentRow_data()
415 {
416 QTest::addColumn<int>("fill");
417 QTest::newRow("HasItems: 0") << 0;
418 QTest::newRow("HasItems: 1") << 1;
419 QTest::newRow("HasItems: 2") << 2;
420 QTest::newRow("HasItems: 3") << 3;
421 }
422
setCurrentRow()423 void tst_QListWidget::setCurrentRow()
424 {
425 QFETCH(int, fill);
426 for (int i = 0; i < fill; ++i)
427 testWidget->addItem(QString("%1").arg(i));
428
429 // Boundary checking
430 testWidget->setCurrentRow(-1);
431 QCOMPARE(-1, testWidget->currentRow());
432 testWidget->setCurrentRow(testWidget->count());
433 QCOMPARE(-1, testWidget->currentRow());
434
435 // Make sure that currentRow changes to what is passed into setCurrentRow
436 for (int i = 0; i < testWidget->count(); ++i) {
437 testWidget->setCurrentRow(i);
438 for (int j = 0; j < testWidget->count(); ++j) {
439 testWidget->setCurrentRow(j);
440 QCOMPARE(j, testWidget->currentRow());
441 }
442 }
443 }
444
count()445 void tst_QListWidget::count()
446 {
447 populate();
448
449 // actual test
450 QCOMPARE(testWidget->model()->rowCount(), testWidget->count());
451 }
452
currentItem()453 void tst_QListWidget::currentItem()
454 {
455 populate();
456
457 // actual test
458 QModelIndex currentIndex = testWidget->selectionModel()->currentIndex();
459 if (currentIndex.isValid())
460 QVERIFY(testWidget->currentItem() == testWidget->item(currentIndex.row()));
461 else
462 QVERIFY(testWidget->currentItem() == (QListWidgetItem*)0);
463 }
464
currentRow()465 void tst_QListWidget::currentRow()
466 {
467 populate();
468
469 // actual test
470 QModelIndex currentIndex = testWidget->selectionModel()->currentIndex();
471 if (currentIndex.isValid())
472 QCOMPARE(testWidget->currentRow(), currentIndex.row());
473 else
474 QCOMPARE(testWidget->currentRow(), -1);
475 }
476
editItem_data()477 void tst_QListWidget::editItem_data()
478 {
479 QTest::addColumn<bool>("editable");
480 QTest::newRow("editable") << true;
481 QTest::newRow("not editable") << false;
482 }
483
editItem()484 void tst_QListWidget::editItem()
485 {
486 // Boundary checking
487 testWidget->editItem(0);
488 QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count()));
489 testWidget->editItem(item);
490
491 QFETCH(bool, editable);
492 if (editable)
493 item->setFlags(item->flags() | Qt::ItemIsEditable);
494 testWidget->addItem(item);
495
496 int childCount = testWidget->viewport()->children().count();
497 QWidget *existsAlready = testWidget->indexWidget(testWidget->model()->index(testWidget->row(item), 0));
498 testWidget->editItem(item);
499 Qt::ItemFlags flags = item->flags();
500
501 // There doesn't seem to be a way to detect if the item has already been edited...
502 if (!existsAlready && flags & Qt::ItemIsEditable && flags & Qt::ItemIsEnabled) {
503 QList<QObject *> children = testWidget->viewport()->children();
504 QVERIFY(children.count() > childCount);
505 bool found = false;
506 for (int i = 0; i < children.size(); ++i) {
507 if (children.at(i)->inherits("QExpandingLineEdit"))
508 found = true;
509 }
510 QVERIFY(found);
511 } else {
512 QCOMPARE(testWidget->viewport()->children().count(), childCount);
513 }
514 }
515
findItems()516 void tst_QListWidget::findItems()
517 {
518 // This really just tests that the items that are returned are converted from index's to items correctly.
519
520 // Boundary checking
521 QCOMPARE(testWidget->findItems("GirlsCanWearJeansAndCutTheirHairShort", Qt::MatchExactly).count(), 0);
522
523 populate();
524
525 for (int i=0; i < testWidget->count(); ++i)
526 QCOMPARE(testWidget->findItems( (testWidget->item(i)->text()), Qt::MatchExactly).count(), 1);
527 }
528
529
insertItem_data()530 void tst_QListWidget::insertItem_data()
531 {
532 QTest::addColumn<QStringList>("initialItems");
533 QTest::addColumn<int>("insertIndex");
534 QTest::addColumn<QString>("itemLabel");
535 QTest::addColumn<int>("expectedIndex");
536
537 QStringList initialItems;
538 initialItems << "foo" << "bar";
539
540 QTest::newRow("Insert less then 0") << initialItems << -1 << "inserted" << 0;
541 QTest::newRow("Insert at 0") << initialItems << 0 << "inserted" << 0;
542 QTest::newRow("Insert beyond count") << initialItems << initialItems.count()+1 << "inserted" << initialItems.count();
543 QTest::newRow("Insert at count") << initialItems << initialItems.count() << "inserted" << initialItems.count();
544 QTest::newRow("Insert in the middle") << initialItems << 1 << "inserted" << 1;
545 }
546
insertItem()547 void tst_QListWidget::insertItem()
548 {
549 QFETCH(QStringList, initialItems);
550 QFETCH(int, insertIndex);
551 QFETCH(QString, itemLabel);
552 QFETCH(int, expectedIndex);
553
554 testWidget->insertItems(0, initialItems);
555 QCOMPARE(testWidget->count(), initialItems.count());
556
557 testWidget->insertItem(insertIndex, itemLabel);
558
559 QCOMPARE(rcFirst[RowsAboutToBeInserted], expectedIndex);
560 QCOMPARE(rcLast[RowsAboutToBeInserted], expectedIndex);
561 QCOMPARE(rcFirst[RowsInserted], expectedIndex);
562 QCOMPARE(rcLast[RowsInserted], expectedIndex);
563
564 QCOMPARE(testWidget->count(), initialItems.count() + 1);
565 QCOMPARE(testWidget->item(expectedIndex)->text(), itemLabel);
566 }
567
insertItems_data()568 void tst_QListWidget::insertItems_data()
569 {
570 QTest::addColumn<int>("rowCount");
571 QTest::addColumn<int>("insertType");
572
573 QTest::newRow("Insert 1 item using constructor") << 1 << 0;
574 QTest::newRow("Insert 10 items using constructor") << 10 << 0;
575 QTest::newRow("Insert 100 items using constructor") << 100 << 0;
576
577 QTest::newRow("Insert 1 item with insertItem") << 1 << 1;
578 QTest::newRow("Insert 10 items with insertItem") << 10 << 1;
579 QTest::newRow("Insert 100 items with insertItem") << 100 << 1;
580
581 QTest::newRow("Insert/Create 1 item using insertItem") << 1 << 2;
582 QTest::newRow("Insert/Create 10 items using insertItem") << 10 << 2;
583 QTest::newRow("Insert/Create 100 items using insertItem") << 100 << 2;
584
585 QTest::newRow("Insert 0 items with insertItems") << 0 << 3;
586 QTest::newRow("Insert 1 item with insertItems") << 1 << 3;
587 QTest::newRow("Insert 10 items with insertItems") << 10 << 3;
588 QTest::newRow("Insert 100 items with insertItems") << 100 << 3;
589 }
590
insertItems()591 void tst_QListWidget::insertItems()
592 {
593 QFETCH(int, rowCount);
594 QFETCH(int, insertType);
595
596 if (insertType == 3) {
597 QStringList strings;
598 for (int i=0; i<rowCount; ++i)
599 strings << QString::number(i);
600 testWidget->insertItems(0, strings);
601 } else {
602 for (int r = 0; r < rowCount; ++r) {
603 if (insertType == 0) {
604 // insert with QListWidgetItem constructor
605 new QListWidgetItem(QString::number(r), testWidget);
606 } else if (insertType == 1) {
607 // insert actual item
608 testWidget->insertItem(r, new QListWidgetItem(QString::number(r)));
609 } else if (insertType == 2) {
610 // insert/creating with string
611 testWidget->insertItem(r, QString::number(r));
612 } else if (insertType == 3) {
613 QStringList strings;
614 for (int i=0; i<rowCount; ++i)
615 strings << QString::number(i);
616 testWidget->insertItems(0, strings);
617 break;
618 } else {
619 QVERIFY(0);
620 }
621 }
622 }
623 // compare the results
624 QCOMPARE(testWidget->count(), rowCount);
625
626 // check if the text
627 for (int r = 0; r < rowCount; ++r)
628 QCOMPARE(testWidget->item(r)->text(), QString::number(r));
629
630 // make sure all items have view set correctly
631 for (int i=0; i<testWidget->count(); ++i)
632 QCOMPARE(testWidget->item(i)->listWidget(), testWidget);
633 }
634
itemAssignment()635 void tst_QListWidget::itemAssignment()
636 {
637 QListWidgetItem itemInWidget("inWidget", testWidget);
638 itemInWidget.setFlags(itemInWidget.flags() | Qt::ItemIsTristate);
639 QListWidgetItem itemOutsideWidget("outsideWidget");
640
641 QVERIFY(itemInWidget.listWidget());
642 QCOMPARE(itemInWidget.text(), QString("inWidget"));
643 QVERIFY(itemInWidget.flags() & Qt::ItemIsTristate);
644
645 QVERIFY(!itemOutsideWidget.listWidget());
646 QCOMPARE(itemOutsideWidget.text(), QString("outsideWidget"));
647 QVERIFY(!(itemOutsideWidget.flags() & Qt::ItemIsTristate));
648
649 itemOutsideWidget = itemInWidget;
650 QVERIFY(!itemOutsideWidget.listWidget());
651 QCOMPARE(itemOutsideWidget.text(), QString("inWidget"));
652 QVERIFY(itemOutsideWidget.flags() & Qt::ItemIsTristate);
653 }
654
item_data()655 void tst_QListWidget::item_data()
656 {
657 QTest::addColumn<int>("row");
658 QTest::addColumn<bool>("outOfBounds");
659
660 QTest::newRow("First item, row: 0") << 0 << false;
661 QTest::newRow("Middle item, row: 1") << 1 << false;
662 QTest::newRow("Last item, row: 2") << 2 << false;
663 QTest::newRow("Out of bounds, row: -1") << -1 << true;
664 QTest::newRow("Out of bounds, row: 3") << 3 << true;
665 }
666
item()667 void tst_QListWidget::item()
668 {
669 QFETCH(int, row);
670 QFETCH(bool, outOfBounds);
671
672 (new QListWidgetItem(testWidget))->setText("item0");
673 (new QListWidgetItem(testWidget))->setText("item1");
674 (new QListWidgetItem(testWidget))->setText("item2");
675
676 QCOMPARE(testWidget->count(), 3);
677
678 QListWidgetItem *item = testWidget->item(row);
679 if (outOfBounds) {
680 QCOMPARE(item, static_cast<QListWidgetItem*>(0));
681 QCOMPARE(testWidget->count(), 3);
682 } else {
683 QCOMPARE(item->text(), QString("item%1").arg(row));
684 QCOMPARE(testWidget->count(), 3);
685 }
686 }
687
takeItem_data()688 void tst_QListWidget::takeItem_data()
689 {
690 QTest::addColumn<int>("row");
691 QTest::addColumn<bool>("outOfBounds");
692
693 QTest::newRow("First item, row: 0") << 0 << false;
694 QTest::newRow("Middle item, row: 1") << 1 << false;
695 QTest::newRow("Last item, row: 2") << 2 << false;
696 QTest::newRow("Out of bounds, row: -1") << -1 << true;
697 QTest::newRow("Out of bounds, row: 3") << 3 << true;
698 }
699
takeItem()700 void tst_QListWidget::takeItem()
701 {
702 QFETCH(int, row);
703 QFETCH(bool, outOfBounds);
704
705 (new QListWidgetItem(testWidget))->setText("item0");
706 (new QListWidgetItem(testWidget))->setText("item1");
707 (new QListWidgetItem(testWidget))->setText("item2");
708
709 QCOMPARE(testWidget->count(), 3);
710
711 QListWidgetItem *item = testWidget->takeItem(row);
712 if (outOfBounds) {
713 QCOMPARE(item, static_cast<QListWidgetItem*>(0));
714 QCOMPARE(testWidget->count(), 3);
715 } else {
716 QCOMPARE(item->text(), QString("item%1").arg(row));
717 QCOMPARE(testWidget->count(), 2);
718 }
719
720 delete item;
721 }
722
selectedItems_data()723 void tst_QListWidget::selectedItems_data()
724 {
725 QTest::addColumn<int>("itemCount");
726 QTest::addColumn<IntList>("hiddenRows");
727 QTest::addColumn<IntList>("selectedRows");
728 QTest::addColumn<IntList>("expectedRows");
729
730
731 QTest::newRow("none hidden, none selected")
732 << 3
733 << IntList()
734 << IntList()
735 << IntList();
736
737 QTest::newRow("none hidden, all selected")
738 << 3
739 << IntList()
740 << (IntList() << 0 << 1 << 2)
741 << (IntList() << 0 << 1 << 2);
742
743 QTest::newRow("first hidden, all selected")
744 << 3
745 << (IntList() << 0)
746 << (IntList() << 0 << 1 << 2)
747 << (IntList() << 0 << 1 << 2);
748
749 QTest::newRow("last hidden, all selected")
750 << 3
751 << (IntList() << 2)
752 << (IntList() << 0 << 1 << 2)
753 << (IntList() << 0 << 1 << 2);
754
755 QTest::newRow("middle hidden, all selected")
756 << 3
757 << (IntList() << 1)
758 << (IntList() << 0 << 1 << 2)
759 << (IntList() << 0 << 1 << 2);
760
761 QTest::newRow("all hidden, all selected")
762 << 3
763 << (IntList() << 0 << 1 << 2)
764 << (IntList() << 0 << 1 << 2)
765 << (IntList() << 0 << 1 << 2);
766 }
767
selectedItems()768 void tst_QListWidget::selectedItems()
769 {
770 QFETCH(int, itemCount);
771 QFETCH(IntList, hiddenRows);
772 QFETCH(IntList, selectedRows);
773 QFETCH(IntList, expectedRows);
774
775 QVERIFY(testWidget->count() == 0);
776
777 //insert items
778 for (int i=0; i<itemCount; ++i)
779 new QListWidgetItem(QString("Item%1").arg(i), testWidget);
780
781 //test the selection
782 testWidget->setSelectionMode(QListWidget::SingleSelection);
783 for (int i=0; i<itemCount; ++i) {
784 QListWidgetItem *item = testWidget->item(i);
785 testWidget->setItemSelected(item, true);
786 QVERIFY(item->isSelected());
787 QCOMPARE(testWidget->selectedItems().count(), 1);
788 }
789 //let's clear the selection
790 testWidget->clearSelection();
791 //... and set the selection mode to allow more than 1 item to be selected
792 testWidget->setSelectionMode(QAbstractItemView::MultiSelection);
793
794 //verify items are inserted
795 QCOMPARE(testWidget->count(), itemCount);
796 // hide items
797 foreach (int row, hiddenRows)
798 testWidget->setItemHidden(testWidget->item(row), true);
799 // select items
800 foreach (int row, selectedRows)
801 testWidget->setItemSelected(testWidget->item(row), true);
802
803 // check that the correct number of items and the expected items are there
804 QList<QListWidgetItem *> selectedItems = testWidget->selectedItems();
805 QCOMPARE(selectedItems.count(), expectedRows.count());
806 foreach (int row, expectedRows)
807 QVERIFY(selectedItems.contains(testWidget->item(row)));
808
809 //check that isSelected agrees with selectedItems
810 for (int i=0; i<itemCount; ++i) {
811 QListWidgetItem *item = testWidget->item(i);
812 if (testWidget->isItemSelected(item))
813 QVERIFY(selectedItems.contains(item));
814 }
815 }
816
removeItems_data()817 void tst_QListWidget::removeItems_data()
818 {
819 QTest::addColumn<int>("rowCount");
820 QTest::addColumn<int>("removeRows");
821 QTest::addColumn<int>("row");
822 QTest::addColumn<int>("expectedRowCount");
823
824 QTest::newRow("Empty") << 0 << 1 << 0 << 0;
825 QTest::newRow("1:1") << 1 << 1 << 0 << 0;
826 QTest::newRow("3:1") << 3 << 1 << 0 << 2;
827 QTest::newRow("3:2") << 3 << 2 << 0 << 1;
828 QTest::newRow("100:10") << 100 << 10 << 0 << 90;
829 }
830
removeItems()831 void tst_QListWidget::removeItems()
832 {
833 QFETCH(int, rowCount);
834 QFETCH(int, removeRows);
835 QFETCH(int, row);
836 QFETCH(int, expectedRowCount);
837
838 //insert items
839 for (int r = 0; r < rowCount; ++r)
840 new QListWidgetItem(QString::number(r), testWidget);
841
842 // remove and compare the results
843 for (int r = 0; r < removeRows; ++r)
844 delete testWidget->item(row);
845 QCOMPARE(testWidget->count(), expectedRowCount);
846
847 // check if the correct items were removed
848 for (int r = 0; r < expectedRowCount; ++r)
849 if (r < row)
850 QCOMPARE(testWidget->item(r)->text(), QString::number(r));
851 else
852 QCOMPARE(testWidget->item(r)->text(), QString::number(r + removeRows));
853
854
855 }
856
moveItemsPriv_data()857 void tst_QListWidget::moveItemsPriv_data()
858 {
859 QTest::addColumn<int>("rowCount");
860 QTest::addColumn<int>("srcRow");
861 QTest::addColumn<int>("dstRow");
862 QTest::addColumn<bool>("shouldHaveSignaled");
863
864 QTest::newRow("Empty") << 0 << 0 << 0 << false;
865 QTest::newRow("Overflow src") << 5 << 5 << 2 << false;
866 QTest::newRow("Underflow src") << 5 << -1 << 2 << false;
867 QTest::newRow("Overflow dst") << 5 << 2 << 6 << false;
868 QTest::newRow("Underflow dst") << 5 << 2 << -1 << false;
869 QTest::newRow("Same place") << 5 << 2 << 2 << false;
870 QTest::newRow("Up") << 5 << 4 << 2 << true;
871 QTest::newRow("Down") << 5 << 2 << 4 << true;
872 QTest::newRow("QTBUG-6532 assert") << 5 << 0 << 1 << false;
873 QTest::newRow("QTBUG-6565 to the end") << 5 << 3 << 5 << true;
874 QTest::newRow("Same place 2") << 2 << 0 << 1 << false;
875 QTest::newRow("swap") << 2 << 0 << 2 << true;
876 QTest::newRow("swap2") << 4 << 1 << 3 << true;
877 QTest::newRow("swap3") << 4 << 3 << 2 << true;
878 QTest::newRow("swap4") << 2 << 1 << 0 << true;
879 }
880
moveItemsPriv()881 void tst_QListWidget::moveItemsPriv()
882 {
883 QFETCH(int, rowCount);
884 QFETCH(int, srcRow);
885 QFETCH(int, dstRow);
886 QFETCH(bool, shouldHaveSignaled);
887
888 for (int r = 0; r < rowCount; ++r)
889 new QListWidgetItem(QString::number(r), testWidget);
890
891 QListModel *model = qobject_cast<QListModel *>(testWidget->model());
892 QVERIFY(model);
893 QSignalSpy beginMoveSpy(model, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
894 QSignalSpy movedSpy(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)));
895 model->move(srcRow, dstRow);
896
897 if (shouldHaveSignaled) {
898 if (srcRow < dstRow)
899 QCOMPARE(testWidget->item(dstRow - 1)->text(), QString::number(srcRow));
900 else
901 QCOMPARE(testWidget->item(dstRow)->text(), QString::number(srcRow));
902
903 QCOMPARE(beginMoveSpy.count(), 1);
904 const QList<QVariant> &beginMoveArgs = beginMoveSpy.takeFirst();
905 QCOMPARE(beginMoveArgs.at(1).toInt(), srcRow);
906 QCOMPARE(beginMoveArgs.at(2).toInt(), srcRow);
907 QCOMPARE(beginMoveArgs.at(4).toInt(), dstRow);
908
909 QCOMPARE(movedSpy.count(), 1);
910 const QList<QVariant> &movedArgs = movedSpy.takeFirst();
911 QCOMPARE(movedArgs.at(1).toInt(), srcRow);
912 QCOMPARE(movedArgs.at(2).toInt(), srcRow);
913 QCOMPARE(movedArgs.at(4).toInt(), dstRow);
914 } else {
915 QCOMPARE(beginMoveSpy.count(), 0);
916 QCOMPARE(movedSpy.count(), 0);
917 }
918 }
919
itemStreaming_data()920 void tst_QListWidget::itemStreaming_data()
921 {
922 QTest::addColumn<QString>("text");
923 QTest::addColumn<QString>("toolTip");
924
925 QTest::newRow("Data") << "item text" << "tool tip text";
926 }
927
itemStreaming()928 void tst_QListWidget::itemStreaming()
929 {
930 QFETCH(QString, text);
931 QFETCH(QString, toolTip);
932
933 QListWidgetItem item;
934 QCOMPARE(item.text(), QString());
935 QCOMPARE(item.toolTip(), QString());
936
937 item.setText(text);
938 item.setToolTip(toolTip);
939 QCOMPARE(item.text(), text);
940 QCOMPARE(item.toolTip(), toolTip);
941
942 QByteArray buffer;
943 QDataStream out(&buffer, QIODevice::WriteOnly);
944 out << item;
945
946 QListWidgetItem item2;
947 QCOMPARE(item2.text(), QString());
948 QCOMPARE(item2.toolTip(), QString());
949
950 QVERIFY(!buffer.isEmpty());
951
952 QDataStream in(&buffer, QIODevice::ReadOnly);
953 in >> item2;
954 QCOMPARE(item2.text(), text);
955 QCOMPARE(item2.toolTip(), toolTip);
956 }
957
sortItems_data()958 void tst_QListWidget::sortItems_data()
959 {
960 QTest::addColumn<int>("order");
961 QTest::addColumn<QVariantList>("initialList");
962 QTest::addColumn<QVariantList>("expectedList");
963 QTest::addColumn<IntList>("expectedRows");
964
965 QTest::newRow("ascending strings")
966 << static_cast<int>(Qt::AscendingOrder)
967 << (QVariantList() << QString("c") << QString("d") << QString("a") << QString("b"))
968 << (QVariantList() << QString("a") << QString("b") << QString("c") << QString("d"))
969 << (IntList() << 2 << 3 << 0 << 1);
970
971 QTest::newRow("descending strings")
972 << static_cast<int>(Qt::DescendingOrder)
973 << (QVariantList() << QString("c") << QString("d") << QString("a") << QString("b"))
974 << (QVariantList() << QString("d") << QString("c") << QString("b") << QString("a"))
975 << (IntList() << 1 << 0 << 3 << 2);
976
977 QTest::newRow("ascending numbers")
978 << static_cast<int>(Qt::AscendingOrder)
979 << (QVariantList() << 1 << 11 << 2 << 22)
980 << (QVariantList() << 1 << 2 << 11 << 22)
981 << (IntList() << 0 << 2 << 1 << 3);
982
983 QTest::newRow("descending numbers")
984 << static_cast<int>(Qt::DescendingOrder)
985 << (QVariantList() << 1 << 11 << 2 << 22)
986 << (QVariantList() << 22 << 11 << 2 << 1)
987 << (IntList() << 3 << 1 << 2 << 0);
988 }
989
sortItems()990 void tst_QListWidget::sortItems()
991 {
992 QFETCH(int, order);
993 QFETCH(QVariantList, initialList);
994 QFETCH(QVariantList, expectedList);
995 QFETCH(IntList, expectedRows);
996
997 foreach (const QVariant &data, initialList) {
998 QListWidgetItem *item = new QListWidgetItem(testWidget);
999 item->setData(Qt::DisplayRole, data);
1000 }
1001
1002 QAbstractItemModel *model = testWidget->model();
1003 QList<QPersistentModelIndex> persistent;
1004 for (int j = 0; j < model->rowCount(QModelIndex()); ++j)
1005 persistent << model->index(j, 0, QModelIndex());
1006
1007 testWidget->sortItems(static_cast<Qt::SortOrder>(order));
1008
1009 QCOMPARE(testWidget->count(), expectedList.count());
1010 for (int i = 0; i < testWidget->count(); ++i)
1011 QCOMPARE(testWidget->item(i)->text(), expectedList.at(i).toString());
1012
1013 for (int k = 0; k < testWidget->count(); ++k)
1014 QCOMPARE(persistent.at(k).row(), expectedRows.at(k));
1015 }
1016
sortHiddenItems_data()1017 void tst_QListWidget::sortHiddenItems_data()
1018 {
1019 QTest::addColumn<int>("order");
1020 QTest::addColumn<QStringList>("initialList");
1021 QTest::addColumn<QStringList>("expectedList");
1022 QTest::addColumn<IntList>("expectedRows");
1023 QTest::addColumn<IntList>("expectedVisibility");
1024
1025 QStringList initial, expected;
1026 IntList rowOrder;
1027 IntList visible;
1028 for (int i = 0; i < 20; ++i) {
1029 initial << QString(QChar(0x41 + i));
1030 expected << QString(QChar(0x54 - i));
1031 rowOrder << 19 - i;
1032 visible << (i % 2);
1033
1034 }
1035 QTest::newRow("descending order, 20 items")
1036 << static_cast<int>(Qt::DescendingOrder)
1037 << initial
1038 << expected
1039 << rowOrder
1040 << visible;
1041
1042 QTest::newRow("ascending order")
1043 << static_cast<int>(Qt::AscendingOrder)
1044 << (QStringList() << "c" << "d" << "a" << "b")
1045 << (QStringList() << "a" << "b" << "c" << "d")
1046 << (IntList() << 2 << 3 << 0 << 1)
1047 << (IntList() << 1 << 0 << 1 << 0);
1048
1049 QTest::newRow("descending order")
1050 << static_cast<int>(Qt::DescendingOrder)
1051 << (QStringList() << "c" << "d" << "a" << "b")
1052 << (QStringList() << "d" << "c" << "b" << "a")
1053 << (IntList() << 1 << 0 << 3 << 2)
1054 << (IntList() << 0 << 1 << 0 << 1);
1055 }
1056
sortHiddenItems()1057 void tst_QListWidget::sortHiddenItems()
1058 {
1059 QFETCH(int, order);
1060 QFETCH(QStringList, initialList);
1061 QFETCH(QStringList, expectedList);
1062 QFETCH(IntList, expectedRows);
1063 QFETCH(IntList, expectedVisibility);
1064
1065 // init() won't clear hidden items...
1066 QListWidget *tw = new QListWidget();
1067 tw->addItems(initialList);
1068
1069 QAbstractItemModel *model = tw->model();
1070 QList<QPersistentModelIndex> persistent;
1071 for (int j = 0; j < model->rowCount(QModelIndex()); ++j) {
1072 persistent << model->index(j, 0, QModelIndex());
1073 tw->setRowHidden(j, j & 1); // every odd is hidden
1074 }
1075
1076 tw->setSortingEnabled(true);
1077 tw->sortItems(static_cast<Qt::SortOrder>(order));
1078
1079 QCOMPARE(tw->count(), expectedList.count());
1080 for (int i = 0; i < tw->count(); ++i) {
1081 QCOMPARE(tw->item(i)->text(), expectedList.at(i));
1082 QCOMPARE(tw->item(i)->isHidden(), !expectedVisibility.at(i));
1083 }
1084
1085 for (int k = 0; k < tw->count(); ++k)
1086 QCOMPARE(persistent.at(k).row(), expectedRows.at(k));
1087
1088 delete tw;
1089 }
1090
modelChanged(ModelChanged change,const QModelIndex & parent,int first,int last)1091 void tst_QListWidget::modelChanged(ModelChanged change, const QModelIndex &parent,
1092 int first, int last)
1093 {
1094 rcParent[change] = parent;
1095 rcFirst[change] = first;
1096 rcLast[change] = last;
1097 }
1098
1099 class TestListWidget : public QListWidget {
1100 public:
TestListWidget()1101 TestListWidget() : QListWidget()
1102 {
1103
1104 }
getState()1105 State getState() {return QListWidget::state();}
1106
closeEditor(QWidget * w,QAbstractItemDelegate::EndEditHint hint)1107 void closeEditor(QWidget *w, QAbstractItemDelegate::EndEditHint hint) {
1108 QListWidget::closeEditor(w, hint);
1109 }
1110
isEditingState(QListWidgetItem * item)1111 bool isEditingState(QListWidgetItem *item) {
1112 Q_UNUSED(item);
1113 return (QListWidget::state() == QListWidget::EditingState ? true : false);
1114 }
1115 };
1116
closeEditor()1117 void tst_QListWidget::closeEditor()
1118 {
1119 TestListWidget w;
1120 QStringList labels = (QStringList() << "a" << "b" << "c" << "d");
1121 w.addItems(labels);
1122 QListWidgetItem *item = w.item(0);
1123 item->setFlags(item->flags() | Qt::ItemIsEditable);
1124 QVERIFY(item);
1125 w.editItem(item);
1126
1127 QVERIFY(w.isEditingState(item));
1128
1129 w.reset();
1130
1131 QVERIFY(!w.isEditingState(item));
1132 }
1133
setData_data()1134 void tst_QListWidget::setData_data()
1135 {
1136 QTest::addColumn<QStringList>("initialItems");
1137 QTest::addColumn<int>("itemIndex");
1138 QTest::addColumn<IntList>("roles");
1139 QTest::addColumn<QVariantList>("values");
1140 QTest::addColumn<int>("expectedSignalCount");
1141
1142 QStringList initialItems;
1143 IntList roles;
1144 QVariantList values;
1145
1146 {
1147 initialItems.clear(); roles.clear(); values.clear();
1148 initialItems << "foo";
1149 roles << Qt::DisplayRole;
1150 values << "xxx";
1151 QTest::newRow("changing a role should emit")
1152 << initialItems << 0 << roles << values << 1;
1153 }
1154 {
1155 initialItems.clear(); roles.clear(); values.clear();
1156 initialItems << "foo";
1157 roles << Qt::DisplayRole;
1158 values << "foo";
1159 QTest::newRow("setting the same value should not emit")
1160 << initialItems << 0 << roles << values << 0;
1161 }
1162 {
1163 initialItems.clear(); roles.clear(); values.clear();
1164 initialItems << "foo";
1165 roles << Qt::DisplayRole << Qt::DisplayRole;
1166 values << "bar" << "bar";
1167 QTest::newRow("setting the same value twice should only emit once")
1168 << initialItems << 0 << roles << values << 1;
1169 }
1170 {
1171 initialItems.clear(); roles.clear(); values.clear();
1172 initialItems << "foo";
1173 roles << Qt::DisplayRole << Qt::ToolTipRole << Qt::WhatsThisRole;
1174 values << "bar" << "bartooltip" << "barwhatsthis";
1175 QTest::newRow("changing three roles should emit three times")
1176 << initialItems << 0 << roles << values << 3;
1177 }
1178 }
1179
setData()1180 void tst_QListWidget::setData()
1181 {
1182 QFETCH(QStringList, initialItems);
1183 QFETCH(int, itemIndex);
1184 QFETCH(IntList, roles);
1185 QFETCH(QVariantList, values);
1186 QFETCH(int, expectedSignalCount);
1187 qRegisterMetaType<QListWidgetItem *>("QListWidgetItem*");
1188 qRegisterMetaType<QModelIndex>("QModelIndex");
1189
1190 QVERIFY(roles.count() == values.count());
1191
1192 for (int manipulateModel=0; manipulateModel<2; ++manipulateModel) {
1193 testWidget->clear();
1194 testWidget->insertItems(0, initialItems);
1195 QCOMPARE(testWidget->count(), initialItems.count());
1196
1197 QSignalSpy itemChanged(testWidget, SIGNAL(itemChanged(QListWidgetItem *)));
1198 QSignalSpy dataChanged(testWidget->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)));
1199
1200 for (int i=0; i < roles.count(); ++i) {
1201 if (manipulateModel)
1202 testWidget->model()->setData(
1203 testWidget->model()->index(itemIndex, 0, testWidget->rootIndex()),
1204 values.at(i),
1205 roles.at(i));
1206 else
1207 testWidget->item(itemIndex)->setData(roles.at(i), values.at(i));
1208 }
1209
1210 // make sure the data is actually set
1211 for (int i=0; i < roles.count(); ++i)
1212 QCOMPARE(testWidget->item(itemIndex)->data(roles.at(i)), values.at(i));
1213
1214 // make sure we get the right number of emits
1215 QCOMPARE(itemChanged.count(), expectedSignalCount);
1216 QCOMPARE(dataChanged.count(), expectedSignalCount);
1217 }
1218 }
1219
insertItemsWithSorting_data()1220 void tst_QListWidget::insertItemsWithSorting_data()
1221 {
1222 QTest::addColumn<int>("sortOrder");
1223 QTest::addColumn<QStringList>("initialItems");
1224 QTest::addColumn<QStringList>("insertItems");
1225 QTest::addColumn<QStringList>("expectedItems");
1226 QTest::addColumn<IntList>("expectedRows");
1227
1228 QTest::newRow("() + (a) = (a)")
1229 << static_cast<int>(Qt::AscendingOrder)
1230 << QStringList()
1231 << (QStringList() << "a")
1232 << (QStringList() << "a")
1233 << IntList();
1234 QTest::newRow("() + (c, b, a) = (a, b, c)")
1235 << static_cast<int>(Qt::AscendingOrder)
1236 << QStringList()
1237 << (QStringList() << "c" << "b" << "a")
1238 << (QStringList() << "a" << "b" << "c")
1239 << IntList();
1240 QTest::newRow("() + (a, b, c) = (c, b, a)")
1241 << static_cast<int>(Qt::DescendingOrder)
1242 << QStringList()
1243 << (QStringList() << "a" << "b" << "c")
1244 << (QStringList() << "c" << "b" << "a")
1245 << IntList();
1246 QTest::newRow("(a) + (b) = (a, b)")
1247 << static_cast<int>(Qt::AscendingOrder)
1248 << QStringList("a")
1249 << (QStringList() << "b")
1250 << (QStringList() << "a" << "b")
1251 << (IntList() << 0);
1252 QTest::newRow("(a) + (b) = (b, a)")
1253 << static_cast<int>(Qt::DescendingOrder)
1254 << QStringList("a")
1255 << (QStringList() << "b")
1256 << (QStringList() << "b" << "a")
1257 << (IntList() << 1);
1258 QTest::newRow("(a, c, b) + (d) = (a, b, c, d)")
1259 << static_cast<int>(Qt::AscendingOrder)
1260 << (QStringList() << "a" << "c" << "b")
1261 << (QStringList() << "d")
1262 << (QStringList() << "a" << "b" << "c" << "d")
1263 << (IntList() << 0 << 1 << 2);
1264 QTest::newRow("(b, c, a) + (d) = (d, c, b, a)")
1265 << static_cast<int>(Qt::DescendingOrder)
1266 << (QStringList() << "b" << "c" << "a")
1267 << (QStringList() << "d")
1268 << (QStringList() << "d" << "c" << "b" << "a")
1269 << (IntList() << 1 << 2 << 3);
1270 {
1271 IntList ascendingRows;
1272 IntList reverseRows;
1273 QStringList ascendingItems;
1274 QStringList reverseItems;
1275 for (int i = 'a'; i <= 'z'; ++i) {
1276 ascendingItems << QString("%0").arg(QLatin1Char(i));
1277 reverseItems << QString("%0").arg(QLatin1Char('z' - i + 'a'));
1278 ascendingRows << i - 'a';
1279 reverseRows << 'z' - i + 'a';
1280 }
1281 QTest::newRow("() + (sorted items) = (sorted items)")
1282 << static_cast<int>(Qt::AscendingOrder)
1283 << QStringList()
1284 << ascendingItems
1285 << ascendingItems
1286 << IntList();
1287 QTest::newRow("(sorted items) + () = (sorted items)")
1288 << static_cast<int>(Qt::AscendingOrder)
1289 << ascendingItems
1290 << QStringList()
1291 << ascendingItems
1292 << ascendingRows;
1293 QTest::newRow("() + (ascending items) = (reverse items)")
1294 << static_cast<int>(Qt::DescendingOrder)
1295 << QStringList()
1296 << ascendingItems
1297 << reverseItems
1298 << IntList();
1299 QTest::newRow("(reverse items) + () = (ascending items)")
1300 << static_cast<int>(Qt::AscendingOrder)
1301 << reverseItems
1302 << QStringList()
1303 << ascendingItems
1304 << ascendingRows;
1305 QTest::newRow("(reverse items) + () = (reverse items)")
1306 << static_cast<int>(Qt::DescendingOrder)
1307 << reverseItems
1308 << QStringList()
1309 << reverseItems
1310 << ascendingRows;
1311 }
1312 }
1313
insertItemsWithSorting()1314 void tst_QListWidget::insertItemsWithSorting()
1315 {
1316 QFETCH(int, sortOrder);
1317 QFETCH(QStringList, initialItems);
1318 QFETCH(QStringList, insertItems);
1319 QFETCH(QStringList, expectedItems);
1320 QFETCH(IntList, expectedRows);
1321
1322 for (int method = 0; method < 5; ++method) {
1323 QListWidget w;
1324 w.setSortingEnabled(true);
1325 w.sortItems(static_cast<Qt::SortOrder>(sortOrder));
1326 w.addItems(initialItems);
1327
1328 QAbstractItemModel *model = w.model();
1329 QList<QPersistentModelIndex> persistent;
1330 for (int j = 0; j < model->rowCount(QModelIndex()); ++j)
1331 persistent << model->index(j, 0, QModelIndex());
1332
1333 switch (method) {
1334 case 0:
1335 // insert using item constructor
1336 for (int i = 0; i < insertItems.size(); ++i)
1337 new QListWidgetItem(insertItems.at(i), &w);
1338 break;
1339 case 1:
1340 // insert using insertItems()
1341 w.insertItems(0, insertItems);
1342 break;
1343 case 2:
1344 // insert using insertItem()
1345 for (int i = 0; i < insertItems.size(); ++i)
1346 w.insertItem(0, insertItems.at(i));
1347 break;
1348 case 3:
1349 // insert using addItems()
1350 w.addItems(insertItems);
1351 break;
1352 case 4:
1353 // insert using addItem()
1354 for (int i = 0; i < insertItems.size(); ++i)
1355 w.addItem(insertItems.at(i));
1356 break;
1357 }
1358 QCOMPARE(w.count(), expectedItems.count());
1359 for (int i = 0; i < w.count(); ++i)
1360 QCOMPARE(w.item(i)->text(), expectedItems.at(i));
1361
1362 for (int k = 0; k < persistent.count(); ++k)
1363 QCOMPARE(persistent.at(k).row(), expectedRows.at(k));
1364 }
1365 }
1366
changeDataWithSorting_data()1367 void tst_QListWidget::changeDataWithSorting_data()
1368 {
1369 QTest::addColumn<int>("sortOrder");
1370 QTest::addColumn<QStringList>("initialItems");
1371 QTest::addColumn<int>("itemIndex");
1372 QTest::addColumn<QString>("newValue");
1373 QTest::addColumn<QStringList>("expectedItems");
1374 QTest::addColumn<IntList>("expectedRows");
1375 QTest::addColumn<bool>("reorderingExpected");
1376
1377 QTest::newRow("change a to b in (a)")
1378 << static_cast<int>(Qt::AscendingOrder)
1379 << (QStringList() << "a")
1380 << 0 << "b"
1381 << (QStringList() << "b")
1382 << (IntList() << 0)
1383 << false;
1384 QTest::newRow("change a to b in (a, c)")
1385 << static_cast<int>(Qt::AscendingOrder)
1386 << (QStringList() << "a" << "c")
1387 << 0 << "b"
1388 << (QStringList() << "b" << "c")
1389 << (IntList() << 0 << 1)
1390 << false;
1391 QTest::newRow("change a to c in (a, b)")
1392 << static_cast<int>(Qt::AscendingOrder)
1393 << (QStringList() << "a" << "b")
1394 << 0 << "c"
1395 << (QStringList() << "b" << "c")
1396 << (IntList() << 1 << 0)
1397 << true;
1398 QTest::newRow("change c to a in (c, b)")
1399 << static_cast<int>(Qt::DescendingOrder)
1400 << (QStringList() << "c" << "b")
1401 << 0 << "a"
1402 << (QStringList() << "b" << "a")
1403 << (IntList() << 1 << 0)
1404 << true;
1405 QTest::newRow("change e to i in (a, c, e, g)")
1406 << static_cast<int>(Qt::AscendingOrder)
1407 << (QStringList() << "a" << "c" << "e" << "g")
1408 << 2 << "i"
1409 << (QStringList() << "a" << "c" << "g" << "i")
1410 << (IntList() << 0 << 1 << 3 << 2)
1411 << true;
1412 QTest::newRow("change e to a in (c, e, g, i)")
1413 << static_cast<int>(Qt::AscendingOrder)
1414 << (QStringList() << "c" << "e" << "g" << "i")
1415 << 1 << "a"
1416 << (QStringList() << "a" << "c" << "g" << "i")
1417 << (IntList() << 1 << 0 << 2 << 3)
1418 << true;
1419 QTest::newRow("change e to f in (c, e, g, i)")
1420 << static_cast<int>(Qt::AscendingOrder)
1421 << (QStringList() << "c" << "e" << "g" << "i")
1422 << 1 << "f"
1423 << (QStringList() << "c" << "f" << "g" << "i")
1424 << (IntList() << 0 << 1 << 2 << 3)
1425 << false;
1426 }
1427
itemData()1428 void tst_QListWidget::itemData()
1429 {
1430 QListWidget widget;
1431 QListWidgetItem item(&widget);
1432 item.setFlags(item.flags() | Qt::ItemIsEditable);
1433 item.setData(Qt::DisplayRole, QString("0"));
1434 item.setData(Qt::CheckStateRole, Qt::PartiallyChecked);
1435 item.setData(Qt::UserRole + 0, QString("1"));
1436 item.setData(Qt::UserRole + 1, QString("2"));
1437 item.setData(Qt::UserRole + 2, QString("3"));
1438 item.setData(Qt::UserRole + 3, QString("4"));
1439 QMap<int, QVariant> flags = widget.model()->itemData(widget.model()->index(0, 0));
1440 QCOMPARE(flags.count(), 6);
1441 QCOMPARE(flags[Qt::UserRole + 0].toString(), QString("1"));
1442 }
1443
changeDataWithSorting()1444 void tst_QListWidget::changeDataWithSorting()
1445 {
1446 QFETCH(int, sortOrder);
1447 QFETCH(QStringList, initialItems);
1448 QFETCH(int, itemIndex);
1449 QFETCH(QString, newValue);
1450 QFETCH(QStringList, expectedItems);
1451 QFETCH(IntList, expectedRows);
1452 QFETCH(bool, reorderingExpected);
1453
1454 QListWidget w;
1455 w.setSortingEnabled(true);
1456 w.sortItems(static_cast<Qt::SortOrder>(sortOrder));
1457 w.addItems(initialItems);
1458
1459 QAbstractItemModel *model = w.model();
1460 QList<QPersistentModelIndex> persistent;
1461 for (int j = 0; j < model->rowCount(QModelIndex()); ++j)
1462 persistent << model->index(j, 0, QModelIndex());
1463
1464 QSignalSpy dataChangedSpy(model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)));
1465 QSignalSpy layoutChangedSpy(model, SIGNAL(layoutChanged()));
1466
1467 QListWidgetItem *item = w.item(itemIndex);
1468 item->setText(newValue);
1469 for (int i = 0; i < expectedItems.count(); ++i) {
1470 QCOMPARE(w.item(i)->text(), expectedItems.at(i));
1471 for (int j = 0; j < persistent.count(); ++j) {
1472 if (persistent.at(j).row() == i) // the same toplevel row
1473 QCOMPARE(persistent.at(j).internalPointer(), (void *)w.item(i));
1474 }
1475 }
1476
1477 for (int k = 0; k < persistent.count(); ++k)
1478 QCOMPARE(persistent.at(k).row(), expectedRows.at(k));
1479
1480 QCOMPARE(dataChangedSpy.count(), 1);
1481 QCOMPARE(layoutChangedSpy.count(), reorderingExpected ? 1 : 0);
1482 }
1483
itemWidget()1484 void tst_QListWidget::itemWidget()
1485 {
1486 QListWidget list;
1487 QWidget widget;
1488
1489 QListWidgetItem *item = new QListWidgetItem(&list);
1490
1491
1492 QCOMPARE(list.itemWidget(item), static_cast<QWidget*>(0));
1493 list.setItemWidget(item, &widget);
1494 QCOMPARE(list.itemWidget(item), &widget);
1495 list.removeItemWidget(item);
1496 QCOMPARE(list.itemWidget(item), static_cast<QWidget*>(0));
1497 }
1498
1499 #ifndef Q_WS_MAC
1500 class MyListWidget : public QListWidget
1501 {
1502 public:
MyListWidget(QWidget * parent=0)1503 MyListWidget(QWidget *parent=0)
1504 : QListWidget(parent)
1505 {
1506 }
1507
paintEvent(QPaintEvent * e)1508 void paintEvent(QPaintEvent *e) {
1509 painted += e->region();
1510 QListWidget::paintEvent(e);
1511 }
1512
1513 QRegion painted;
1514 };
1515
fastScroll()1516 void tst_QListWidget::fastScroll()
1517 {
1518 if (qstrcmp(QApplication::style()->metaObject()->className(), "QS60Style") == 0) {
1519 QSKIP("S60 style doesn't support fast scrolling", SkipAll);
1520 }
1521
1522 QWidget topLevel;
1523 MyListWidget widget(&topLevel);
1524 for (int i = 0; i < 50; ++i)
1525 widget.addItem(QString("Item %1").arg(i));
1526
1527 topLevel.resize(300, 300); // toplevel needs to be wide enough for the item
1528 topLevel.show();
1529 // Make sure the widget gets the first full repaint. On
1530 // some WMs, we'll get two (first inactive exposure, then
1531 // active exposure.
1532 QTest::qWaitForWindowShown(&widget);
1533 #ifdef Q_WS_X11
1534 qt_x11_wait_for_window_manager(&widget);
1535 #endif
1536 QApplication::processEvents();
1537 QTest::qWait(500);
1538
1539 QSize itemSize = widget.visualItemRect(widget.item(0)).size();
1540 QVERIFY(!itemSize.isEmpty());
1541
1542 QScrollBar *sbar = widget.verticalScrollBar();
1543 widget.setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
1544 widget.painted = QRegion();
1545 sbar->setValue(sbar->value() + sbar->singleStep());
1546 QApplication::processEvents();
1547
1548 // only one item should be repainted, the rest should be scrolled in memory
1549 #ifdef Q_OS_WIN
1550 if (widget.painted.boundingRect().size() != itemSize) {
1551 QEXPECT_FAIL("", "QTBUG-26892", Abort);
1552 }
1553 #endif
1554 QCOMPARE(widget.painted.boundingRect().size(), itemSize);
1555 }
1556 #endif // Q_WS_MAC
1557
insertUnchanged()1558 void tst_QListWidget::insertUnchanged()
1559 {
1560 QListWidget w;
1561 QSignalSpy itemChangedSpy(&w, SIGNAL(itemChanged(QListWidgetItem*)));
1562 QListWidgetItem item("foo", &w);
1563 QCOMPARE(itemChangedSpy.count(), 0);
1564 }
1565
setSortingEnabled()1566 void tst_QListWidget::setSortingEnabled()
1567 {
1568 QListWidget w;
1569 QListWidgetItem *item1 = new QListWidgetItem(&w);
1570 QListWidgetItem *item2 = new QListWidgetItem(&w);
1571
1572 w.setSortingEnabled(true);
1573 QCOMPARE(w.isSortingEnabled(), true);
1574 QCOMPARE(w.item(0), item1);
1575 QCOMPARE(w.item(1), item2);
1576 }
1577
task199503_crashWhenCleared()1578 void tst_QListWidget::task199503_crashWhenCleared()
1579 {
1580 //we test here for a crash that would occur if you clear the items in the currentItemChanged signal
1581 QListWidget w;
1582 w.addItems( QStringList() << "item1" << "item2" << "item3");
1583 w.setCurrentRow(0);
1584 w.connect(&w, SIGNAL(currentItemChanged(QListWidgetItem *,QListWidgetItem*)), SLOT(clear()));
1585 w.setCurrentRow(1);
1586 }
1587
task217070_scrollbarsAdjusted()1588 void tst_QListWidget::task217070_scrollbarsAdjusted()
1589 {
1590 //This task was mailing for style using SH_ScrollView_FrameOnlyAroundContents such as QMotifStyle
1591 QListWidget v;
1592 for (int i = 0; i<200;i++)
1593 v.addItem(QString::number(i));
1594 v.show();
1595 v.setViewMode(QListView::IconMode);
1596 v.setResizeMode(QListView::Adjust);
1597 v.setUniformItemSizes(true);
1598 v.resize(160,100);
1599 QTest::qWait(50);
1600 for(int f=150; f>90 ; f--) {
1601 v.resize(f,100);
1602 QTest::qWait(30);
1603 QVERIFY(v.verticalScrollBar()->isVisible());
1604 //the vertical scrollbar must not be visible.
1605 QVERIFY(!v.horizontalScrollBar()->isVisible());
1606 }
1607 }
1608
task258949_keypressHangup()1609 void tst_QListWidget::task258949_keypressHangup()
1610 {
1611 QListWidget lw;
1612 for (int y = 0; y < 5; y++) {
1613 QListWidgetItem *lwi = new QListWidgetItem(&lw);
1614 lwi->setText(y ? "1" : "0");
1615 if (y)
1616 lwi->setFlags(Qt::ItemIsSelectable);
1617 }
1618
1619 lw.show();
1620 lw.setCurrentIndex(lw.model()->index(0,0));
1621 QCOMPARE(lw.currentIndex(), lw.model()->index(0,0));
1622 QTest::qWait(30);
1623 QTest::keyPress(&lw, '1'); //this used to freeze
1624 QTest::qWait(30);
1625 QCOMPARE(lw.currentIndex(), lw.model()->index(0,0));
1626 }
1627
QTBUG8086_currentItemChangedOnClick()1628 void tst_QListWidget::QTBUG8086_currentItemChangedOnClick()
1629 {
1630 qRegisterMetaType<QListWidgetItem*>("QListWidgetItem*");
1631 QWidget win;
1632 QHBoxLayout layout(&win);
1633 QListWidget list;
1634 for (int i = 0 ; i < 4; ++i)
1635 new QListWidgetItem(QString::number(i), &list);
1636
1637 layout.addWidget(&list);
1638
1639 QLineEdit edit;
1640 layout.addWidget(&edit);
1641
1642 edit.setFocus();
1643 win.show();
1644
1645 QSignalSpy spy(&list, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)));
1646
1647 QTest::qWaitForWindowShown(&win);
1648
1649 QCOMPARE(spy.count(), 0);
1650
1651 QTest::mouseClick(list.viewport(), Qt::LeftButton, 0, list.visualItemRect(list.item(2)).center());
1652
1653 QCOMPARE(spy.count(), 1);
1654
1655 }
1656
1657
1658 class ItemDelegate : public QItemDelegate
1659 {
1660 public:
ItemDelegate(QObject * parent=0)1661 ItemDelegate(QObject *parent = 0) : QItemDelegate(parent)
1662 {}
createEditor(QWidget * parent,const QStyleOptionViewItem &,const QModelIndex &) const1663 virtual QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &, const QModelIndex &) const
1664 {
1665 QLineEdit *lineEdit = new QLineEdit(parent);
1666 lineEdit->setFrame(false);
1667 QCompleter *completer = new QCompleter(QStringList() << "completer", lineEdit);
1668 completer->setCompletionMode(QCompleter::InlineCompletion);
1669 lineEdit->setCompleter(completer);
1670 return lineEdit;
1671 }
1672 };
1673
QTBUG14363_completerWithAnyKeyPressedEditTriggers()1674 void tst_QListWidget::QTBUG14363_completerWithAnyKeyPressedEditTriggers()
1675 {
1676 QListWidget listWidget;
1677 listWidget.setEditTriggers(QAbstractItemView::AnyKeyPressed);
1678 listWidget.setItemDelegate(new ItemDelegate);
1679 QListWidgetItem *item = new QListWidgetItem(QLatin1String("select an item (don't start editing)"), &listWidget);
1680 item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable|Qt::ItemIsEditable);
1681 new QListWidgetItem(QLatin1String("try to type the letter 'c'"), &listWidget);
1682 new QListWidgetItem(QLatin1String("completer"), &listWidget);
1683 listWidget.show();
1684 listWidget.setCurrentItem(item);
1685 QTest::qWaitForWindowShown(&listWidget);
1686
1687 QTest::keyClick(listWidget.viewport(), Qt::Key_C);
1688
1689 QLineEdit *le = qobject_cast<QLineEdit*>(listWidget.itemWidget(item));
1690 QVERIFY(le);
1691 QCOMPARE(le->text(), QString("completer"));
1692 QCOMPARE(le->completer()->currentCompletion(), QString("completer"));
1693 }
1694
1695
1696
1697 QTEST_MAIN(tst_QListWidget)
1698 #include "tst_qlistwidget.moc"
1699