diff options
Diffstat (limited to 'tests/auto/widgets/itemviews/qlistwidget/tst_qlistwidget.cpp')
| -rw-r--r-- | tests/auto/widgets/itemviews/qlistwidget/tst_qlistwidget.cpp | 1685 |
1 files changed, 1685 insertions, 0 deletions
diff --git a/tests/auto/widgets/itemviews/qlistwidget/tst_qlistwidget.cpp b/tests/auto/widgets/itemviews/qlistwidget/tst_qlistwidget.cpp new file mode 100644 index 0000000000..9ede38f553 --- /dev/null +++ b/tests/auto/widgets/itemviews/qlistwidget/tst_qlistwidget.cpp @@ -0,0 +1,1685 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include <QtTest/QtTest> +#include <QtGui/QtGui> +#include <QtWidgets/QtWidgets> +#include <qeventloop.h> +#include <qlist.h> + +#include <qlistwidget.h> +#include <private/qlistwidget_p.h> + +//TESTED_CLASS= +//TESTED_FILES= + +class tst_QListWidget : public QObject +{ + Q_OBJECT + +public: + tst_QListWidget(); + ~tst_QListWidget(); + + enum ModelChanged { + RowsAboutToBeInserted, + RowsInserted, + RowsAboutToBeRemoved, + RowsRemoved, + ColumnsAboutToBeInserted, + ColumnsInserted, + ColumnsAboutToBeRemoved, + ColumnsRemoved + }; + +public slots: + void initTestCase(); + void cleanupTestCase(); + void init(); + void cleanup(); + +private slots: + void addItem(); + void addItem2(); + void addItems(); + void openPersistentEditor(); + void closePersistentEditor(); + void count(); + void currentItem(); + void setCurrentItem_data(); + void setCurrentItem(); + void currentRow(); + void setCurrentRow_data(); + void setCurrentRow(); + void editItem_data(); + void editItem(); + void findItems(); + void insertItem_data(); + void insertItem(); + void insertItems_data(); + void insertItems(); + void moveItemsPriv_data(); + void moveItemsPriv(); + + void itemAssignment(); + void item_data(); + void item(); + void takeItem_data(); + void takeItem(); + void setItemHidden(); + void selectedItems_data(); + void selectedItems(); + void removeItems_data(); + void removeItems(); + void itemStreaming_data(); + void itemStreaming(); + void sortItems_data(); + void sortItems(); + void sortHiddenItems(); + void sortHiddenItems_data(); + void closeEditor(); + void setData_data(); + void setData(); + void insertItemsWithSorting_data(); + void insertItemsWithSorting(); + void changeDataWithSorting_data(); + void changeDataWithSorting(); + void itemData(); + void itemWidget(); +#ifndef Q_WS_MAC + void fastScroll(); +#endif + void insertUnchanged(); + void setSortingEnabled(); + void task199503_crashWhenCleared(); + void task217070_scrollbarsAdjusted(); + void task258949_keypressHangup(); + void QTBUG8086_currentItemChangedOnClick(); + void QTBUG14363_completerWithAnyKeyPressedEditTriggers(); + + +protected slots: + void rowsAboutToBeInserted(const QModelIndex &parent, int first, int last) + { modelChanged(RowsAboutToBeInserted, parent, first, last); } + void rowsInserted(const QModelIndex &parent, int first, int last) + { modelChanged(RowsInserted, parent, first, last); } + void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last) + { modelChanged(RowsAboutToBeRemoved, parent, first, last); } + void rowsRemoved(const QModelIndex &parent, int first, int last) + { modelChanged(RowsRemoved, parent, first, last); } + void columnsAboutToBeInserted(const QModelIndex &parent, int first, int last) + { modelChanged(ColumnsAboutToBeInserted, parent, first, last); } + void columnsInserted(const QModelIndex &parent, int first, int last) + { modelChanged(ColumnsInserted, parent, first, last); } + void columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last) + { modelChanged(ColumnsAboutToBeRemoved, parent, first, last); } + void columnsRemoved(const QModelIndex &parent, int first, int last) + { modelChanged(ColumnsRemoved, parent, first, last); } + + void modelChanged(ModelChanged change, const QModelIndex &parent, int first, int last); + +private: + QListWidget *testWidget; + QVector<QModelIndex> rcParent; + QVector<int> rcFirst; + QVector<int> rcLast; + + void populate(); + void checkDefaultValues(); +}; + + +typedef QList<int> IntList; +Q_DECLARE_METATYPE(IntList) +Q_DECLARE_METATYPE(QVariantList) + +tst_QListWidget::tst_QListWidget(): testWidget(0), rcParent(8), rcFirst(8,0), rcLast(8,0) +{ +} + +tst_QListWidget::~tst_QListWidget() +{ +} + +void tst_QListWidget::initTestCase() +{ + testWidget = new QListWidget(); + testWidget->show(); + + connect(testWidget->model(), SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)), + this, SLOT(rowsAboutToBeInserted(QModelIndex, int, int))); + connect(testWidget->model(), SIGNAL(rowsInserted(QModelIndex, int, int)), + this, SLOT(rowsInserted(QModelIndex, int, int))); + connect(testWidget->model(), SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), + this, SLOT(rowsAboutToBeRemoved(QModelIndex, int, int))); + connect(testWidget->model(), SIGNAL(rowsRemoved(QModelIndex, int, int)), + this, SLOT(rowsRemoved(QModelIndex, int, int))); + + connect(testWidget->model(), SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)), + this, SLOT(columnsAboutToBeInserted(QModelIndex, int, int))); + connect(testWidget->model(), SIGNAL(columnsInserted(QModelIndex, int, int)), + this, SLOT(columnsInserted(QModelIndex, int, int))); + connect(testWidget->model(), SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)), + this, SLOT(columnsAboutToBeRemoved(QModelIndex, int, int))); + connect(testWidget->model(), SIGNAL(columnsRemoved(QModelIndex, int, int)), + this, SLOT(columnsRemoved(QModelIndex, int, int))); + + checkDefaultValues(); +} + +void tst_QListWidget::cleanupTestCase() +{ + delete testWidget; +} + +void tst_QListWidget::init() +{ + testWidget->clear(); + + if (testWidget->viewport()->children().count() > 0) { + QEventLoop eventLoop; + for (int i=0; i < testWidget->viewport()->children().count(); ++i) + connect(testWidget->viewport()->children().at(i), SIGNAL(destroyed()), &eventLoop, SLOT(quit())); + QTimer::singleShot(100, &eventLoop, SLOT(quit())); + eventLoop.exec(); + } +} + +void tst_QListWidget::checkDefaultValues() +{ + QCOMPARE(testWidget->currentItem(), (QListWidgetItem *)0); + QCOMPARE(testWidget->currentRow(), -1); + QCOMPARE(testWidget->count(), 0); +} + +void tst_QListWidget::cleanup() +{ +} + +void tst_QListWidget::populate() +{ + addItem(); + addItem2(); + addItems(); + setItemHidden(); + + testWidget->setCurrentIndex(testWidget->model()->index(0,0)); + + // setCurrentItem(); + // setCurrentRow(); +} + +void tst_QListWidget::addItem() +{ + int count = testWidget->count(); + QString label = QString("%1").arg(count); + testWidget->addItem(label); + QCOMPARE(testWidget->count(), ++count); + QCOMPARE(testWidget->item(testWidget->count()-1)->text(), label); +} + +void tst_QListWidget::addItem2() +{ + int count = testWidget->count(); + + // Boundary Checking + testWidget->addItem(0); + QCOMPARE(testWidget->count(), count); + + QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(count)); + item->setFlags(item->flags() | Qt::ItemIsEditable); + testWidget->addItem(item); + QCOMPARE(testWidget->count(), ++count); + QCOMPARE(testWidget->item(testWidget->count()-1), item); + QCOMPARE(testWidget->isItemHidden(item), false); +} + +void tst_QListWidget::addItems() +{ + int count = testWidget->count(); + + // Boundary Checking + testWidget->addItems(QStringList()); + QCOMPARE(testWidget->count(), count); + + QStringList stringList; + QString label = QString("%1").arg(count); + stringList << QString("%1").arg(testWidget->count() + 1) + << QString("%1").arg(testWidget->count() + 2) + << QString("%1").arg(testWidget->count() + 3) + << label; + testWidget->addItems(stringList); + QCOMPARE(testWidget->count(), count + stringList.count()); + QCOMPARE(testWidget->item(testWidget->count()-1)->text(), label); +} + + +void tst_QListWidget::openPersistentEditor() +{ + // Boundary checking + testWidget->openPersistentEditor(0); + QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count())); + testWidget->openPersistentEditor(item); + + int childCount = testWidget->viewport()->children().count(); + testWidget->addItem(item); + testWidget->openPersistentEditor(item); + QCOMPARE(childCount + 1, testWidget->viewport()->children().count()); +} + +void tst_QListWidget::closePersistentEditor() +{ + // Boundary checking + int childCount = testWidget->viewport()->children().count(); + testWidget->closePersistentEditor(0); + QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count())); + testWidget->closePersistentEditor(item); + QCOMPARE(childCount, testWidget->viewport()->children().count()); + + // Create something + testWidget->addItem(item); + testWidget->openPersistentEditor(item); + + // actual test + childCount = testWidget->viewport()->children().count(); + testWidget->closePersistentEditor(item); + // Spin the event loop and hopefully it will die. + QEventLoop eventLoop; + for (int i=0; i < childCount; ++i) + connect(testWidget->viewport()->children().at(i), SIGNAL(destroyed()), &eventLoop, SLOT(quit())); + QTimer::singleShot(100, &eventLoop, SLOT(quit())); + eventLoop.exec(); + QCOMPARE(testWidget->viewport()->children().count(), childCount - 1); +} + +void tst_QListWidget::setItemHidden() +{ + // Boundary checking + testWidget->setItemHidden(0, true); + testWidget->setItemHidden(0, false); + + int totalHidden = 0; + for (int i = 0; i < testWidget->model()->rowCount(); ++i) + if (testWidget->isItemHidden(testWidget->item(i))) + totalHidden++; + + QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count())); + testWidget->addItem(item); + + // Check that nothing else changed + int newTotal = 0; + for (int i = 0; i < testWidget->model()->rowCount(); ++i) + if (testWidget->isItemHidden(testWidget->item(i))) + newTotal++; + QCOMPARE(newTotal, totalHidden); + + testWidget->setItemHidden(item, true); + QCOMPARE(testWidget->isItemHidden(item), true); + + // Check that nothing else changed + newTotal = 0; + for (int i = 0; i < testWidget->model()->rowCount(); ++i) + if (testWidget->isItemHidden(testWidget->item(i))) + newTotal++; + QCOMPARE(newTotal, totalHidden + 1); + + testWidget->setItemHidden(item, false); + QCOMPARE(testWidget->isItemHidden(item), false); + + // Check that nothing else changed + newTotal = 0; + for (int i = 0; i < testWidget->model()->rowCount(); ++i) + if (testWidget->isItemHidden(testWidget->item(i))) + newTotal++; + QCOMPARE(newTotal, totalHidden); + + testWidget->setItemHidden(item, true); +} + +void tst_QListWidget::setCurrentItem_data() +{ + QTest::addColumn<int>("fill"); + QTest::newRow("HasItems: 0") << 0; + QTest::newRow("HasItems: 1") << 1; + QTest::newRow("HasItems: 2") << 2; + QTest::newRow("HasItems: 3") << 3; +} + +void tst_QListWidget::setCurrentItem() +{ + QFETCH(int, fill); + for (int i = 0; i < fill; ++i) + testWidget->addItem(QString("%1").arg(i)); + + // Boundary checking + testWidget->setCurrentItem((QListWidgetItem *)0); + QCOMPARE((QListWidgetItem *)0, testWidget->currentItem()); + QListWidgetItem item; + testWidget->setCurrentItem(&item); + QCOMPARE((QListWidgetItem *)0, testWidget->currentItem()); + + // Make sure that currentItem changes to what is passed into setCurrentItem + for (int i = 0; i < testWidget->count(); ++i) { + testWidget->setCurrentItem(testWidget->item(i)); + for (int j = 0; j < testWidget->count(); ++j) { + testWidget->setCurrentItem(testWidget->item(j)); + QCOMPARE(testWidget->item(j), testWidget->currentItem()); + } + } +} + +void tst_QListWidget::setCurrentRow_data() +{ + QTest::addColumn<int>("fill"); + QTest::newRow("HasItems: 0") << 0; + QTest::newRow("HasItems: 1") << 1; + QTest::newRow("HasItems: 2") << 2; + QTest::newRow("HasItems: 3") << 3; +} + +void tst_QListWidget::setCurrentRow() +{ + QFETCH(int, fill); + for (int i = 0; i < fill; ++i) + testWidget->addItem(QString("%1").arg(i)); + + // Boundary checking + testWidget->setCurrentRow(-1); + QCOMPARE(-1, testWidget->currentRow()); + testWidget->setCurrentRow(testWidget->count()); + QCOMPARE(-1, testWidget->currentRow()); + + // Make sure that currentRow changes to what is passed into setCurrentRow + for (int i = 0; i < testWidget->count(); ++i) { + testWidget->setCurrentRow(i); + for (int j = 0; j < testWidget->count(); ++j) { + testWidget->setCurrentRow(j); + QCOMPARE(j, testWidget->currentRow()); + } + } +} + +void tst_QListWidget::count() +{ + populate(); + + // actual test + QCOMPARE(testWidget->model()->rowCount(), testWidget->count()); +} + +void tst_QListWidget::currentItem() +{ + populate(); + + // actual test + QModelIndex currentIndex = testWidget->selectionModel()->currentIndex(); + if (currentIndex.isValid()) + QVERIFY(testWidget->currentItem() == testWidget->item(currentIndex.row())); + else + QVERIFY(testWidget->currentItem() == (QListWidgetItem*)0); +} + +void tst_QListWidget::currentRow() +{ + populate(); + + // actual test + QModelIndex currentIndex = testWidget->selectionModel()->currentIndex(); + if (currentIndex.isValid()) + QCOMPARE(testWidget->currentRow(), currentIndex.row()); + else + QCOMPARE(testWidget->currentRow(), -1); +} + +void tst_QListWidget::editItem_data() +{ + QTest::addColumn<bool>("editable"); + QTest::newRow("editable") << true; + QTest::newRow("not editable") << false; +} + +void tst_QListWidget::editItem() +{ + // Boundary checking + testWidget->editItem(0); + QListWidgetItem *item = new QListWidgetItem(QString("%1").arg(testWidget->count())); + testWidget->editItem(item); + + QFETCH(bool, editable); + if (editable) + item->setFlags(item->flags() | Qt::ItemIsEditable); + testWidget->addItem(item); + + int childCount = testWidget->viewport()->children().count(); + QWidget *existsAlready = testWidget->indexWidget(testWidget->model()->index(testWidget->row(item), 0)); + testWidget->editItem(item); + Qt::ItemFlags flags = item->flags(); + + // There doesn't seem to be a way to detect if the item has already been edited... + if (!existsAlready && flags & Qt::ItemIsEditable && flags & Qt::ItemIsEnabled) { + QList<QObject *> children = testWidget->viewport()->children(); + QVERIFY(children.count() > childCount); + bool found = false; + for (int i = 0; i < children.size(); ++i) { + if (children.at(i)->inherits("QExpandingLineEdit")) + found = true; + } + QVERIFY(found); + } else { + QCOMPARE(testWidget->viewport()->children().count(), childCount); + } +} + +void tst_QListWidget::findItems() +{ + // This really just tests that the items that are returned are converted from index's to items correctly. + + // Boundary checking + QCOMPARE(testWidget->findItems("GirlsCanWearJeansAndCutTheirHairShort", Qt::MatchExactly).count(), 0); + + populate(); + + for (int i=0; i < testWidget->count(); ++i) + QCOMPARE(testWidget->findItems( (testWidget->item(i)->text()), Qt::MatchExactly).count(), 1); +} + + +void tst_QListWidget::insertItem_data() +{ + QTest::addColumn<QStringList>("initialItems"); + QTest::addColumn<int>("insertIndex"); + QTest::addColumn<QString>("itemLabel"); + QTest::addColumn<int>("expectedIndex"); + + QStringList initialItems; + initialItems << "foo" << "bar"; + + QTest::newRow("Insert less then 0") << initialItems << -1 << "inserted" << 0; + QTest::newRow("Insert at 0") << initialItems << 0 << "inserted" << 0; + QTest::newRow("Insert beyond count") << initialItems << initialItems.count()+1 << "inserted" << initialItems.count(); + QTest::newRow("Insert at count") << initialItems << initialItems.count() << "inserted" << initialItems.count(); + QTest::newRow("Insert in the middle") << initialItems << 1 << "inserted" << 1; +} + +void tst_QListWidget::insertItem() +{ + QFETCH(QStringList, initialItems); + QFETCH(int, insertIndex); + QFETCH(QString, itemLabel); + QFETCH(int, expectedIndex); + + testWidget->insertItems(0, initialItems); + QCOMPARE(testWidget->count(), initialItems.count()); + + testWidget->insertItem(insertIndex, itemLabel); + + QCOMPARE(rcFirst[RowsAboutToBeInserted], expectedIndex); + QCOMPARE(rcLast[RowsAboutToBeInserted], expectedIndex); + QCOMPARE(rcFirst[RowsInserted], expectedIndex); + QCOMPARE(rcLast[RowsInserted], expectedIndex); + + QCOMPARE(testWidget->count(), initialItems.count() + 1); + QCOMPARE(testWidget->item(expectedIndex)->text(), itemLabel); +} + +void tst_QListWidget::insertItems_data() +{ + QTest::addColumn<int>("rowCount"); + QTest::addColumn<int>("insertType"); + + QTest::newRow("Insert 1 item using constructor") << 1 << 0; + QTest::newRow("Insert 10 items using constructor") << 10 << 0; + QTest::newRow("Insert 100 items using constructor") << 100 << 0; + + QTest::newRow("Insert 1 item with insertItem") << 1 << 1; + QTest::newRow("Insert 10 items with insertItem") << 10 << 1; + QTest::newRow("Insert 100 items with insertItem") << 100 << 1; + + QTest::newRow("Insert/Create 1 item using insertItem") << 1 << 2; + QTest::newRow("Insert/Create 10 items using insertItem") << 10 << 2; + QTest::newRow("Insert/Create 100 items using insertItem") << 100 << 2; + + QTest::newRow("Insert 0 items with insertItems") << 0 << 3; + QTest::newRow("Insert 1 item with insertItems") << 1 << 3; + QTest::newRow("Insert 10 items with insertItems") << 10 << 3; + QTest::newRow("Insert 100 items with insertItems") << 100 << 3; +} + +void tst_QListWidget::insertItems() +{ + QFETCH(int, rowCount); + QFETCH(int, insertType); + + if (insertType == 3) { + QStringList strings; + for (int i=0; i<rowCount; ++i) + strings << QString::number(i); + testWidget->insertItems(0, strings); + } else { + for (int r = 0; r < rowCount; ++r) { + if (insertType == 0) { + // insert with QListWidgetItem constructor + new QListWidgetItem(QString::number(r), testWidget); + } else if (insertType == 1) { + // insert actual item + testWidget->insertItem(r, new QListWidgetItem(QString::number(r))); + } else if (insertType == 2) { + // insert/creating with string + testWidget->insertItem(r, QString::number(r)); + } else if (insertType == 3) { + QStringList strings; + for (int i=0; i<rowCount; ++i) + strings << QString::number(i); + testWidget->insertItems(0, strings); + break; + } else { + QVERIFY(0); + } + } + } + // compare the results + QCOMPARE(testWidget->count(), rowCount); + + // check if the text + for (int r = 0; r < rowCount; ++r) + QCOMPARE(testWidget->item(r)->text(), QString::number(r)); + + // make sure all items have view set correctly + for (int i=0; i<testWidget->count(); ++i) + QCOMPARE(testWidget->item(i)->listWidget(), testWidget); +} + +void tst_QListWidget::itemAssignment() +{ + QListWidgetItem itemInWidget("inWidget", testWidget); + itemInWidget.setFlags(itemInWidget.flags() | Qt::ItemIsTristate); + QListWidgetItem itemOutsideWidget("outsideWidget"); + + QVERIFY(itemInWidget.listWidget()); + QCOMPARE(itemInWidget.text(), QString("inWidget")); + QVERIFY(itemInWidget.flags() & Qt::ItemIsTristate); + + QVERIFY(!itemOutsideWidget.listWidget()); + QCOMPARE(itemOutsideWidget.text(), QString("outsideWidget")); + QVERIFY(!(itemOutsideWidget.flags() & Qt::ItemIsTristate)); + + itemOutsideWidget = itemInWidget; + QVERIFY(!itemOutsideWidget.listWidget()); + QCOMPARE(itemOutsideWidget.text(), QString("inWidget")); + QVERIFY(itemOutsideWidget.flags() & Qt::ItemIsTristate); +} + +void tst_QListWidget::item_data() +{ + QTest::addColumn<int>("row"); + QTest::addColumn<bool>("outOfBounds"); + + QTest::newRow("First item, row: 0") << 0 << false; + QTest::newRow("Middle item, row: 1") << 1 << false; + QTest::newRow("Last item, row: 2") << 2 << false; + QTest::newRow("Out of bounds, row: -1") << -1 << true; + QTest::newRow("Out of bounds, row: 3") << 3 << true; +} + +void tst_QListWidget::item() +{ + QFETCH(int, row); + QFETCH(bool, outOfBounds); + + (new QListWidgetItem(testWidget))->setText("item0"); + (new QListWidgetItem(testWidget))->setText("item1"); + (new QListWidgetItem(testWidget))->setText("item2"); + + QCOMPARE(testWidget->count(), 3); + + QListWidgetItem *item = testWidget->item(row); + if (outOfBounds) { + QCOMPARE(item, static_cast<QListWidgetItem*>(0)); + QCOMPARE(testWidget->count(), 3); + } else { + QCOMPARE(item->text(), QString("item%1").arg(row)); + QCOMPARE(testWidget->count(), 3); + } +} + +void tst_QListWidget::takeItem_data() +{ + QTest::addColumn<int>("row"); + QTest::addColumn<bool>("outOfBounds"); + + QTest::newRow("First item, row: 0") << 0 << false; + QTest::newRow("Middle item, row: 1") << 1 << false; + QTest::newRow("Last item, row: 2") << 2 << false; + QTest::newRow("Out of bounds, row: -1") << -1 << true; + QTest::newRow("Out of bounds, row: 3") << 3 << true; +} + +void tst_QListWidget::takeItem() +{ + QFETCH(int, row); + QFETCH(bool, outOfBounds); + + (new QListWidgetItem(testWidget))->setText("item0"); + (new QListWidgetItem(testWidget))->setText("item1"); + (new QListWidgetItem(testWidget))->setText("item2"); + + QCOMPARE(testWidget->count(), 3); + + QListWidgetItem *item = testWidget->takeItem(row); + if (outOfBounds) { + QCOMPARE(item, static_cast<QListWidgetItem*>(0)); + QCOMPARE(testWidget->count(), 3); + } else { + QCOMPARE(item->text(), QString("item%1").arg(row)); + QCOMPARE(testWidget->count(), 2); + } + + delete item; +} + +void tst_QListWidget::selectedItems_data() +{ + QTest::addColumn<int>("itemCount"); + QTest::addColumn<IntList>("hiddenRows"); + QTest::addColumn<IntList>("selectedRows"); + QTest::addColumn<IntList>("expectedRows"); + + + QTest::newRow("none hidden, none selected") + << 3 + << IntList() + << IntList() + << IntList(); + + QTest::newRow("none hidden, all selected") + << 3 + << IntList() + << (IntList() << 0 << 1 << 2) + << (IntList() << 0 << 1 << 2); + + QTest::newRow("first hidden, all selected") + << 3 + << (IntList() << 0) + << (IntList() << 0 << 1 << 2) + << (IntList() << 0 << 1 << 2); + + QTest::newRow("last hidden, all selected") + << 3 + << (IntList() << 2) + << (IntList() << 0 << 1 << 2) + << (IntList() << 0 << 1 << 2); + + QTest::newRow("middle hidden, all selected") + << 3 + << (IntList() << 1) + << (IntList() << 0 << 1 << 2) + << (IntList() << 0 << 1 << 2); + + QTest::newRow("all hidden, all selected") + << 3 + << (IntList() << 0 << 1 << 2) + << (IntList() << 0 << 1 << 2) + << (IntList() << 0 << 1 << 2); +} + +void tst_QListWidget::selectedItems() +{ + QFETCH(int, itemCount); + QFETCH(IntList, hiddenRows); + QFETCH(IntList, selectedRows); + QFETCH(IntList, expectedRows); + + QVERIFY(testWidget->count() == 0); + + //insert items + for (int i=0; i<itemCount; ++i) + new QListWidgetItem(QString("Item%1").arg(i), testWidget); + + //test the selection + testWidget->setSelectionMode(QListWidget::SingleSelection); + for (int i=0; i<itemCount; ++i) { + QListWidgetItem *item = testWidget->item(i); + testWidget->setItemSelected(item, true); + QVERIFY(item->isSelected()); + QCOMPARE(testWidget->selectedItems().count(), 1); + } + //let's clear the selection + testWidget->clearSelection(); + //... and set the selection mode to allow more than 1 item to be selected + testWidget->setSelectionMode(QAbstractItemView::MultiSelection); + + //verify items are inserted + QCOMPARE(testWidget->count(), itemCount); + // hide items + foreach (int row, hiddenRows) + testWidget->setItemHidden(testWidget->item(row), true); + // select items + foreach (int row, selectedRows) + testWidget->setItemSelected(testWidget->item(row), true); + + // check that the correct number of items and the expected items are there + QList<QListWidgetItem *> selectedItems = testWidget->selectedItems(); + QCOMPARE(selectedItems.count(), expectedRows.count()); + foreach (int row, expectedRows) + QVERIFY(selectedItems.contains(testWidget->item(row))); + + //check that isSelected agrees with selectedItems + for (int i=0; i<itemCount; ++i) { + QListWidgetItem *item = testWidget->item(i); + if (testWidget->isItemSelected(item)) + QVERIFY(selectedItems.contains(item)); + } +} + +void tst_QListWidget::removeItems_data() +{ + QTest::addColumn<int>("rowCount"); + QTest::addColumn<int>("removeRows"); + QTest::addColumn<int>("row"); + QTest::addColumn<int>("expectedRowCount"); + + QTest::newRow("Empty") << 0 << 1 << 0 << 0; + QTest::newRow("1:1") << 1 << 1 << 0 << 0; + QTest::newRow("3:1") << 3 << 1 << 0 << 2; + QTest::newRow("3:2") << 3 << 2 << 0 << 1; + QTest::newRow("100:10") << 100 << 10 << 0 << 90; +} + +void tst_QListWidget::removeItems() +{ + QFETCH(int, rowCount); + QFETCH(int, removeRows); + QFETCH(int, row); + QFETCH(int, expectedRowCount); + + //insert items + for (int r = 0; r < rowCount; ++r) + new QListWidgetItem(QString::number(r), testWidget); + + // remove and compare the results + for (int r = 0; r < removeRows; ++r) + delete testWidget->item(row); + QCOMPARE(testWidget->count(), expectedRowCount); + + // check if the correct items were removed + for (int r = 0; r < expectedRowCount; ++r) + if (r < row) + QCOMPARE(testWidget->item(r)->text(), QString::number(r)); + else + QCOMPARE(testWidget->item(r)->text(), QString::number(r + removeRows)); + + +} + +void tst_QListWidget::moveItemsPriv_data() +{ + QTest::addColumn<int>("rowCount"); + QTest::addColumn<int>("srcRow"); + QTest::addColumn<int>("dstRow"); + QTest::addColumn<bool>("shouldHaveSignaled"); + + QTest::newRow("Empty") << 0 << 0 << 0 << false; + QTest::newRow("Overflow src") << 5 << 5 << 2 << false; + QTest::newRow("Underflow src") << 5 << -1 << 2 << false; + QTest::newRow("Overflow dst") << 5 << 2 << 6 << false; + QTest::newRow("Underflow dst") << 5 << 2 << -1 << false; + QTest::newRow("Same place") << 5 << 2 << 2 << false; + QTest::newRow("Up") << 5 << 4 << 2 << true; + QTest::newRow("Down") << 5 << 2 << 4 << true; + QTest::newRow("QTBUG-6532 assert") << 5 << 0 << 1 << false; + QTest::newRow("QTBUG-6565 to the end") << 5 << 3 << 5 << true; + QTest::newRow("Same place 2") << 2 << 0 << 1 << false; + QTest::newRow("swap") << 2 << 0 << 2 << true; + QTest::newRow("swap2") << 4 << 1 << 3 << true; + QTest::newRow("swap3") << 4 << 3 << 2 << true; + QTest::newRow("swap4") << 2 << 1 << 0 << true; +} + +void tst_QListWidget::moveItemsPriv() +{ + QFETCH(int, rowCount); + QFETCH(int, srcRow); + QFETCH(int, dstRow); + QFETCH(bool, shouldHaveSignaled); + + for (int r = 0; r < rowCount; ++r) + new QListWidgetItem(QString::number(r), testWidget); + + QListModel *model = qobject_cast<QListModel *>(testWidget->model()); + QVERIFY(model); + QSignalSpy beginMoveSpy(model, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int))); + QSignalSpy movedSpy(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int))); + model->move(srcRow, dstRow); + + if (shouldHaveSignaled) { + if (srcRow < dstRow) + QCOMPARE(testWidget->item(dstRow - 1)->text(), QString::number(srcRow)); + else + QCOMPARE(testWidget->item(dstRow)->text(), QString::number(srcRow)); + + QCOMPARE(beginMoveSpy.count(), 1); + const QList<QVariant> &beginMoveArgs = beginMoveSpy.takeFirst(); + QCOMPARE(beginMoveArgs.at(1).toInt(), srcRow); + QCOMPARE(beginMoveArgs.at(2).toInt(), srcRow); + QCOMPARE(beginMoveArgs.at(4).toInt(), dstRow); + + QCOMPARE(movedSpy.count(), 1); + const QList<QVariant> &movedArgs = movedSpy.takeFirst(); + QCOMPARE(movedArgs.at(1).toInt(), srcRow); + QCOMPARE(movedArgs.at(2).toInt(), srcRow); + QCOMPARE(movedArgs.at(4).toInt(), dstRow); + } else { + QCOMPARE(beginMoveSpy.count(), 0); + QCOMPARE(movedSpy.count(), 0); + } +} + +void tst_QListWidget::itemStreaming_data() +{ + QTest::addColumn<QString>("text"); + QTest::addColumn<QString>("toolTip"); + + QTest::newRow("Data") << "item text" << "tool tip text"; +} + +void tst_QListWidget::itemStreaming() +{ + QFETCH(QString, text); + QFETCH(QString, toolTip); + + QListWidgetItem item; + QCOMPARE(item.text(), QString()); + QCOMPARE(item.toolTip(), QString()); + + item.setText(text); + item.setToolTip(toolTip); + QCOMPARE(item.text(), text); + QCOMPARE(item.toolTip(), toolTip); + + QByteArray buffer; + QDataStream out(&buffer, QIODevice::WriteOnly); + out << item; + + QListWidgetItem item2; + QCOMPARE(item2.text(), QString()); + QCOMPARE(item2.toolTip(), QString()); + + QVERIFY(!buffer.isEmpty()); + + QDataStream in(&buffer, QIODevice::ReadOnly); + in >> item2; + QCOMPARE(item2.text(), text); + QCOMPARE(item2.toolTip(), toolTip); +} + +void tst_QListWidget::sortItems_data() +{ + QTest::addColumn<int>("order"); + QTest::addColumn<QVariantList>("initialList"); + QTest::addColumn<QVariantList>("expectedList"); + QTest::addColumn<IntList>("expectedRows"); + + QTest::newRow("ascending strings") + << static_cast<int>(Qt::AscendingOrder) + << (QVariantList() << QString("c") << QString("d") << QString("a") << QString("b")) + << (QVariantList() << QString("a") << QString("b") << QString("c") << QString("d")) + << (IntList() << 2 << 3 << 0 << 1); + + QTest::newRow("descending strings") + << static_cast<int>(Qt::DescendingOrder) + << (QVariantList() << QString("c") << QString("d") << QString("a") << QString("b")) + << (QVariantList() << QString("d") << QString("c") << QString("b") << QString("a")) + << (IntList() << 1 << 0 << 3 << 2); + + QTest::newRow("ascending numbers") + << static_cast<int>(Qt::AscendingOrder) + << (QVariantList() << 1 << 11 << 2 << 22) + << (QVariantList() << 1 << 2 << 11 << 22) + << (IntList() << 0 << 2 << 1 << 3); + + QTest::newRow("descending numbers") + << static_cast<int>(Qt::DescendingOrder) + << (QVariantList() << 1 << 11 << 2 << 22) + << (QVariantList() << 22 << 11 << 2 << 1) + << (IntList() << 3 << 1 << 2 << 0); +} + +void tst_QListWidget::sortItems() +{ + QFETCH(int, order); + QFETCH(QVariantList, initialList); + QFETCH(QVariantList, expectedList); + QFETCH(IntList, expectedRows); + + foreach (const QVariant &data, initialList) { + QListWidgetItem *item = new QListWidgetItem(testWidget); + item->setData(Qt::DisplayRole, data); + } + + QAbstractItemModel *model = testWidget->model(); + QList<QPersistentModelIndex> persistent; + for (int j = 0; j < model->rowCount(QModelIndex()); ++j) + persistent << model->index(j, 0, QModelIndex()); + + testWidget->sortItems(static_cast<Qt::SortOrder>(order)); + + QCOMPARE(testWidget->count(), expectedList.count()); + for (int i = 0; i < testWidget->count(); ++i) + QCOMPARE(testWidget->item(i)->text(), expectedList.at(i).toString()); + + for (int k = 0; k < testWidget->count(); ++k) + QCOMPARE(persistent.at(k).row(), expectedRows.at(k)); +} + +void tst_QListWidget::sortHiddenItems_data() +{ + QTest::addColumn<int>("order"); + QTest::addColumn<QStringList>("initialList"); + QTest::addColumn<QStringList>("expectedList"); + QTest::addColumn<IntList>("expectedRows"); + QTest::addColumn<IntList>("expectedVisibility"); + + QStringList initial, expected; + IntList rowOrder; + IntList visible; + for (int i = 0; i < 20; ++i) { + initial << QString(QChar(0x41 + i)); + expected << QString(QChar(0x54 - i)); + rowOrder << 19 - i; + visible << (i % 2); + + } + QTest::newRow("descending order, 20 items") + << static_cast<int>(Qt::DescendingOrder) + << initial + << expected + << rowOrder + << visible; + + QTest::newRow("ascending order") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "c" << "d" << "a" << "b") + << (QStringList() << "a" << "b" << "c" << "d") + << (IntList() << 2 << 3 << 0 << 1) + << (IntList() << 1 << 0 << 1 << 0); + + QTest::newRow("descending order") + << static_cast<int>(Qt::DescendingOrder) + << (QStringList() << "c" << "d" << "a" << "b") + << (QStringList() << "d" << "c" << "b" << "a") + << (IntList() << 1 << 0 << 3 << 2) + << (IntList() << 0 << 1 << 0 << 1); +} + +void tst_QListWidget::sortHiddenItems() +{ + QFETCH(int, order); + QFETCH(QStringList, initialList); + QFETCH(QStringList, expectedList); + QFETCH(IntList, expectedRows); + QFETCH(IntList, expectedVisibility); + + // init() won't clear hidden items... + QListWidget *tw = new QListWidget(); + tw->addItems(initialList); + + QAbstractItemModel *model = tw->model(); + QList<QPersistentModelIndex> persistent; + for (int j = 0; j < model->rowCount(QModelIndex()); ++j) { + persistent << model->index(j, 0, QModelIndex()); + tw->setRowHidden(j, j & 1); // every odd is hidden + } + + tw->setSortingEnabled(true); + tw->sortItems(static_cast<Qt::SortOrder>(order)); + + QCOMPARE(tw->count(), expectedList.count()); + for (int i = 0; i < tw->count(); ++i) { + QCOMPARE(tw->item(i)->text(), expectedList.at(i)); + QCOMPARE(tw->item(i)->isHidden(), !expectedVisibility.at(i)); + } + + for (int k = 0; k < tw->count(); ++k) + QCOMPARE(persistent.at(k).row(), expectedRows.at(k)); + + delete tw; +} + +void tst_QListWidget::modelChanged(ModelChanged change, const QModelIndex &parent, + int first, int last) +{ + rcParent[change] = parent; + rcFirst[change] = first; + rcLast[change] = last; +} + +class TestListWidget : public QListWidget { +public: + TestListWidget() : QListWidget() + { + + } + State getState() {return QListWidget::state();} + + void closeEditor(QWidget *w, QAbstractItemDelegate::EndEditHint hint) { + QListWidget::closeEditor(w, hint); + } + + bool isEditingState(QListWidgetItem *item) { + Q_UNUSED(item); + return (QListWidget::state() == QListWidget::EditingState ? true : false); + } +}; + +void tst_QListWidget::closeEditor() +{ + TestListWidget w; + QStringList labels = (QStringList() << "a" << "b" << "c" << "d"); + w.addItems(labels); + QListWidgetItem *item = w.item(0); + item->setFlags(item->flags() | Qt::ItemIsEditable); + QVERIFY(item); + w.editItem(item); + + QVERIFY(w.isEditingState(item)); + + w.reset(); + + QVERIFY(!w.isEditingState(item)); +} + +void tst_QListWidget::setData_data() +{ + QTest::addColumn<QStringList>("initialItems"); + QTest::addColumn<int>("itemIndex"); + QTest::addColumn<IntList>("roles"); + QTest::addColumn<QVariantList>("values"); + QTest::addColumn<int>("expectedSignalCount"); + + QStringList initialItems; + IntList roles; + QVariantList values; + + { + initialItems.clear(); roles.clear(); values.clear(); + initialItems << "foo"; + roles << Qt::DisplayRole; + values << "xxx"; + QTest::newRow("changing a role should emit") + << initialItems << 0 << roles << values << 1; + } + { + initialItems.clear(); roles.clear(); values.clear(); + initialItems << "foo"; + roles << Qt::DisplayRole; + values << "foo"; + QTest::newRow("setting the same value should not emit") + << initialItems << 0 << roles << values << 0; + } + { + initialItems.clear(); roles.clear(); values.clear(); + initialItems << "foo"; + roles << Qt::DisplayRole << Qt::DisplayRole; + values << "bar" << "bar"; + QTest::newRow("setting the same value twice should only emit once") + << initialItems << 0 << roles << values << 1; + } + { + initialItems.clear(); roles.clear(); values.clear(); + initialItems << "foo"; + roles << Qt::DisplayRole << Qt::ToolTipRole << Qt::WhatsThisRole; + values << "bar" << "bartooltip" << "barwhatsthis"; + QTest::newRow("changing three roles should emit three times") + << initialItems << 0 << roles << values << 3; + } +} + +void tst_QListWidget::setData() +{ + QFETCH(QStringList, initialItems); + QFETCH(int, itemIndex); + QFETCH(IntList, roles); + QFETCH(QVariantList, values); + QFETCH(int, expectedSignalCount); + qRegisterMetaType<QListWidgetItem *>("QListWidgetItem*"); + qRegisterMetaType<QModelIndex>("QModelIndex"); + + QVERIFY(roles.count() == values.count()); + + for (int manipulateModel=0; manipulateModel<2; ++manipulateModel) { + testWidget->clear(); + testWidget->insertItems(0, initialItems); + QCOMPARE(testWidget->count(), initialItems.count()); + + QSignalSpy itemChanged(testWidget, SIGNAL(itemChanged(QListWidgetItem *))); + QSignalSpy dataChanged(testWidget->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &))); + + for (int i=0; i < roles.count(); ++i) { + if (manipulateModel) + testWidget->model()->setData( + testWidget->model()->index(itemIndex, 0, testWidget->rootIndex()), + values.at(i), + roles.at(i)); + else + testWidget->item(itemIndex)->setData(roles.at(i), values.at(i)); + } + + // make sure the data is actually set + for (int i=0; i < roles.count(); ++i) + QCOMPARE(testWidget->item(itemIndex)->data(roles.at(i)), values.at(i)); + + // make sure we get the right number of emits + QCOMPARE(itemChanged.count(), expectedSignalCount); + QCOMPARE(dataChanged.count(), expectedSignalCount); + } +} + +void tst_QListWidget::insertItemsWithSorting_data() +{ + QTest::addColumn<int>("sortOrder"); + QTest::addColumn<QStringList>("initialItems"); + QTest::addColumn<QStringList>("insertItems"); + QTest::addColumn<QStringList>("expectedItems"); + QTest::addColumn<IntList>("expectedRows"); + + QTest::newRow("() + (a) = (a)") + << static_cast<int>(Qt::AscendingOrder) + << QStringList() + << (QStringList() << "a") + << (QStringList() << "a") + << IntList(); + QTest::newRow("() + (c, b, a) = (a, b, c)") + << static_cast<int>(Qt::AscendingOrder) + << QStringList() + << (QStringList() << "c" << "b" << "a") + << (QStringList() << "a" << "b" << "c") + << IntList(); + QTest::newRow("() + (a, b, c) = (c, b, a)") + << static_cast<int>(Qt::DescendingOrder) + << QStringList() + << (QStringList() << "a" << "b" << "c") + << (QStringList() << "c" << "b" << "a") + << IntList(); + QTest::newRow("(a) + (b) = (a, b)") + << static_cast<int>(Qt::AscendingOrder) + << QStringList("a") + << (QStringList() << "b") + << (QStringList() << "a" << "b") + << (IntList() << 0); + QTest::newRow("(a) + (b) = (b, a)") + << static_cast<int>(Qt::DescendingOrder) + << QStringList("a") + << (QStringList() << "b") + << (QStringList() << "b" << "a") + << (IntList() << 1); + QTest::newRow("(a, c, b) + (d) = (a, b, c, d)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "a" << "c" << "b") + << (QStringList() << "d") + << (QStringList() << "a" << "b" << "c" << "d") + << (IntList() << 0 << 1 << 2); + QTest::newRow("(b, c, a) + (d) = (d, c, b, a)") + << static_cast<int>(Qt::DescendingOrder) + << (QStringList() << "b" << "c" << "a") + << (QStringList() << "d") + << (QStringList() << "d" << "c" << "b" << "a") + << (IntList() << 1 << 2 << 3); + { + IntList ascendingRows; + IntList reverseRows; + QStringList ascendingItems; + QStringList reverseItems; + for (int i = 'a'; i <= 'z'; ++i) { + ascendingItems << QString("%0").arg(QLatin1Char(i)); + reverseItems << QString("%0").arg(QLatin1Char('z' - i + 'a')); + ascendingRows << i - 'a'; + reverseRows << 'z' - i + 'a'; + } + QTest::newRow("() + (sorted items) = (sorted items)") + << static_cast<int>(Qt::AscendingOrder) + << QStringList() + << ascendingItems + << ascendingItems + << IntList(); + QTest::newRow("(sorted items) + () = (sorted items)") + << static_cast<int>(Qt::AscendingOrder) + << ascendingItems + << QStringList() + << ascendingItems + << ascendingRows; + QTest::newRow("() + (ascending items) = (reverse items)") + << static_cast<int>(Qt::DescendingOrder) + << QStringList() + << ascendingItems + << reverseItems + << IntList(); + QTest::newRow("(reverse items) + () = (ascending items)") + << static_cast<int>(Qt::AscendingOrder) + << reverseItems + << QStringList() + << ascendingItems + << ascendingRows; + QTest::newRow("(reverse items) + () = (reverse items)") + << static_cast<int>(Qt::DescendingOrder) + << reverseItems + << QStringList() + << reverseItems + << ascendingRows; + } +} + +void tst_QListWidget::insertItemsWithSorting() +{ + QFETCH(int, sortOrder); + QFETCH(QStringList, initialItems); + QFETCH(QStringList, insertItems); + QFETCH(QStringList, expectedItems); + QFETCH(IntList, expectedRows); + + for (int method = 0; method < 5; ++method) { + QListWidget w; + w.setSortingEnabled(true); + w.sortItems(static_cast<Qt::SortOrder>(sortOrder)); + w.addItems(initialItems); + + QAbstractItemModel *model = w.model(); + QList<QPersistentModelIndex> persistent; + for (int j = 0; j < model->rowCount(QModelIndex()); ++j) + persistent << model->index(j, 0, QModelIndex()); + + switch (method) { + case 0: + // insert using item constructor + for (int i = 0; i < insertItems.size(); ++i) + new QListWidgetItem(insertItems.at(i), &w); + break; + case 1: + // insert using insertItems() + w.insertItems(0, insertItems); + break; + case 2: + // insert using insertItem() + for (int i = 0; i < insertItems.size(); ++i) + w.insertItem(0, insertItems.at(i)); + break; + case 3: + // insert using addItems() + w.addItems(insertItems); + break; + case 4: + // insert using addItem() + for (int i = 0; i < insertItems.size(); ++i) + w.addItem(insertItems.at(i)); + break; + } + QCOMPARE(w.count(), expectedItems.count()); + for (int i = 0; i < w.count(); ++i) + QCOMPARE(w.item(i)->text(), expectedItems.at(i)); + + for (int k = 0; k < persistent.count(); ++k) + QCOMPARE(persistent.at(k).row(), expectedRows.at(k)); + } +} + +void tst_QListWidget::changeDataWithSorting_data() +{ + QTest::addColumn<int>("sortOrder"); + QTest::addColumn<QStringList>("initialItems"); + QTest::addColumn<int>("itemIndex"); + QTest::addColumn<QString>("newValue"); + QTest::addColumn<QStringList>("expectedItems"); + QTest::addColumn<IntList>("expectedRows"); + QTest::addColumn<bool>("reorderingExpected"); + + QTest::newRow("change a to b in (a)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "a") + << 0 << "b" + << (QStringList() << "b") + << (IntList() << 0) + << false; + QTest::newRow("change a to b in (a, c)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "a" << "c") + << 0 << "b" + << (QStringList() << "b" << "c") + << (IntList() << 0 << 1) + << false; + QTest::newRow("change a to c in (a, b)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "a" << "b") + << 0 << "c" + << (QStringList() << "b" << "c") + << (IntList() << 1 << 0) + << true; + QTest::newRow("change c to a in (c, b)") + << static_cast<int>(Qt::DescendingOrder) + << (QStringList() << "c" << "b") + << 0 << "a" + << (QStringList() << "b" << "a") + << (IntList() << 1 << 0) + << true; + QTest::newRow("change e to i in (a, c, e, g)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "a" << "c" << "e" << "g") + << 2 << "i" + << (QStringList() << "a" << "c" << "g" << "i") + << (IntList() << 0 << 1 << 3 << 2) + << true; + QTest::newRow("change e to a in (c, e, g, i)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "c" << "e" << "g" << "i") + << 1 << "a" + << (QStringList() << "a" << "c" << "g" << "i") + << (IntList() << 1 << 0 << 2 << 3) + << true; + QTest::newRow("change e to f in (c, e, g, i)") + << static_cast<int>(Qt::AscendingOrder) + << (QStringList() << "c" << "e" << "g" << "i") + << 1 << "f" + << (QStringList() << "c" << "f" << "g" << "i") + << (IntList() << 0 << 1 << 2 << 3) + << false; +} + +void tst_QListWidget::itemData() +{ + QListWidget widget; + QListWidgetItem item(&widget); + item.setFlags(item.flags() | Qt::ItemIsEditable); + item.setData(Qt::DisplayRole, QString("0")); + item.setData(Qt::CheckStateRole, Qt::PartiallyChecked); + item.setData(Qt::UserRole + 0, QString("1")); + item.setData(Qt::UserRole + 1, QString("2")); + item.setData(Qt::UserRole + 2, QString("3")); + item.setData(Qt::UserRole + 3, QString("4")); + QMap<int, QVariant> flags = widget.model()->itemData(widget.model()->index(0, 0)); + QCOMPARE(flags.count(), 6); + QCOMPARE(flags[Qt::UserRole + 0].toString(), QString("1")); +} + +void tst_QListWidget::changeDataWithSorting() +{ + QFETCH(int, sortOrder); + QFETCH(QStringList, initialItems); + QFETCH(int, itemIndex); + QFETCH(QString, newValue); + QFETCH(QStringList, expectedItems); + QFETCH(IntList, expectedRows); + QFETCH(bool, reorderingExpected); + + QListWidget w; + w.setSortingEnabled(true); + w.sortItems(static_cast<Qt::SortOrder>(sortOrder)); + w.addItems(initialItems); + + QAbstractItemModel *model = w.model(); + QList<QPersistentModelIndex> persistent; + for (int j = 0; j < model->rowCount(QModelIndex()); ++j) + persistent << model->index(j, 0, QModelIndex()); + + QSignalSpy dataChangedSpy(model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &))); + QSignalSpy layoutChangedSpy(model, SIGNAL(layoutChanged())); + + QListWidgetItem *item = w.item(itemIndex); + item->setText(newValue); + for (int i = 0; i < expectedItems.count(); ++i) { + QCOMPARE(w.item(i)->text(), expectedItems.at(i)); + for (int j = 0; j < persistent.count(); ++j) { + if (persistent.at(j).row() == i) // the same toplevel row + QCOMPARE(persistent.at(j).internalPointer(), (void *)w.item(i)); + } + } + + for (int k = 0; k < persistent.count(); ++k) + QCOMPARE(persistent.at(k).row(), expectedRows.at(k)); + + QCOMPARE(dataChangedSpy.count(), 1); + QCOMPARE(layoutChangedSpy.count(), reorderingExpected ? 1 : 0); +} + +void tst_QListWidget::itemWidget() +{ + QListWidget list; + QWidget widget; + + QListWidgetItem *item = new QListWidgetItem(&list); + + + QCOMPARE(list.itemWidget(item), static_cast<QWidget*>(0)); + list.setItemWidget(item, &widget); + QCOMPARE(list.itemWidget(item), &widget); + list.removeItemWidget(item); + QCOMPARE(list.itemWidget(item), static_cast<QWidget*>(0)); +} + +#ifndef Q_WS_MAC +class MyListWidget : public QListWidget +{ +public: + MyListWidget(QWidget *parent=0) + : QListWidget(parent) + { + } + + void paintEvent(QPaintEvent *e) { + painted += e->region(); + QListWidget::paintEvent(e); + } + + QRegion painted; +}; + +void tst_QListWidget::fastScroll() +{ + QWidget topLevel; + MyListWidget widget(&topLevel); + for (int i = 0; i < 50; ++i) + widget.addItem(QString("Item %1").arg(i)); + + topLevel.resize(300, 300); // toplevel needs to be wide enough for the item + topLevel.show(); + // Make sure the widget gets the first full repaint. On + // some WMs, we'll get two (first inactive exposure, then + // active exposure. + QTest::qWaitForWindowShown(&widget); +#ifdef Q_WS_X11 + qt_x11_wait_for_window_manager(&widget); +#endif + QApplication::processEvents(); + QTest::qWait(500); + + QSize itemSize = widget.visualItemRect(widget.item(0)).size(); + QVERIFY(!itemSize.isEmpty()); + + QScrollBar *sbar = widget.verticalScrollBar(); + widget.setVerticalScrollMode(QAbstractItemView::ScrollPerItem); + widget.painted = QRegion(); + sbar->setValue(sbar->value() + sbar->singleStep()); + QApplication::processEvents(); + + // only one item should be repainted, the rest should be scrolled in memory + QCOMPARE(widget.painted.boundingRect().size(), itemSize); +} +#endif // Q_WS_MAC + +void tst_QListWidget::insertUnchanged() +{ + QListWidget w; + QSignalSpy itemChangedSpy(&w, SIGNAL(itemChanged(QListWidgetItem*))); + QListWidgetItem item("foo", &w); + QCOMPARE(itemChangedSpy.count(), 0); +} + +void tst_QListWidget::setSortingEnabled() +{ + QListWidget w; + QListWidgetItem *item1 = new QListWidgetItem(&w); + QListWidgetItem *item2 = new QListWidgetItem(&w); + + w.setSortingEnabled(true); + QCOMPARE(w.isSortingEnabled(), true); + QCOMPARE(w.item(0), item1); + QCOMPARE(w.item(1), item2); +} + +void tst_QListWidget::task199503_crashWhenCleared() +{ + //we test here for a crash that would occur if you clear the items in the currentItemChanged signal + QListWidget w; + w.addItems( QStringList() << "item1" << "item2" << "item3"); + w.setCurrentRow(0); + w.connect(&w, SIGNAL(currentItemChanged(QListWidgetItem *,QListWidgetItem*)), SLOT(clear())); + w.setCurrentRow(1); +} + +void tst_QListWidget::task217070_scrollbarsAdjusted() +{ + //This task was mailing for style using SH_ScrollView_FrameOnlyAroundContents such as QMotifStyle + QListWidget v; + for (int i = 0; i<200;i++) + v.addItem(QString::number(i)); + v.show(); + v.setViewMode(QListView::IconMode); + v.setResizeMode(QListView::Adjust); + v.setUniformItemSizes(true); + v.resize(160,100); + QTest::qWait(50); + for(int f=150; f>90 ; f--) { + v.resize(f,100); + QTest::qWait(30); + QVERIFY(v.verticalScrollBar()->isVisible()); + //the vertical scrollbar must not be visible. + QVERIFY(!v.horizontalScrollBar()->isVisible()); + } +} + +void tst_QListWidget::task258949_keypressHangup() +{ + QListWidget lw; + for (int y = 0; y < 5; y++) { + QListWidgetItem *lwi = new QListWidgetItem(&lw); + lwi->setText(y ? "1" : "0"); + if (y) + lwi->setFlags(Qt::ItemIsSelectable); + } + + lw.show(); + lw.setCurrentIndex(lw.model()->index(0,0)); + QCOMPARE(lw.currentIndex(), lw.model()->index(0,0)); + QTest::qWait(30); + QTest::keyPress(&lw, '1'); //this used to freeze + QTest::qWait(30); + QCOMPARE(lw.currentIndex(), lw.model()->index(0,0)); +} + +void tst_QListWidget::QTBUG8086_currentItemChangedOnClick() +{ + qRegisterMetaType<QListWidgetItem*>("QListWidgetItem*"); + QWidget win; + QHBoxLayout layout(&win); + QListWidget list; + for (int i = 0 ; i < 4; ++i) + new QListWidgetItem(QString::number(i), &list); + + layout.addWidget(&list); + + QLineEdit edit; + layout.addWidget(&edit); + + edit.setFocus(); + win.show(); + + QSignalSpy spy(&list, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*))); + + QTest::qWaitForWindowShown(&win); + + QCOMPARE(spy.count(), 0); + + QTest::mouseClick(list.viewport(), Qt::LeftButton, 0, list.visualItemRect(list.item(2)).center()); + + QCOMPARE(spy.count(), 1); + +} + + +class ItemDelegate : public QItemDelegate +{ +public: + ItemDelegate(QObject *parent = 0) : QItemDelegate(parent) + {} + virtual QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &, const QModelIndex &) const + { + QLineEdit *lineEdit = new QLineEdit(parent); + lineEdit->setFrame(false); + QCompleter *completer = new QCompleter(QStringList() << "completer", lineEdit); + completer->setCompletionMode(QCompleter::InlineCompletion); + lineEdit->setCompleter(completer); + return lineEdit; + } +}; + +void tst_QListWidget::QTBUG14363_completerWithAnyKeyPressedEditTriggers() +{ + QListWidget listWidget; + listWidget.setEditTriggers(QAbstractItemView::AnyKeyPressed); + listWidget.setItemDelegate(new ItemDelegate); + QListWidgetItem *item = new QListWidgetItem(QLatin1String("select an item (don't start editing)"), &listWidget); + item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable|Qt::ItemIsEditable); + new QListWidgetItem(QLatin1String("try to type the letter 'c'"), &listWidget); + new QListWidgetItem(QLatin1String("completer"), &listWidget); + listWidget.show(); + listWidget.setCurrentItem(item); + QTest::qWaitForWindowShown(&listWidget); + + QTest::keyClick(listWidget.viewport(), Qt::Key_C); + + QLineEdit *le = qobject_cast<QLineEdit*>(listWidget.itemWidget(item)); + QVERIFY(le); + QCOMPARE(le->text(), QString("completer")); + QCOMPARE(le->completer()->currentCompletion(), QString("completer")); +} + + + +QTEST_MAIN(tst_QListWidget) +#include "tst_qlistwidget.moc" |