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

**

** 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 <QtGui/QtGui>

#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();

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();

    // Boundry 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();

    // Boundry 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()

{

    // Boundry 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()

{

#if defined(Q_OS_SYMBIAN)

    //give the Symbian app start event queue time to clear

    QTest::qWait(1000);

#endif

    // Boundry 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()

{

    // Boundry 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));

    // Boundry 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));

    // Boundry 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()

{

    // Boundry 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.

    // Boundry 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);

}