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

**

** 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 <qstandarditemmodel.h>

#include <QTreeView>

#include <private/qtreeview_p.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_QStandardItemModel : public QObject

{

    Q_OBJECT

public:

    tst_QStandardItemModel();

    virtual ~tst_QStandardItemModel();

    enum ModelChanged {

        RowsAboutToBeInserted,

        RowsInserted,

        RowsAboutToBeRemoved,

        RowsRemoved,

        ColumnsAboutToBeInserted,

        ColumnsInserted,

        ColumnsAboutToBeRemoved,

        ColumnsRemoved

    };

public slots:

    void init();

    void cleanup();

protected slots:

    void checkAboutToBeRemoved();

    void checkRemoved();

    void updateRowAboutToBeRemoved();

    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 slots:

    void insertRow_data();

    void insertRow();

    void insertRows();

    void insertRowsItems();

    void insertRowInHierarcy();

    void insertColumn_data();

    void insertColumn();

    void insertColumns();

    void removeRows();

    void removeColumns();

    void setHeaderData();

    void persistentIndexes();

    void removingPersistentIndexes();

    void updatingPersistentIndexes();

    void checkChildren();

    void data();

    void clear();

    void sort_data();

    void sort();

    void sortRole_data();

    void sortRole();

    void findItems();

    void getSetHeaderItem();

    void indexFromItem();

    void itemFromIndex();

    void getSetItemPrototype();

    void getSetItemData();

    void setHeaderLabels_data();

    void setHeaderLabels();

    void itemDataChanged();

    void takeHeaderItem();

    void useCase1();

    void useCase2();

    void useCase3();

    void rootItemFlags();

    void treeDragAndDrop();

    void removeRowsAndColumns();

private:

    QAbstractItemModel *m_model;

    QPersistentModelIndex persistent;

    QVector<QModelIndex> rcParent;

    QVector<int> rcFirst;

    QVector<int> rcLast;

    //return true if models have the same structure, and all child have the same text

    bool compareModels(QStandardItemModel *model1, QStandardItemModel *model2);

    //return true if models have the same structure, and all child have the same text

    bool compareItems(QStandardItem *item1, QStandardItem *item2);

};

static const int defaultSize = 3;

Q_DECLARE_METATYPE(QModelIndex)

Q_DECLARE_METATYPE(QStandardItem*)

Q_DECLARE_METATYPE(Qt::Orientation)

Q_DECLARE_METATYPE(QVariantList)

tst_QStandardItemModel::tst_QStandardItemModel() : m_model(0), rcParent(8), rcFirst(8,0), rcLast(8,0)

{

}

tst_QStandardItemModel::~tst_QStandardItemModel()

{

}

/*

  This test usually uses a model with a 3x3 table

  ---------------------------

  |  0,0  |  0,1    |  0,2  |

  ---------------------------

  |  1,0  |  1,1    |  1,2  |

  ---------------------------

  |  2,0  |  2,1    |  2,2  |

  ---------------------------

*/

void tst_QStandardItemModel::init()

{

    qRegisterMetaType<QModelIndex>("QModelIndex");

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

    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");

    m_model = new QStandardItemModel(defaultSize, defaultSize);

    connect(m_model, SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)),

            this, SLOT(rowsAboutToBeInserted(QModelIndex, int, int)));

    connect(m_model, SIGNAL(rowsInserted(QModelIndex, int, int)),

            this, SLOT(rowsInserted(QModelIndex, int, int)));

    connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)),

            this, SLOT(rowsAboutToBeRemoved(QModelIndex, int, int)));

    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)),

            this, SLOT(rowsRemoved(QModelIndex, int, int)));

    connect(m_model, SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)),

            this, SLOT(columnsAboutToBeInserted(QModelIndex, int, int)));

    connect(m_model, SIGNAL(columnsInserted(QModelIndex, int, int)),

            this, SLOT(columnsInserted(QModelIndex, int, int)));

    connect(m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)),

            this, SLOT(columnsAboutToBeRemoved(QModelIndex, int, int)));

    connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)),

            this, SLOT(columnsRemoved(QModelIndex, int, int)));

    rcFirst.fill(-1);

    rcLast.fill(-1);

}

void tst_QStandardItemModel::cleanup()

{

    disconnect(m_model, SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)),

               this, SLOT(rowsAboutToBeInserted(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(rowsInserted(QModelIndex, int, int)),

               this, SLOT(rowsInserted(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)),

               this, SLOT(rowsAboutToBeRemoved(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)),

               this, SLOT(rowsRemoved(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)),

               this, SLOT(columnsAboutToBeInserted(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(columnsInserted(QModelIndex, int, int)),

               this, SLOT(columnsInserted(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)),

               this, SLOT(columnsAboutToBeRemoved(QModelIndex, int, int)));

    disconnect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)),

               this, SLOT(columnsRemoved(QModelIndex, int, int)));

    delete m_model;

    m_model = 0;

}

void tst_QStandardItemModel::insertRow_data()

{

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

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

    QTest::newRow("Insert less then 0") << -1 << 0;

    QTest::newRow("Insert at 0")  << 0 << 0;

    QTest::newRow("Insert beyond count")  << defaultSize+1 << defaultSize;

    QTest::newRow("Insert at count") << defaultSize << defaultSize;

    QTest::newRow("Insert in the middle") << 1 << 1;

}

void tst_QStandardItemModel::insertRow()

{

    QFETCH(int, insertRow);

    QFETCH(int, expectedRow);

    QIcon icon;

    // default all initial items to DisplayRole: "initalitem"

    for (int r=0; r < m_model->rowCount(); ++r) {

        for (int c=0; c < m_model->columnCount(); ++c) {

            m_model->setData(m_model->index(r,c), "initialitem", Qt::DisplayRole);

        }

    }

    // check that inserts changes rowCount

    QCOMPARE(m_model->rowCount(), defaultSize);

    m_model->insertRow(insertRow);

    if (insertRow >= 0 && insertRow <= defaultSize) {

        QCOMPARE(m_model->rowCount(), defaultSize + 1);

        // check that signals were emitted with correct info

        QCOMPARE(rcFirst[RowsAboutToBeInserted], expectedRow);

        QCOMPARE(rcLast[RowsAboutToBeInserted], expectedRow);

        QCOMPARE(rcFirst[RowsInserted], expectedRow);

        QCOMPARE(rcLast[RowsInserted], expectedRow);

        //check that the inserted item has different DisplayRole than initial items

        QVERIFY(m_model->data(m_model->index(expectedRow, 0), Qt::DisplayRole).toString() != "initialitem");

    } else {

        // We inserted something outside the bounds, do nothing

        QCOMPARE(m_model->rowCount(), defaultSize);

        QCOMPARE(rcFirst[RowsAboutToBeInserted], -1);

        QCOMPARE(rcLast[RowsAboutToBeInserted], -1);

        QCOMPARE(rcFirst[RowsInserted], -1);

        QCOMPARE(rcLast[RowsInserted], -1);

    }

}

void tst_QStandardItemModel::insertRows()

{

    int rowCount = m_model->rowCount();

    QCOMPARE(rowCount, defaultSize);

    // insert custom header label

    QString headerLabel = "custom";

    m_model->setHeaderData(0, Qt::Vertical, headerLabel);

    // insert one row

    m_model->insertRows(0, 1);

    QCOMPARE(m_model->rowCount(), rowCount + 1);

    rowCount = m_model->rowCount();

    // check header data has moved

    QCOMPARE(m_model->headerData(1, Qt::Vertical).toString(), headerLabel);

    // insert two rows

    m_model->insertRows(0, 2);

    QCOMPARE(m_model->rowCount(), rowCount + 2);

    // check header data has moved

    QCOMPARE(m_model->headerData(3, Qt::Vertical).toString(), headerLabel);

}

void tst_QStandardItemModel::insertRowsItems()

{

    int rowCount = m_model->rowCount();

    QList<QStandardItem *> items;

    QStandardItemModel *m = qobject_cast<QStandardItemModel*>(m_model);

    QStandardItem *hiddenRoot = m->invisibleRootItem();

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

        items.append(new QStandardItem(QString("%1").arg(i + 10)));

    hiddenRoot->appendRows(items);

    QCOMPARE(m_model->rowCount(), rowCount + 3);

    QCOMPARE(m_model->index(rowCount + 0, 0).data().toInt(), 10);

    QCOMPARE(m_model->index(rowCount + 1, 0).data().toInt(), 11);

    QCOMPARE(m_model->index(rowCount + 2, 0).data().toInt(), 12);

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

        QVERIFY(m->item(i));

        QCOMPARE(static_cast<QAbstractItemModel *>(m->item(i)->model()), m_model);

    }

}

void tst_QStandardItemModel::insertRowInHierarcy()

{

    QVERIFY(m_model->insertRows(0, 1, QModelIndex()));

    QVERIFY(m_model->insertColumns(0, 1, QModelIndex()));

    QVERIFY(m_model->hasIndex(0, 0, QModelIndex()));

    QModelIndex parent = m_model->index(0, 0, QModelIndex());

    QVERIFY(parent.isValid());

    QVERIFY(m_model->insertRows(0, 1, parent));

    QVERIFY(m_model->insertColumns(0, 1, parent));

    QVERIFY(m_model->hasIndex(0, 0, parent));

    QModelIndex child = m_model->index(0, 0, parent);

    QVERIFY(child.isValid());

}

void tst_QStandardItemModel::insertColumn_data()

{

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

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

    QTest::newRow("Insert less then 0") << -1 << 0;

    QTest::newRow("Insert at 0")  << 0 << 0;

    QTest::newRow("Insert beyond count")  << defaultSize+1 << defaultSize;

    QTest::newRow("Insert at count") << defaultSize << defaultSize;

    QTest::newRow("Insert in the middle") << 1 << 1;

}

void tst_QStandardItemModel::insertColumn()

{

    QFETCH(int, insertColumn);

    QFETCH(int, expectedColumn);

    // default all initial items to DisplayRole: "initalitem"

    for (int r=0; r < m_model->rowCount(); ++r) {

        for (int c=0; c < m_model->columnCount(); ++c) {

            m_model->setData(m_model->index(r,c), "initialitem", Qt::DisplayRole);

        }

    }

    // check that inserts changes columnCount

    QCOMPARE(m_model->columnCount(), defaultSize);

    m_model->insertColumn(insertColumn);

    if (insertColumn >= 0 && insertColumn <= defaultSize) {

        QCOMPARE(m_model->columnCount(), defaultSize +  1);

        // check that signals were emitted with correct info

        QCOMPARE(rcFirst[ColumnsAboutToBeInserted], expectedColumn);

        QCOMPARE(rcLast[ColumnsAboutToBeInserted], expectedColumn);

        QCOMPARE(rcFirst[ColumnsInserted], expectedColumn);

        QCOMPARE(rcLast[ColumnsInserted], expectedColumn);

        //check that the inserted item has different DisplayRole than initial items

        QVERIFY(m_model->data(m_model->index(0, expectedColumn), Qt::DisplayRole).toString() != "initialitem");

    } else {

        // We inserted something outside the bounds, do nothing

        QCOMPARE(m_model->columnCount(), defaultSize);

        QCOMPARE(rcFirst[ColumnsAboutToBeInserted], -1);

        QCOMPARE(rcLast[ColumnsAboutToBeInserted], -1);

        QCOMPARE(rcFirst[ColumnsInserted], -1);

        QCOMPARE(rcLast[ColumnsInserted], -1);

    }

}

void tst_QStandardItemModel::insertColumns()

{

    int columnCount = m_model->columnCount();

    QCOMPARE(columnCount, defaultSize);

    // insert custom header label

    QString headerLabel = "custom";

    m_model->setHeaderData(0, Qt::Horizontal, headerLabel);

    // insert one column

    m_model->insertColumns(0, 1);

    QCOMPARE(m_model->columnCount(), columnCount + 1);

    columnCount = m_model->columnCount();

    // check header data has moved

    QCOMPARE(m_model->headerData(1, Qt::Horizontal).toString(), headerLabel);

    // insert two columns

    m_model->insertColumns(0, 2);

    QCOMPARE(m_model->columnCount(), columnCount + 2);

    // check header data has moved

    QCOMPARE(m_model->headerData(3, Qt::Horizontal).toString(), headerLabel);

}

void tst_QStandardItemModel::removeRows()

{

    int rowCount = m_model->rowCount();

    QCOMPARE(rowCount, defaultSize);

    // insert custom header label

    QString headerLabel = "custom";

    m_model->setHeaderData(rowCount - 1, Qt::Vertical, headerLabel);

    // remove one row

    m_model->removeRows(0, 1);

    QCOMPARE(m_model->rowCount(), rowCount - 1);

    rowCount = m_model->rowCount();

    // check header data has moved

    QCOMPARE(m_model->headerData(rowCount - 1, Qt::Vertical).toString(), headerLabel);

    // remove two rows

    m_model->removeRows(0, 2);

    QCOMPARE(m_model->rowCount(), rowCount - 2);

}

void tst_QStandardItemModel::removeColumns()

{

    int columnCount = m_model->columnCount();

    QCOMPARE(columnCount, defaultSize);

    // insert custom header label

    QString headerLabel = "custom";

    m_model->setHeaderData(columnCount - 1, Qt::Horizontal, headerLabel);

    // remove one column

    m_model->removeColumns(0, 1);

    QCOMPARE(m_model->columnCount(), columnCount - 1);

    columnCount = m_model->columnCount();

    // check header data has moved

    QCOMPARE(m_model->headerData(columnCount - 1, Qt::Horizontal).toString(), headerLabel);

    // remove two columns

    m_model->removeColumns(0, 2);

    QCOMPARE(m_model->columnCount(), columnCount - 2);

}

void tst_QStandardItemModel::setHeaderData()

{

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

        bool vertical = (x == 0);

        int count = vertical ? m_model->rowCount() : m_model->columnCount();

        QCOMPARE(count, defaultSize);

        Qt::Orientation orient = vertical ? Qt::Vertical : Qt::Horizontal;

        // check default values are ok

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

            QCOMPARE(m_model->headerData(i, orient).toString(), QString::number(i + 1));

        QSignalSpy headerDataChangedSpy(

            m_model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)));

        QSignalSpy dataChangedSpy(

            m_model, SIGNAL(dataChanged(QModelIndex, QModelIndex)));

        // insert custom values and check

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

            QString customString = QString("custom") + QString::number(i);

            QCOMPARE(m_model->setHeaderData(i, orient, customString), true);

            QCOMPARE(headerDataChangedSpy.count(), 1);

            QCOMPARE(dataChangedSpy.count(), 0);

            QVariantList args = headerDataChangedSpy.takeFirst();

            QCOMPARE(qvariant_cast<Qt::Orientation>(args.at(0)), orient);

            QCOMPARE(args.at(1).toInt(), i);

            QCOMPARE(args.at(2).toInt(), i);

            QCOMPARE(m_model->headerData(i, orient).toString(), customString);

            QCOMPARE(m_model->setHeaderData(i, orient, customString), true);

            QCOMPARE(headerDataChangedSpy.count(), 0);

            QCOMPARE(dataChangedSpy.count(), 0);

        }

        //check read from invalid sections

        QVERIFY(!m_model->headerData(count, orient).isValid());

        QVERIFY(!m_model->headerData(-1, orient).isValid());

        //check write to invalid section

        QCOMPARE(m_model->setHeaderData(count, orient, "foo"), false);

        QCOMPARE(m_model->setHeaderData(-1, orient, "foo"), false);

        QVERIFY(!m_model->headerData(count, orient).isValid());

        QVERIFY(!m_model->headerData(-1, orient).isValid());

    }

}

void tst_QStandardItemModel::persistentIndexes()

{

    QCOMPARE(m_model->rowCount(), defaultSize);

    QCOMPARE(m_model->columnCount(), defaultSize);

    // create a persisten index at 0,0

    QPersistentModelIndex persistentIndex(m_model->index(0, 0));

    // verify it is ok and at the correct spot

    QVERIFY(persistentIndex.isValid());

    QCOMPARE(persistentIndex.row(), 0);

    QCOMPARE(persistentIndex.column(), 0);

    // insert row and check that the persisten index has moved

    QVERIFY(m_model->insertRow(0));

    QVERIFY(persistentIndex.isValid());

    QCOMPARE(persistentIndex.row(), 1);

    QCOMPARE(persistentIndex.column(), 0);

    // insert row after the persisten index and see that it stays the same

    QVERIFY(m_model->insertRow(m_model->rowCount()));

    QVERIFY(persistentIndex.isValid());

    QCOMPARE(persistentIndex.row(), 1);

    QCOMPARE(persistentIndex.column(), 0);

    // insert column and check that the persisten index has moved

    QVERIFY(m_model->insertColumn(0));