1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <qtreewidget.h>

    45 #include <qtreewidgetitemiterator.h>

    46 #include <qapplication.h>

    47 #include <qeventloop.h>

    48 #include <qdebug.h>

    49 #include <qheaderview.h>

    50 #include <qlineedit.h>

    51 #include <QScrollBar>

    52 #include <QStyledItemDelegate>

    53 

    54 #include "../../shared/util.h"

    55 

    56 

    57 //TESTED_CLASS=

    58 //TESTED_FILES=

    59 

    60 class CustomTreeWidget : public QTreeWidget

    61 {

    62     Q_OBJECT

    63 public:

    64     QModelIndex indexFromItem(QTreeWidgetItem *item, int column = 0) const

    65     { return QTreeWidget::indexFromItem(item, column); }

    66 };

    67 

    68 class tst_QTreeWidget : public QObject

    69 {

    70     Q_OBJECT

    71 

    72 public:

    73     tst_QTreeWidget();

    74     ~tst_QTreeWidget();

    75 

    76 

    77 public slots:

    78     void initTestCase();

    79     void cleanupTestCase();

    80     void init();

    81     void cleanup();

    82 

    83 private slots:

    84     void getSetCheck();

    85     void addTopLevelItem();

    86     void currentItem_data();

    87     void currentItem();

    88     void editItem_data();

    89     void editItem();

    90     void takeItem_data();

    91     void takeItem();

    92     void removeChild_data();

    93     void removeChild();

    94     void setItemHidden();

    95     void setItemHidden2();

    96     void selectedItems_data();

    97     void selectedItems();

    98     void itemAssignment();

    99     void clone_data();

   100     void clone();

   101     void expand_data();

   102     void expand();

   103     void checkState_data();

   104     void checkState();

   105     void findItems_data();

   106     void findItems();

   107     void findItemsInColumn();

   108     void sortItems_data();

   109     void sortItems();

   110     void deleteItems_data();

   111     void deleteItems();

   112     void itemAboveOrBelow();

   113     void itemStreaming_data();

   114     void itemStreaming();

   115     void insertTopLevelItems_data();

   116     void insertTopLevelItems();

   117     void keyboardNavigation();

   118     void scrollToItem();

   119     void setSortingEnabled();

   120     void match();

   121     void columnCount();

   122     void setHeaderLabels();

   123     void setHeaderItem();

   124     void itemWidget_data();

   125     void itemWidget();

   126     void insertItemsWithSorting_data();

   127     void insertItemsWithSorting();

   128     void insertExpandedItemsWithSorting_data();

   129     void insertExpandedItemsWithSorting();

   130     void changeDataWithSorting_data();

   131     void changeDataWithSorting();

   132     void changeDataWithStableSorting_data();

   133     void changeDataWithStableSorting();

   134 

   135     void sortedIndexOfChild_data();

   136     void sortedIndexOfChild();

   137     void defaultRowSizes();

   138 

   139     void task191552_rtl();

   140     void task203673_selection();

   141     void rootItemFlags();

   142     void task218661_setHeaderData();

   143     void task245280_sortChildren();

   144     void task253109_itemHeight();

   145 

   146     // QTreeWidgetItem

   147     void itemOperatorLessThan();

   148     void addChild();

   149     void setData();

   150     void enableDisable();

   151 

   152     void expandAndCallapse();

   153     void itemData();

   154     void setDisabled();

   155     void removeSelectedItem();

   156     void removeCurrentItem();

   157     void removeCurrentItem_task186451();

   158     void randomExpand();

   159     void crashTest();

   160     void sortAndSelect();

   161 

   162     void task206367_duplication();

   163     void selectionOrder();

   164 

   165     void setSelectionModel();

   166     void task217309();

   167     void setCurrentItemExpandsParent();

   168     void task239150_editorWidth();

   169     void setTextUpdate();

   170 

   171 public slots:

   172     void itemSelectionChanged();

   173     void emitDataChanged();

   174 

   175 private:

   176     CustomTreeWidget *testWidget;

   177 };

   178 

   179 // Testing get/set functions

   180 void tst_QTreeWidget::getSetCheck()

   181 {

   182     QTreeWidget obj1;

   183     // int QTreeWidget::columnCount()

   184     // void QTreeWidget::setColumnCount(int)

   185     obj1.setColumnCount(0);

   186     QCOMPARE(obj1.columnCount(), 0);

   187 

   188     obj1.setColumnCount(INT_MIN);

   189     QCOMPARE(obj1.columnCount(), 0);

   190 

   191     //obj1.setColumnCount(INT_MAX);

   192     //QCOMPARE(obj1.columnCount(), INT_MAX);

   193     // Since setColumnCount allocates memory, there is no way this will succeed

   194 

   195     obj1.setColumnCount(100);

   196     QCOMPARE(obj1.columnCount(), 100);

   197 

   198     // QTreeWidgetItem * QTreeWidget::headerItem()

   199     // void QTreeWidget::setHeaderItem(QTreeWidgetItem *)

   200     QTreeWidgetItem *var2 = new QTreeWidgetItem();

   201     obj1.setHeaderItem(var2);

   202     QCOMPARE(obj1.headerItem(), var2);

   203 

   204     obj1.setHeaderItem((QTreeWidgetItem *)0);

   205 //    QCOMPARE(obj1.headerItem(), (QTreeWidgetItem *)0);

   206 

   207     // QTreeWidgetItem * QTreeWidget::currentItem()

   208     // void QTreeWidget::setCurrentItem(QTreeWidgetItem *)

   209     QTreeWidgetItem *var3 = new QTreeWidgetItem(&obj1);

   210     obj1.setCurrentItem(var3);

   211     QCOMPARE(obj1.currentItem(), var3);

   212 

   213     obj1.setCurrentItem((QTreeWidgetItem *)0);

   214     QCOMPARE(obj1.currentItem(), (QTreeWidgetItem *)0);

   215 }

   216 

   217 typedef QList<int> IntList;

   218 typedef QList<IntList> ListIntList;

   219 

   220 Q_DECLARE_METATYPE(IntList)

   221 Q_DECLARE_METATYPE(ListIntList)

   222 Q_DECLARE_METATYPE(QModelIndex)

   223 Q_DECLARE_METATYPE(Qt::Orientation)

   224 

   225 typedef QTreeWidgetItem TreeItem;

   226 typedef QList<TreeItem*> TreeItemList;

   227 

   228 Q_DECLARE_METATYPE(QTreeWidgetItem*)

   229 Q_DECLARE_METATYPE(TreeItemList)

   230 

   231 tst_QTreeWidget::tst_QTreeWidget(): testWidget(0)

   232 {

   233 }

   234 

   235 tst_QTreeWidget::~tst_QTreeWidget()

   236 {

   237 }

   238 

   239 void tst_QTreeWidget::initTestCase()

   240 {

   241     qMetaTypeId<QModelIndex>();

   242     qMetaTypeId<Qt::Orientation>();

   243     qRegisterMetaType<QTreeWidgetItem*>("QTreeWidgetItem*");

   244 

   245     testWidget = new CustomTreeWidget();

   246     testWidget->show();

   247 #ifdef Q_WS_X11

   248     qt_x11_wait_for_window_manager(testWidget);

   249 #endif

   250 }

   251 

   252 void tst_QTreeWidget::cleanupTestCase()

   253 {

   254     testWidget->hide();

   255     delete testWidget;

   256 }

   257 

   258 void tst_QTreeWidget::init()

   259 {

   260     testWidget->clear();

   261     testWidget->setColumnCount(2);

   262 }

   263 

   264 void tst_QTreeWidget::cleanup()

   265 {

   266 }

   267 

   268 TreeItem *operator<<(TreeItem *parent, const TreeItemList &children) {

   269     for (int i = 0; i < children.count(); ++i)

   270         parent->addChild(children.at(i));

   271     return parent;

   272 }

   273 

   274 static void populate(QTreeWidget *widget, const TreeItemList &topLevelItems,

   275                      TreeItem *headerItem = 0)

   276 {

   277     widget->clear();

   278     widget->setHeaderItem(headerItem);

   279     foreach (TreeItem *item, topLevelItems)

   280         widget->addTopLevelItem(item);

   281 }

   282 

   283 void tst_QTreeWidget::addTopLevelItem()

   284 {

   285     QTreeWidget tree;

   286     QCOMPARE(tree.topLevelItemCount(), 0);

   287 

   288     // try to add 0

   289     tree.addTopLevelItem(0);

   290     QCOMPARE(tree.topLevelItemCount(), 0);

   291     QCOMPARE(tree.indexOfTopLevelItem(0), -1);

   292 

   293     // add one at a time

   294     QList<TreeItem*> tops;

   295     for (int i = 0; i < 10; ++i) {

   296         TreeItem *ti = new TreeItem();

   297         QCOMPARE(tree.indexOfTopLevelItem(ti), -1);

   298         tree.addTopLevelItem(ti);

   299         QCOMPARE(tree.topLevelItemCount(), i+1);

   300         QCOMPARE(tree.topLevelItem(i), ti);

   301         QCOMPARE(tree.topLevelItem(-1), static_cast<TreeItem*>(0));

   302         QCOMPARE(tree.indexOfTopLevelItem(ti), i);

   303         QCOMPARE(ti->parent(), static_cast<TreeItem*>(0));

   304         tree.addTopLevelItem(ti);

   305         QCOMPARE(tree.topLevelItemCount(), i+1);

   306         tops.append(ti);

   307     }

   308 

   309     // delete one at a time

   310     while (!tops.isEmpty()) {

   311         TreeItem *ti = tops.takeFirst();

   312         delete ti;

   313         QCOMPARE(tree.topLevelItemCount(), tops.count());

   314         for (int i = 0; i < tops.count(); ++i)

   315             QCOMPARE(tree.topLevelItem(i), tops.at(i));

   316     }

   317 

   318     // add none

   319     {

   320         int count = tree.topLevelItemCount();

   321         tree.addTopLevelItems(tops);

   322         QCOMPARE(tree.topLevelItemCount(), count);

   323     }

   324 

   325     // add many at a time

   326     {

   327         const int count = 10;

   328         for (int i = 0; i < 100; i += count) {

   329             tops.clear();

   330             for (int j = 0; j < count; ++j)

   331                 tops << new TreeItem(QStringList() << QString("%0").arg(j));

   332             tree.addTopLevelItems(tops);

   333             QCOMPARE(tree.topLevelItemCount(), count + i);

   334             for (int j = 0; j < count; ++j)

   335                 QCOMPARE(tree.topLevelItem(i+j), tops.at(j));

   336 

   337             tree.addTopLevelItems(tops);

   338             QCOMPARE(tree.topLevelItemCount(), count + i);

   339         }

   340     }

   341 

   342     // insert

   343     {

   344         tops.clear();

   345         for (int i = 0; i < 10; ++i)

   346             tops << new TreeItem();

   347         int count = tree.topLevelItemCount();

   348         tree.insertTopLevelItems(100000, tops);

   349         // ### fixme

   350         QCOMPARE(tree.topLevelItemCount(), count + 10);

   351     }

   352 }

   353 

   354 void tst_QTreeWidget::currentItem_data()

   355 {

   356     QTest::addColumn<TreeItemList>("topLevelItems");

   357 

   358     QTest::newRow("only top-level items, 2 columns")

   359         << (TreeItemList()

   360             << new TreeItem(QStringList() << "a" << "b")

   361             << new TreeItem(QStringList() << "c" << "d"));

   362     TreeItemList lst;

   363     lst << (new TreeItem(QStringList() << "a" << "b")

   364         << (TreeItemList()

   365             << new TreeItem(QStringList() << "c" << "d")

   366             << new TreeItem(QStringList() << "c" << "d")

   367             )

   368             )

   369         << (new TreeItem(QStringList() << "e" << "f")

   370             << (TreeItemList()

   371                 << new TreeItem(QStringList() << "g" << "h")

   372                 << new TreeItem(QStringList() << "g" << "h")

   373                 )

   374             );

   375     QTest::newRow("hierarchy, 2 columns") << lst;

   376 }

   377 

   378 void tst_QTreeWidget::currentItem()

   379 {

   380     QFETCH(TreeItemList, topLevelItems);

   381 

   382     QTreeWidget tree;

   383     tree.show();

   384     populate(&tree, topLevelItems, new TreeItem(QStringList() << "1" << "2"));

   385     QTreeWidgetItem *previous = 0;

   386     for (int x = 0; x < 2; ++x) {

   387         tree.setSelectionBehavior(x ? QAbstractItemView::SelectItems

   388                                   : QAbstractItemView::SelectRows);

   389         QSignalSpy currentItemChangedSpy(

   390             &tree, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));

   391         QSignalSpy itemSelectionChangedSpy(

   392             &tree, SIGNAL(itemSelectionChanged()));

   393 

   394         QTreeWidgetItemIterator it(&tree);

   395         // do all items

   396         while (QTreeWidgetItem *item = (*it++)) {

   397             tree.setCurrentItem(item);

   398             QCOMPARE(tree.currentItem(), item);

   399 

   400             QCOMPARE(currentItemChangedSpy.count(), 1);

   401             QVariantList args = currentItemChangedSpy.takeFirst();

   402             QCOMPARE(qvariant_cast<QTreeWidgetItem*>(args.at(0)), item);

   403             QCOMPARE(qvariant_cast<QTreeWidgetItem*>(args.at(1)), previous);

   404 

   405             QCOMPARE(itemSelectionChangedSpy.count(), 1);

   406             itemSelectionChangedSpy.clear();

   407 

   408             previous = item;

   409             // do all columns

   410             for (int col = 0; col < item->columnCount(); ++col) {

   411                 tree.setCurrentItem(item, col);

   412                 QCOMPARE(tree.currentItem(), item);

   413                 QCOMPARE(tree.currentColumn(), col);

   414 

   415                 if (!currentItemChangedSpy.isEmpty()) {

   416                     // ### we get a currentItemChanged() when what really

   417                     // changed was just currentColumn(). Should it be like this?

   418                     QCOMPARE(currentItemChangedSpy.count(), 1);

   419                     QVariantList args = currentItemChangedSpy.takeFirst();

   420                     QCOMPARE(qvariant_cast<QTreeWidgetItem*>(args.at(0)), item);

   421                     QCOMPARE(qvariant_cast<QTreeWidgetItem*>(args.at(1)), item);

   422                     if (tree.selectionBehavior() == QAbstractItemView::SelectItems) {

   423                         QCOMPARE(itemSelectionChangedSpy.count(), 1);

   424                         itemSelectionChangedSpy.clear();

   425                     } else {

   426                         QCOMPARE(itemSelectionChangedSpy.count(), 0);

   427                     }

   428                 }

   429             }

   430         }

   431     }

   432 

   433     // can't set the headerItem to be the current item

   434     tree.setCurrentItem(tree.headerItem());

   435     QCOMPARE(tree.currentItem(), static_cast<TreeItem*>(0));

   436 }

   437 

   438 void tst_QTreeWidget::editItem_data()

   439 {

   440     QTest::addColumn<TreeItemList>("topLevelItems");

   441 

   442     {

   443         TreeItemList list;

   444         for (int i = 0; i < 10; i++) {

   445             TreeItem *item = new TreeItem(QStringList() << "col1" << "col2");

   446             if ((i & 1) == 0)

   447                 item->setFlags(item->flags() | Qt::ItemIsEditable);

   448             else

   449                 item->setFlags(item->flags() & ~Qt::ItemIsEditable);

   450             list << item;

   451         }

   452         QTest::newRow("2 columns, only even items editable")

   453             << list;

   454     }

   455 }

   456 

   457 void tst_QTreeWidget::editItem()

   458 {

   459     QFETCH(TreeItemList, topLevelItems);

   460 

   461     QTreeWidget tree;

   462     populate(&tree, topLevelItems, new TreeItem(QStringList() << "1" << "2"));

   463     tree.show();

   464 

   465     QSignalSpy itemChangedSpy(

   466         &tree, SIGNAL(itemChanged(QTreeWidgetItem*,int)));

   467 

   468     QTreeWidgetItemIterator it(&tree);

   469     while (QTreeWidgetItem *item = (*it++)) {

   470         for (int col = 0; col < item->columnCount(); ++col) {

   471             if (!(item->flags() & Qt::ItemIsEditable))

   472                 QTest::ignoreMessage(QtWarningMsg, "edit: editing failed");

   473             tree.editItem(item, col);

   474             QApplication::instance()->processEvents();

   475             QApplication::instance()->processEvents();

   476             QLineEdit *editor = qFindChild<QLineEdit*>(&tree);

   477             if (editor) {

   478                 QVERIFY(item->flags() & Qt::ItemIsEditable);

   479                 QCOMPARE(editor->selectedText(), editor->text());

   480                 QTest::keyClick(editor, Qt::Key_A);

   481                 QTest::keyClick(editor, Qt::Key_Enter);

   482                 QApplication::instance()->processEvents();

   483                 QCOMPARE(itemChangedSpy.count(), 1);

   484                 QVariantList args = itemChangedSpy.takeFirst();

   485                 QCOMPARE(qvariant_cast<QTreeWidgetItem*>(args.at(0)), item);

   486                 QCOMPARE(qvariant_cast<int>(args.at(1)), col);

   487             } else {

   488                 QVERIFY(!(item->flags() & Qt::ItemIsEditable));

   489             }

   490         }

   491     }

   492 }

   493 

   494 void tst_QTreeWidget::takeItem_data()

   495 {

   496     QTest::addColumn<int>("index");

   497     QTest::addColumn<bool>("topLevel");

   498     QTest::addColumn<bool>("outOfBounds");

   499 

   500     QTest::newRow("First, topLevel") << 0 << true << false;

   501     QTest::newRow("Last, topLevel") << 2 << true << false;

   502     QTest::newRow("Middle, topLevel") << 1 << true << false;

   503     QTest::newRow("Out of bounds, toplevel, (index: -1)") << -1 << true << true;

   504     QTest::newRow("Out of bounds, toplevel, (index: 3)") << 3 << true << true;

   505 

   506     QTest::newRow("First, child of topLevel") << 0 << false << false;

   507     QTest::newRow("Last, child of topLevel") << 2 << false << false;

   508     QTest::newRow("Middle, child of topLevel") << 1 << false << false;

   509     QTest::newRow("Out of bounds, child of toplevel, (index: -1)") << -1 << false << true;

   510     QTest::newRow("Out of bounds, child of toplevel, (index: 3)") << 3 << false << true;

   511 }

   512 

   513 void tst_QTreeWidget::takeItem()

   514 {

   515     QFETCH(int, index);

   516     QFETCH(bool, topLevel);

   517     QFETCH(bool, outOfBounds);

   518 

   519     for (int i=0; i<3; ++i) {

   520         QTreeWidgetItem *top = new QTreeWidgetItem(testWidget);

   521         top->setText(0, QString("top%1").arg(i));

   522         for (int j=0; j<3; ++j) {

   523             QTreeWidgetItem *child = new QTreeWidgetItem(top);

   524             child->setText(0, QString("child%1").arg(j));

   525         }

   526     }

   527 

   528     QCOMPARE(testWidget->topLevelItemCount(), 3);

   529     QCOMPARE(testWidget->topLevelItem(0)->childCount(), 3);

   530 

   531     if (topLevel) {

   532         int count = testWidget->topLevelItemCount();

   533         QTreeWidgetItem *item = testWidget->takeTopLevelItem(index);

   534         if (outOfBounds) {

   535             QCOMPARE(item, (QTreeWidgetItem *)0);

   536             QCOMPARE(count, testWidget->topLevelItemCount());

   537         } else {

   538             QCOMPARE(item->text(0), QString("top%1").arg(index));

   539             QCOMPARE(count-1, testWidget->topLevelItemCount());

   540             delete item;

   541         }

   542     } else {

   543         int count = testWidget->topLevelItem(0)->childCount();

   544         QTreeWidgetItem *item = testWidget->topLevelItem(0)->takeChild(index);

   545         if (outOfBounds) {

   546             QCOMPARE(item, (QTreeWidgetItem *)0);

   547             QCOMPARE(count, testWidget->topLevelItem(0)->childCount());

   548         } else {

   549             QCOMPARE(item->text(0), QString("child%1").arg(index));

   550             QCOMPARE(count-1, testWidget->topLevelItem(0)->childCount());

   551             delete item;

   552         }

   553     }

   554 }

   555 

   556 void tst_QTreeWidget::removeChild_data()

   557 {

   558     QTest::addColumn<int>("childCount");

   559     QTest::addColumn<int>("removeAt");

   560 

   561     QTest::newRow("10 remove 3") << 10 << 3;

   562 }

   563 

   564 void tst_QTreeWidget::removeChild()

   565 {

   566     QFETCH(int, childCount);

   567     QFETCH(int, removeAt);

   568 

   569     QTreeWidgetItem *root = new QTreeWidgetItem;

   570     for (int i = 0; i < childCount; ++i)

   571         new QTreeWidgetItem(root, QStringList(QString::number(i)));

   572 

   573     QCOMPARE(root->childCount(), childCount);

   574     for (int j = 0; j < childCount; ++j)

   575         QCOMPARE(root->child(j)->text(0), QString::number(j));

   576 

   577     QTreeWidgetItem *remove = root->child(removeAt);

   578     root->removeChild(remove);

   579 

   580     QCOMPARE(root->childCount(), childCount - 1);

   581     for (int k = 0; k < childCount; ++k) {

   582         if (k == removeAt)

   583             QCOMPARE(remove->text(0), QString::number(k));

   584         else if (k < removeAt)

   585             QCOMPARE(root->child(k)->text(0), QString::number(k));

   586         else if (k > removeAt)

   587             QCOMPARE(root->child(k - 1)->text(0), QString::number(k));

   588     }

   589     delete root;

   590 }

   591 

   592 void tst_QTreeWidget::setItemHidden()

   593 {

   594     QTreeWidgetItem *parent = new QTreeWidgetItem(testWidget);

   595     parent->setText(0, "parent");

   596     QTreeWidgetItem *child = new QTreeWidgetItem(parent);

   597     child->setText(0, "child");

   598     QVERIFY(child->parent());

   599 

   600     testWidget->expandItem(parent);

   601     testWidget->scrollToItem(child);

   602 

   603     QVERIFY(testWidget->visualItemRect(parent).isValid()

   604            && testWidget->viewport()->rect().contains(testWidget->visualItemRect(parent)));

   605     QVERIFY(testWidget->visualItemRect(child).isValid()

   606            && testWidget->viewport()->rect().contains(testWidget->visualItemRect(child)));

   607 

   608     QVERIFY(!testWidget->isItemHidden(parent));

   609     QVERIFY(!testWidget->isItemHidden(child));

   610 

   611     testWidget->setItemHidden(parent, true);

   612 

   613     QVERIFY(!(testWidget->visualItemRect(parent).isValid()

   614              && testWidget->viewport()->rect().contains(testWidget->visualItemRect(parent))));

   615     QVERIFY(!(testWidget->visualItemRect(child).isValid()

   616              && testWidget->viewport()->rect().contains(testWidget->visualItemRect(child))));

   617 

   618     QVERIFY(testWidget->isItemHidden(parent));

   619     QVERIFY(!testWidget->isItemHidden(child));

   620 

   621     // From task 78670 (This caused an core dump)

   622     // Check if we can set an item visible if it already is visible.

   623     testWidget->setItemHidden(parent, false);

   624     testWidget->setItemHidden(parent, false);

   625     QVERIFY(!testWidget->isItemHidden(parent));

   626 

   627 

   628     // hide, hide and then unhide.

   629     testWidget->setItemHidden(parent, true);

   630     testWidget->setItemHidden(parent, true);

   631     testWidget->setItemHidden(parent, false);

   632     QVERIFY(!testWidget->isItemHidden(parent));

   633 

   634 

   635 }

   636 

   637 

   638 void tst_QTreeWidget::setItemHidden2()

   639 {

   640     // From Task 78587

   641     QStringList hl;

   642     hl << "ID" << "Desc";

   643     testWidget->setColumnCount(hl.count());

   644     testWidget->setHeaderLabels(hl);

   645     testWidget->setSortingEnabled(true);

   646 

   647     QTreeWidgetItem *top = new QTreeWidgetItem(testWidget);

   648     QTreeWidgetItem *leaf = 0;

   649     top->setText(0, "ItemList");

   650     for (int i = 1; i <= 4; i++) {

   651         leaf = new QTreeWidgetItem(top);

   652         leaf->setText(0, QString().sprintf("%d", i));

   653         leaf->setText(1, QString().sprintf("Item %d", i));

   654     }

   655 

   656     if (testWidget->topLevelItemCount() > 0) {

   657         top = testWidget->topLevelItem(0);

   658         testWidget->setItemExpanded(top, true);

   659     }

   660 

   661     if (testWidget->topLevelItemCount() > 0) {

   662         top = testWidget->topLevelItem(0);

   663         for (int i = 0; i < top->childCount(); i++) {

   664             leaf = top->child(i);

   665             if (leaf->text(0).toInt() % 2 == 0) {

   666                 if (!testWidget->isItemHidden(leaf)) {

   667                     testWidget->setItemHidden(leaf, true);

   668                 }

   669             }

   670         }

   671     }

   672 }

   673 

   674 

   675 void tst_QTreeWidget::selectedItems_data()

   676 {

   677     QTest::addColumn<int>("topLevel");

   678     QTest::addColumn<int>("children");

   679     QTest::addColumn<bool>("closeTopLevel");

   680     QTest::addColumn<ListIntList>("selectedItems");

   681     QTest::addColumn<ListIntList>("hiddenItems");

   682     QTest::addColumn<ListIntList>("expectedItems");

   683 

   684     ListIntList selectedItems;

   685     ListIntList hiddenItems;

   686     ListIntList expectedItems;

   687 

   688     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   689     selectedItems

   690         << (IntList()

   691             << 0);

   692     expectedItems

   693         << (IntList() << 0);

   694     QTest::newRow("2 top with 2 children, closed, top0 selected, no hidden")

   695         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   696 

   697     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   698     selectedItems

   699         << (IntList()

   700             << 0 << 0);

   701     expectedItems

   702         << (IntList() << 0 << 0);

   703     QTest::newRow("2 top with 2 children, closed, top0child0 selected, no hidden")

   704         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   705 

   706     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   707     selectedItems

   708         << (IntList()

   709             << 0 << 0);

   710     expectedItems

   711         << (IntList()

   712             << 0 << 0);

   713     QTest::newRow("2 top with 2 children, open, top0child0 selected, no hidden")

   714         << 2 << 2 << false << selectedItems << hiddenItems << expectedItems;

   715 

   716     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   717     selectedItems << (IntList() << 0);

   718     hiddenItems << (IntList() << 0);

   719     QTest::newRow("2 top with 2 children, closed, top0 selected, top0 hidden")

   720         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   721 

   722     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   723     selectedItems << (IntList() << 0 << 0);

   724     hiddenItems << (IntList() << 0);

   725     expectedItems << (IntList() << 0 << 0);

   726     QTest::newRow("2 top with 2 children, closed, top0child0 selected, top0 hidden")

   727         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   728 

   729     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   730     selectedItems

   731         << (IntList() << 0)

   732         << (IntList() << 0 << 0)

   733         << (IntList() << 0 << 1)

   734         << (IntList() << 1)

   735         << (IntList() << 1 << 0)

   736         << (IntList() << 1 << 1);

   737     expectedItems

   738         << (IntList() << 0)

   739         << (IntList() << 0 << 0)

   740         << (IntList() << 0 << 1)

   741         << (IntList() << 1)

   742         << (IntList() << 1 << 0)

   743         << (IntList() << 1 << 1);

   744     QTest::newRow("2 top with 2 children, closed, all selected, no hidden")

   745         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   746 

   747 

   748     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   749     selectedItems

   750         << (IntList() << 0)

   751         << (IntList() << 0 << 0)

   752         << (IntList() << 0 << 1)

   753         << (IntList() << 1)

   754         << (IntList() << 1 << 0)

   755         << (IntList() << 1 << 1);

   756     hiddenItems

   757         << (IntList() << 0);

   758     expectedItems

   759         //<< (IntList() << 0)

   760         << (IntList() << 0 << 0)

   761         << (IntList() << 0 << 1)

   762         << (IntList() << 1)

   763         << (IntList() << 1 << 0)

   764         << (IntList() << 1 << 1);

   765     QTest::newRow("2 top with 2 children, closed, all selected, top0 hidden")

   766         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   767 

   768     selectedItems.clear(); hiddenItems.clear(); expectedItems.clear();

   769     selectedItems

   770         << (IntList() << 0)

   771         << (IntList() << 0 << 0)

   772         << (IntList() << 0 << 1)

   773         << (IntList() << 1)

   774         << (IntList() << 1 << 0)

   775         << (IntList() << 1 << 1);

   776     hiddenItems

   777         << (IntList() << 0 << 1)

   778         << (IntList() << 1);

   779     expectedItems

   780         << (IntList() << 0)

   781         << (IntList() << 0 << 0)

   782         //<< (IntList() << 0 << 1)

   783         //<< (IntList() << 1)

   784         << (IntList() << 1 << 0)

   785         << (IntList() << 1 << 1);

   786 

   787     QTest::newRow("2 top with 2 children, closed, all selected, top0child1 and top1")

   788         << 2 << 2 << true << selectedItems << hiddenItems << expectedItems;

   789 

   790 }

   791 

   792 void tst_QTreeWidget::selectedItems()

   793 {

   794     QFETCH(int, topLevel);

   795     QFETCH(int, children);

   796     QFETCH(bool, closeTopLevel);

   797     QFETCH(ListIntList, selectedItems);

   798     QFETCH(ListIntList, hiddenItems);

   799     QFETCH(ListIntList, expectedItems);

   800 

   801     // create items

   802     for (int t=0; t<topLevel; ++t) {

   803         QTreeWidgetItem *top = new QTreeWidgetItem(testWidget);

   804         top->setText(0, QString("top%1").arg(t));

   805         for (int c=0; c<children; ++c) {

   806             QTreeWidgetItem *child = new QTreeWidgetItem(top);

   807             child->setText(0, QString("top%1child%2").arg(t).arg(c));

   808         }

   809     }

   810 

   811     // set selected

   812     foreach (IntList itemPath, selectedItems) {

   813         QTreeWidgetItem *item = 0;

   814         foreach(int index, itemPath) {

   815             if (!item)

   816                 item = testWidget->topLevelItem(index);

   817             else

   818                 item = item->child(index);

   819         }

   820         testWidget->setItemSelected(item, true);

   821     }

   822 

   823     // hide rows

   824     foreach (IntList itemPath, hiddenItems) {

   825         QTreeWidgetItem *item = 0;

   826         foreach(int index, itemPath) {

   827             if (!item)

   828                 item = testWidget->topLevelItem(index);

   829             else

   830                 item = item->child(index);

   831         }

   832         testWidget->setItemHidden(item, true);

   833     }

   834 

   835     // open/close toplevel

   836     for (int i=0; i<testWidget->topLevelItemCount(); ++i) {

   837         if (closeTopLevel)

   838             testWidget->collapseItem(testWidget->topLevelItem(i));

   839         else

   840             testWidget->expandItem(testWidget->topLevelItem(i));

   841     }

   842 

   843     // check selectedItems

   844     QList<QTreeWidgetItem*> sel = testWidget->selectedItems();

   845     QCOMPARE(sel.count(), expectedItems.count());

   846     foreach (IntList itemPath, expectedItems) {

   847         QTreeWidgetItem *item = 0;

   848         foreach(int index, itemPath) {

   849             if (!item)

   850                 item = testWidget->topLevelItem(index);

   851             else

   852                 item = item->child(index);

   853         }

   854         if (item)

   855         QVERIFY(sel.contains(item));

   856     }

   857 

   858     // compare isSelected

   859     for (int t=0; t<testWidget->topLevelItemCount(); ++t) {

   860         QTreeWidgetItem *top = testWidget->topLevelItem(t);

   861         if (testWidget->isItemSelected(top) && !testWidget->isItemHidden(top))

   862             QVERIFY(sel.contains(top));

   863         for (int c=0; c<top->childCount(); ++c) {

   864             QTreeWidgetItem *child = top->child(c);

   865             if (testWidget->isItemSelected(child) && !testWidget->isItemHidden(child))

   866                 QVERIFY(sel.contains(child));

   867         }

   868     }

   869 

   870     // Possible to select null without crashing?

   871     testWidget->setItemSelected(0, true);

   872     QVERIFY(!testWidget->isItemSelected(0));

   873 

   874     // unselect

   875     foreach (IntList itemPath, selectedItems) {

   876         QTreeWidgetItem *item = 0;

   877         foreach(int index, itemPath) {

   878             if (!item)

   879                 item = testWidget->topLevelItem(index);

   880             else

   881                 item = item->child(index);

   882         }

   883         testWidget->setItemSelected(item, false);

   884     }

   885     QCOMPARE(testWidget->selectedItems().count(), 0);

   886 }

   887 

   888 void tst_QTreeWidget::itemAssignment()

   889 {

   890     // create item with children and parent but not insert in the view

   891     QTreeWidgetItem grandParent;

   892     QTreeWidgetItem *parent = new QTreeWidgetItem(&grandParent);

   893     parent->setText(0, "foo");

   894     parent->setText(1, "bar");

   895     for (int i=0; i<5; ++i) {

   896         QTreeWidgetItem *child = new QTreeWidgetItem(parent);

   897         child->setText(0, "bingo");

   898         child->setText(1, "bango");

   899     }

   900     QCOMPARE(parent->parent(), &grandParent);

   901     QVERIFY(!parent->treeWidget());

   902     QCOMPARE(parent->columnCount(), 2);

   903     QCOMPARE(parent->text(0), QString("foo"));

   904     QCOMPARE(parent->childCount(), 5);

   905     QCOMPARE(parent->child(0)->parent(), parent);

   906 

   907     // create item which is inserted in the widget

   908     QTreeWidgetItem item(testWidget);

   909     item.setText(0, "baz");

   910     QVERIFY(!item.parent());

   911     QCOMPARE(item.treeWidget(), static_cast<QTreeWidget *>(testWidget));

   912     QCOMPARE(item.columnCount(), 1);

   913     QCOMPARE(item.text(0), QString("baz"));

   914     QCOMPARE(item.childCount(), 0);

   915 

   916     // assign and test

   917     *parent = item;

   918     QCOMPARE(parent->parent(), &grandParent);

   919     QVERIFY(!parent->treeWidget());

   920     QCOMPARE(parent->columnCount(), 1);

   921     QCOMPARE(parent->text(0), QString("baz"));

   922     QCOMPARE(parent->childCount(), 5);

   923     QCOMPARE(parent->child(0)->parent(), parent);

   924 }

   925 

   926 void tst_QTreeWidget::clone_data()

   927 {

   928     QTest::addColumn<int>("column");

   929     QTest::addColumn<int>("topLevelIndex");

   930     QTest::addColumn<int>("childIndex");

   931     QTest::addColumn<QStringList>("topLevelText");

   932     QTest::addColumn<QStringList>("childText");

   933     QTest::addColumn<bool>("cloneChild");

   934 

   935     QTest::newRow("clone parent with child") << 0 << 0 << 0

   936                                           << (QStringList() << "some text")

   937                                           << (QStringList() << "more text")

   938                                           << false;

   939 

   940     QTest::newRow("clone child") << 0 << 0 << 0

   941                               << (QStringList() << "some text")

   942                               << (QStringList() << "more text")

   943                               << true;

   944 }

   945 

   946 void tst_QTreeWidget::clone()

   947 {

   948     QFETCH(int, column);

   949     QFETCH(int, topLevelIndex);

   950     QFETCH(int, childIndex);

   951     QFETCH(QStringList, topLevelText);

   952     QFETCH(QStringList, childText);

   953     QFETCH(bool, cloneChild);

   954 

   955     for (int i = 0; i < topLevelText.count(); ++i) {

   956         QTreeWidgetItem *item = new QTreeWidgetItem(testWidget);

   957         item->setText(column, topLevelText.at(i));

   958         for (int j = 0; j < childText.count(); ++j) {

   959             QTreeWidgetItem *child = new QTreeWidgetItem(item);

   960             child->setText(column, childText.at(j));

   961         }

   962     }

   963 

   964     QTreeWidgetItem *original = testWidget->topLevelItem(topLevelIndex);

   965     QTreeWidgetItem *copy = original->clone();

   966     QCOMPARE(copy->text(column), original->text(column));

   967     QCOMPARE(copy->childCount(), original->childCount());

   968     QVERIFY(!copy->parent());

   969     QVERIFY(!copy->treeWidget());

   970 

   971     QTreeWidgetItem *originalChild = original->child(childIndex);

   972     QTreeWidgetItem *copiedChild = cloneChild ? originalChild->clone() : copy->child(childIndex);

   973     QVERIFY(copiedChild != originalChild);

   974     QCOMPARE(copiedChild->text(column), originalChild->text(column));

   975     QCOMPARE(copiedChild->childCount(), originalChild->childCount());

   976     QCOMPARE(copiedChild->parent(), cloneChild ? 0 : copy);

   977     QVERIFY(!copiedChild->treeWidget());

   978     if (cloneChild)

   979         delete copiedChild;

   980     delete copy;

   981 }

   982 

   983 void tst_QTreeWidget::expand_data()

   984 {

   985     QTest::addColumn<int>("topLevelIndex");

   986     QTest::addColumn<int>("topLevelCount");

   987     QTest::addColumn<int>("childIndex");

   988     QTest::addColumn<int>("childCount");

   989 

   990     QTest::newRow("the only test data for now") << 0 << 1 << 0 << 1;

   991 }

   992 

   993 void tst_QTreeWidget::expand()

   994 {

   995     QFETCH(int, topLevelIndex);

   996     QFETCH(int, topLevelCount);

   997     QFETCH(int, childIndex);

   998     QFETCH(int, childCount);

   999 

  1000     for (int i = 0; i < topLevelCount; ++i) {

  1001         QTreeWidgetItem *item = new QTreeWidgetItem(testWidget);

  1002         for (int j = 0; j < childCount; ++j)

  1003             new QTreeWidgetItem(item);

  1004     }

  1005 

  1006     QTreeWidgetItem *topLevelItem = testWidget->topLevelItem(topLevelIndex);

  1007     QTreeWidgetItem *childItem = topLevelItem->child(childIndex);

  1008 

  1009     QVERIFY(!testWidget->isItemExpanded(topLevelItem));

  1010     testWidget->setItemExpanded(topLevelItem, true);

  1011     QVERIFY(testWidget->isItemExpanded(topLevelItem));

  1012 

  1013     QVERIFY(!testWidget->isItemExpanded(childItem));

  1014     testWidget->setItemExpanded(childItem, true);

  1015     QVERIFY(testWidget->isItemExpanded(childItem));

  1016 

  1017     QVERIFY(testWidget->isItemExpanded(topLevelItem));

  1018     testWidget->setItemExpanded(topLevelItem, false);

  1019     QVERIFY(!testWidget->isItemExpanded(topLevelItem));

  1020 

  1021     QVERIFY(testWidget->isItemExpanded(childItem));

  1022     testWidget->setItemExpanded(childItem, false);

  1023     QVERIFY(!testWidget->isItemExpanded(childItem));

  1024 }

  1025 

  1026 void tst_QTreeWidget::checkState_data()

  1027 {

  1028 }

  1029 

  1030 void tst_QTreeWidget::checkState()

  1031 {

  1032     QTreeWidgetItem *item = new QTreeWidgetItem(testWidget);

  1033     item->setCheckState(0, Qt::Unchecked);

  1034     QTreeWidgetItem *firstChild = new QTreeWidgetItem(item);

  1035     firstChild->setCheckState(0, Qt::Unchecked);

  1036     QTreeWidgetItem *seccondChild = new QTreeWidgetItem(item);

  1037     seccondChild->setCheckState(0, Qt::Unchecked);

  1038 

  1039     QCOMPARE(item->checkState(0), Qt::Unchecked);

  1040     QCOMPARE(firstChild->checkState(0), Qt::Unchecked);

  1041     QCOMPARE(seccondChild->checkState(0), Qt::Unchecked);

  1042 

  1043     firstChild->setCheckState(0, Qt::Checked);

  1044     QCOMPARE(item->checkState(0), Qt::Unchecked);

  1045     QCOMPARE(firstChild->checkState(0), Qt::Checked);

  1046     QCOMPARE(seccondChild->checkState(0), Qt::Unchecked);

  1047 

  1048     item->setFlags(item->flags()|Qt::ItemIsTristate);

  1049     QCOMPARE(item->checkState(0), Qt::PartiallyChecked);

  1050     QCOMPARE(firstChild->checkState(0), Qt::Checked);

  1051     QCOMPARE(seccondChild->checkState(0), Qt::Unchecked);

  1052 

  1053     seccondChild->setCheckState(0, Qt::Checked);

  1054     QCOMPARE(item->checkState(0), Qt::Checked);

  1055     QCOMPARE(firstChild->checkState(0), Qt::Checked);

  1056     QCOMPARE(seccondChild->checkState(0), Qt::Checked);

  1057 

  1058     firstChild->setCheckState(0, Qt::Unchecked);

  1059     seccondChild->setCheckState(0, Qt::Unchecked);

  1060     QCOMPARE(item->checkState(0), Qt::Unchecked);

  1061     QCOMPARE(firstChild->checkState(0), Qt::Unchecked);

  1062     QCOMPARE(seccondChild->checkState(0), Qt::Unchecked);

  1063 }

  1064 

  1065 void tst_QTreeWidget::findItems_data()

  1066 {

  1067     QTest::addColumn<int>("column");

  1068     QTest::addColumn<QStringList>("topLevelText");

  1069     QTest::addColumn<QStringList>("childText");

  1070     QTest::addColumn<QString>("pattern");

  1071     QTest::addColumn<int>("resultCount");

  1072     QTest::addColumn<QStringList>("resultText");

  1073 

  1074     QTest::newRow("find in toplevel")

  1075         << 0

  1076         << (QStringList() << "This is a text" << "This is another" << "This is the one")

  1077         << (QStringList() << "A child" << "This is not the one" << "And yet another child")

  1078         << "This is the one"

  1079         << 1

  1080         << (QStringList() << "This is the one");

  1081 

  1082     QTest::newRow("find child")

  1083         << 0

  1084         << (QStringList() << "This is a text" << "This is another" << "This is the one")

  1085         << (QStringList() << "A child" << "This is not the one" << "And yet another child")

  1086         << "A child"

  1087         << 3 // once for each branch

  1088         << (QStringList() << "A child");

  1089 

  1090 }

  1091 

  1092 void tst_QTreeWidget::findItems()

  1093 {

  1094     QFETCH(int, column);

  1095     QFETCH(QStringList, topLevelText);

  1096     QFETCH(QStringList, childText);

  1097     QFETCH(QString, pattern);

  1098     QFETCH(int, resultCount);

  1099     QFETCH(QStringList, resultText);

  1100 

  1101     for (int i = 0; i < topLevelText.count(); ++i) {

  1102         QTreeWidgetItem *item = new QTreeWidgetItem(testWidget);

  1103         item->setText(column, topLevelText.at(i));

  1104         for (int j = 0; j < childText.count(); ++j) {

  1105             QTreeWidgetItem *child = new QTreeWidgetItem(item);

  1106             child->setText(column, childText.at(j));

  1107         }

  1108     }

  1109 

  1110     QList<QTreeWidgetItem*> result = testWidget->findItems(pattern,

  1111                                                            Qt::MatchExactly|Qt::MatchRecursive);

  1112     QCOMPARE(result.count(), resultCount);

  1113 

  1114     for (int k = 0; k < result.count() && k < resultText.count(); ++k)

  1115         QCOMPARE(result.at(k)->text(column), resultText.at(k));

  1116 }

  1117 

  1118 void tst_QTreeWidget::findItemsInColumn()

  1119 {

  1120     // Create 5 root items.

  1121     for (int i = 0; i < 5; i++)

  1122         new QTreeWidgetItem(testWidget, QStringList() << QString::number(i));

  1123 

  1124     // Create a child with two columns for each root item.

  1125     for (int i = 0; i < 5; i++) {

  1126         QTreeWidgetItem * const  parent = testWidget->topLevelItem(i);

  1127         new QTreeWidgetItem(parent, QStringList() << QString::number(i * 10) << QString::number(i * 100));

  1128     }

  1129 

  1130     // Recursively search column one for 400.

  1131     QList<QTreeWidgetItem*> items = testWidget->findItems("400", Qt::MatchExactly|Qt::MatchRecursive, 1);

  1132     QCOMPARE(items.count(), 1);

  1133 }

  1134