/****************************************************************************

**

** Copyright (C) 2010 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$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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.

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qtreewidget.h>

#include <qtreewidgetitemiterator.h>

#include <qapplication.h>

#include <qeventloop.h>

#include <qdebug.h>

#include <qheaderview.h>

#include <qlineedit.h>

#include <QScrollBar>

#include <QStyledItemDelegate>

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

//TESTED_CLASS=

//TESTED_FILES=

class CustomTreeWidget : public QTreeWidget

{

    Q_OBJECT

public:

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

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

};

class tst_QTreeWidget : public QObject

{

    Q_OBJECT

public:

    tst_QTreeWidget();

    ~tst_QTreeWidget();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void addTopLevelItem();

    void currentItem_data();

    void currentItem();

    void editItem_data();

    void editItem();

    void takeItem_data();

    void takeItem();

    void removeChild_data();

    void removeChild();

    void setItemHidden();

    void setItemHidden2();

    void selectedItems_data();

    void selectedItems();

    void itemAssignment();

    void clone_data();

    void clone();

    void expand_data();

    void expand();

    void checkState_data();

    void checkState();

    void findItems_data();

    void findItems();

    void findItemsInColumn();

    void sortItems_data();

    void sortItems();

    void deleteItems_data();

    void deleteItems();

    void itemAboveOrBelow();

    void itemStreaming_data();

    void itemStreaming();

    void insertTopLevelItems_data();

    void insertTopLevelItems();

    void keyboardNavigation();

    void scrollToItem();

    void setSortingEnabled();

    void match();

    void columnCount();

    void setHeaderLabels();

    void setHeaderItem();

    void itemWidget_data();

    void itemWidget();

    void insertItemsWithSorting_data();

    void insertItemsWithSorting();

    void insertExpandedItemsWithSorting_data();

    void insertExpandedItemsWithSorting();

    void changeDataWithSorting_data();

    void changeDataWithSorting();

    void changeDataWithStableSorting_data();

    void changeDataWithStableSorting();

    void sortedIndexOfChild_data();

    void sortedIndexOfChild();

    void defaultRowSizes();

    void task191552_rtl();

    void task203673_selection();

    void rootItemFlags();

    void task218661_setHeaderData();

    void task245280_sortChildren();

    void task253109_itemHeight();

    // QTreeWidgetItem

    void itemOperatorLessThan();

    void addChild();

    void setData();

    void enableDisable();

    void expandAndCallapse();

    void itemData();

    void setDisabled();

    void removeSelectedItem();

    void removeCurrentItem();

    void removeCurrentItem_task186451();

    void randomExpand();

    void crashTest();

    void sortAndSelect();

    void task206367_duplication();

    void selectionOrder();

    void setSelectionModel();

    void task217309();

    void setCurrentItemExpandsParent();

    void task239150_editorWidth();

    void setTextUpdate();

    void taskQTBUG2844_visualItemRect();

    void setChildIndicatorPolicy();

public slots:

    void itemSelectionChanged();

    void emitDataChanged();

private:

    CustomTreeWidget *testWidget;

};

// Testing get/set functions

void tst_QTreeWidget::getSetCheck()

{

    QTreeWidget obj1;

    // int QTreeWidget::columnCount()

    // void QTreeWidget::setColumnCount(int)

    obj1.setColumnCount(0);

    QCOMPARE(obj1.columnCount(), 0);

    obj1.setColumnCount(INT_MIN);

    QCOMPARE(obj1.columnCount(), 0);

    //obj1.setColumnCount(INT_MAX);

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

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

    obj1.setColumnCount(100);

    QCOMPARE(obj1.columnCount(), 100);

    // QTreeWidgetItem * QTreeWidget::headerItem()

    // void QTreeWidget::setHeaderItem(QTreeWidgetItem *)

    QTreeWidgetItem *var2 = new QTreeWidgetItem();

    obj1.setHeaderItem(var2);

    QCOMPARE(obj1.headerItem(), var2);

    obj1.setHeaderItem((QTreeWidgetItem *)0);

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

    // QTreeWidgetItem * QTreeWidget::currentItem()

    // void QTreeWidget::setCurrentItem(QTreeWidgetItem *)

    QTreeWidgetItem *var3 = new QTreeWidgetItem(&obj1);

    obj1.setCurrentItem(var3);

    QCOMPARE(obj1.currentItem(), var3);

    obj1.setCurrentItem((QTreeWidgetItem *)0);

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

}

typedef QList<int> IntList;

typedef QList<IntList> ListIntList;

Q_DECLARE_METATYPE(IntList)

Q_DECLARE_METATYPE(ListIntList)

Q_DECLARE_METATYPE(QModelIndex)

Q_DECLARE_METATYPE(Qt::Orientation)

typedef QTreeWidgetItem TreeItem;

typedef QList<TreeItem*> TreeItemList;

Q_DECLARE_METATYPE(QTreeWidgetItem*)

Q_DECLARE_METATYPE(TreeItemList)

tst_QTreeWidget::tst_QTreeWidget(): testWidget(0)

{

}

tst_QTreeWidget::~tst_QTreeWidget()

{

}

void tst_QTreeWidget::initTestCase()

{

    qMetaTypeId<QModelIndex>();

    qMetaTypeId<Qt::Orientation>();

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

    testWidget = new CustomTreeWidget();

    testWidget->show();

#ifdef Q_WS_X11

    qt_x11_wait_for_window_manager(testWidget);

#endif

}

void tst_QTreeWidget::cleanupTestCase()

{

    testWidget->hide();

    delete testWidget;

}

void tst_QTreeWidget::init()

{

    testWidget->clear();

    testWidget->setColumnCount(2);

}

void tst_QTreeWidget::cleanup()

{

}

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

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

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

    return parent;

}

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

                     TreeItem *headerItem = 0)

{

    widget->clear();

    widget->setHeaderItem(headerItem);

    foreach (TreeItem *item, topLevelItems)

        widget->addTopLevelItem(item);

}

void tst_QTreeWidget::addTopLevelItem()

{

    QTreeWidget tree;

    QCOMPARE(tree.topLevelItemCount(), 0);

    // try to add 0

    tree.addTopLevelItem(0);

    QCOMPARE(tree.topLevelItemCount(), 0);

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

    // add one at a time

    QList<TreeItem*> tops;

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

        TreeItem *ti = new TreeItem();

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

        tree.addTopLevelItem(ti);

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

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

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

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

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

        tree.addTopLevelItem(ti);

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

        tops.append(ti);

    }

    // delete one at a time

    while (!tops.isEmpty()) {

        TreeItem *ti = tops.takeFirst();

        delete ti;

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

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

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

    }

    // add none

    {

        int count = tree.topLevelItemCount();

        tree.addTopLevelItems(tops);

        QCOMPARE(tree.topLevelItemCount(), count);

    }

    // add many at a time

    {

        const int count = 10;

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

            tops.clear();

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

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

            tree.addTopLevelItems(tops);

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

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

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

            tree.addTopLevelItems(tops);

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

        }

    }

    // insert

    {

        tops.clear();

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

            tops << new TreeItem();

        int count = tree.topLevelItemCount();

        tree.insertTopLevelItems(100000, tops);

        // ### fixme

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

    }

}

void tst_QTreeWidget::currentItem_data()

{

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

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

        << (TreeItemList()

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

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

    TreeItemList lst;

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

        << (TreeItemList()

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

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

            )

            )

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

            << (TreeItemList()

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

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

                )

            );

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

}

void tst_QTreeWidget::currentItem()

{

    QFETCH(TreeItemList, topLevelItems);

    QTreeWidget tree;

    tree.show();

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

    QTreeWidgetItem *previous = 0;

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

        tree.setSelectionBehavior(x ? QAbstractItemView::SelectItems

                                  : QAbstractItemView::SelectRows);

        QSignalSpy currentItemChangedSpy(

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

        QSignalSpy itemSelectionChangedSpy(

            &tree, SIGNAL(itemSelectionChanged()));

        QTreeWidgetItemIterator it(&tree);

        // do all items

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

            tree.setCurrentItem(item);

            QCOMPARE(tree.currentItem(), item);

            QCOMPARE(currentItemChangedSpy.count(), 1);

            QVariantList args = currentItemChangedSpy.takeFirst();

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

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

            QCOMPARE(itemSelectionChangedSpy.count(), 1);

            itemSelectionChangedSpy.clear();

            previous = item;

            // do all columns

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

                tree.setCurrentItem(item, col);

                QCOMPARE(tree.currentItem(), item);

                QCOMPARE(tree.currentColumn(), col);

                if (!currentItemChangedSpy.isEmpty()) {

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

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

                    QCOMPARE(currentItemChangedSpy.count(), 1);

                    QVariantList args = currentItemChangedSpy.takeFirst();

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

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

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

                        QCOMPARE(itemSelectionChangedSpy.count(), 1);

                        itemSelectionChangedSpy.clear();

                    } else {

                        QCOMPARE(itemSelectionChangedSpy.count(), 0);

                    }

                }

            }

        }

    }

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

    tree.setCurrentItem(tree.headerItem());

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

}

void tst_QTreeWidget::editItem_data()

{

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

    {

        TreeItemList list;

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

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

            if ((i & 1) == 0)

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

            else

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

            list << item;

        }

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

            << list;

    }

}

void tst_QTreeWidget::editItem()

{

    QFETCH(TreeItemList, topLevelItems);

    QTreeWidget tree;

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

    tree.show();

    QSignalSpy itemChangedSpy(

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

    QTreeWidgetItemIterator it(&tree);

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

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

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

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

            tree.editItem(item, col);

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

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

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

            if (editor) {

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

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

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

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

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

                QCOMPARE(itemChangedSpy.count(), 1);

                QVariantList args = itemChangedSpy.takeFirst();

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

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

            } else {

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

            }

        }

    }

}

void tst_QTreeWidget::takeItem_data()

{

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

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

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

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

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

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

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

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

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

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

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

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

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

}

void tst_QTreeWidget::takeItem()

{

    QFETCH(int, index);

    QFETCH(bool, topLevel);

    QFETCH(bool, outOfBounds);

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

        QTreeWidgetItem *top = new QTreeWidgetItem(testWidget);

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

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

            QTreeWidgetItem *child = new QTreeWidgetItem(top);

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

        }