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

**

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

**

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

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

**

** Copyright (C) 2009 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.

**

** $LICENSE$

**

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

#include <QtTest/QtTest>

#include <QtCore>

#include <qdebug.h>

#include "modelstotest.cpp"

#include <QMetaType>

Q_DECLARE_METATYPE(QModelIndex)

//TESTED_CLASS=

//TESTED_FILES=gui/itemviews/qstandarditemmodel.h gui/itemviews/qstandarditemmodel.cpp

/*!

    See modelstotest.cpp for instructions on how to have your model tested with these tests.

    Each test such as rowCount have a _data() function which populate the QTest data with

    the tests specified by modelstotest.cpp and any extra data needed for that perticular test.

    setupWithNoTestData() fills the QTest data with just the tests and is used by most tests.

    There are some basic qDebug statements sprikled about that might be helpfull for fixing

    your issues.

 */

class tst_QItemModel : public QObject

{

    Q_OBJECT

public:

    tst_QItemModel() {};

    virtual ~tst_QItemModel() {};

public slots:

    void init();

    void cleanup();

private slots:

    void nonDestructiveBasicTest_data();

    void nonDestructiveBasicTest();

    void rowCount_data();

    void rowCount();

    void columnCount_data();

    void columnCount();

    void hasIndex_data();

    void hasIndex();

    void index_data();

    void index();

    void parent_data();

    void parent();

    void data_data();

    void data();

    void setData_data();

    void setData();

    void setHeaderData_data();

    void setHeaderData();

    void remove_data();

    void remove();

    void insert_data();

    void insert();

    void sort_data();

    void sort();

protected slots:

    void slot_rowsAboutToRemove(const QModelIndex &parent);

    void slot_rowsRemoved(const QModelIndex &parent);

    void slot_columnsAboutToRemove(const QModelIndex &parent);

    void slot_columnsRemoved(const QModelIndex &parent);

    void slot_rowsAboutToInserted(const QModelIndex &parent);

    void slot_rowsInserted(const QModelIndex &parent);

    void slot_columnsAboutToInserted(const QModelIndex &parent);

    void slot_columnsInserted(const QModelIndex &parent);

private:

    void setupWithNoTestData();

    QAbstractItemModel *currentModel;

    ModelsToTest *testModels;

    // used by remove()

    QPersistentModelIndex parentOfRemoved;

    int afterAboutToRemoveRowCount;

    int afterRemoveRowCount;

    int afterAboutToRemoveColumnCount;

    int afterRemoveColumnCount;

    // remove() recursive

    bool removeRecursively;

    // used by insert()

    QPersistentModelIndex parentOfInserted;

    int afterAboutToInsertRowCount;

    int afterInsertRowCount;

    int afterAboutToInsertColumnCount;

    int afterInsertColumnCount;

    // insert() recursive

    bool insertRecursively;

};

void tst_QItemModel::init()

{

    testModels = new ModelsToTest();

    removeRecursively = false;

    insertRecursively = false;

}

void tst_QItemModel::cleanup()

{

    testModels->cleanupTestArea(currentModel);

    delete testModels;

    delete currentModel;

    currentModel = 0;

}

void tst_QItemModel::setupWithNoTestData()

{

    ModelsToTest modelsToTest;

    QTest::addColumn<QString>("modelType");

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

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

    for (int i = 0; i < modelsToTest.tests.size(); ++i) {

        ModelsToTest::test t = modelsToTest.tests.at(i);

        bool readOnly = (t.read == ModelsToTest::ReadOnly);

        bool isEmpty = (t.contains == ModelsToTest::Empty);

        QTest::newRow(t.modelType.toLatin1().data()) << t.modelType << readOnly << isEmpty;

    }

}

void tst_QItemModel::nonDestructiveBasicTest_data()

{

    setupWithNoTestData();

}

/*!

    nonDestructiveBasicTest trys to call a number of the basic functions (not all)

    to make sure the model doesn't segfault, testing the functions that makes sense.

 */

void tst_QItemModel::nonDestructiveBasicTest()

{

    QFETCH(QString, modelType);

    currentModel = testModels->createModel(modelType);

    QCOMPARE(currentModel->buddy(QModelIndex()), QModelIndex());

    currentModel->canFetchMore(QModelIndex());

    QVERIFY(currentModel->columnCount(QModelIndex()) >= 0);

    QCOMPARE(currentModel->data(QModelIndex()), QVariant());

    currentModel->fetchMore(QModelIndex());

    Qt::ItemFlags flags = currentModel->flags(QModelIndex());

    QVERIFY(flags == Qt::ItemIsDropEnabled || flags == 0);

    currentModel->hasChildren(QModelIndex());

    currentModel->hasIndex(0, 0);

    currentModel->headerData(0, Qt::Horizontal);

    currentModel->index(0,0), QModelIndex();

    currentModel->itemData(QModelIndex());

    QVariant cache;

    currentModel->match(QModelIndex(), -1, cache);

    currentModel->mimeTypes();

    QCOMPARE(currentModel->parent(QModelIndex()), QModelIndex());

    QVERIFY(currentModel->rowCount() >= 0);

    QVariant variant;

    currentModel->setData(QModelIndex(), variant, -1);

    currentModel->setHeaderData(-1, Qt::Horizontal, QVariant());

    currentModel->setHeaderData(0, Qt::Horizontal, QVariant());

    currentModel->setHeaderData(currentModel->columnCount() + 100, Qt::Horizontal, QVariant());

    QMap<int, QVariant> roles;

    currentModel->setItemData(QModelIndex(), roles);

    currentModel->sibling(0,0,QModelIndex());

    currentModel->span(QModelIndex());

    currentModel->supportedDropActions();

    currentModel->revert();

    currentModel->submit();

}

void tst_QItemModel::rowCount_data()

{

    setupWithNoTestData();

}

/*!

    Tests model's implimentation of QAbstractItemModel::rowCount() and hasChildren()

 */

void tst_QItemModel::rowCount()

{

    QFETCH(QString, modelType);

    currentModel = testModels->createModel(modelType);

    QFETCH(bool, isEmpty);

    if (isEmpty) {

        QCOMPARE(currentModel->rowCount(), 0);

        QCOMPARE(currentModel->hasChildren(), false);

    }

    else {

        QVERIFY(currentModel->rowCount() > 0);

        QCOMPARE(currentModel->hasChildren(), true);

    }

    // check top row

    QModelIndex topIndex = currentModel->index(0, 0, QModelIndex());

    int rows = currentModel->rowCount(topIndex);

    QVERIFY(rows >= 0);

    if (rows > 0)

        QCOMPARE(currentModel->hasChildren(topIndex), true);

    else

        QCOMPARE(currentModel->hasChildren(topIndex), false);

    QModelIndex secondLevelIndex = currentModel->index(0, 0, topIndex);

    if (secondLevelIndex.isValid()) { // not the top level

        // check a row count where parent is valid

        rows = currentModel->rowCount(secondLevelIndex);

        QVERIFY(rows >= 0);

        if (rows > 0)

            QCOMPARE(currentModel->hasChildren(secondLevelIndex), true);

        else

            QCOMPARE(currentModel->hasChildren(secondLevelIndex), false);

    }

    // rowCount is tested more extensivly more later in checkChildren(),

    // but this catches the big mistakes

}

void tst_QItemModel::columnCount_data()

{

    setupWithNoTestData();

}

/*!

    Tests model's implimentation of QAbstractItemModel::columnCount() and hasChildren()

 */

void tst_QItemModel::columnCount()

{

    QFETCH(QString, modelType);

    currentModel = testModels->createModel(modelType);

    QFETCH(bool, isEmpty);

    if (isEmpty) {

        QCOMPARE(currentModel->hasChildren(), false);

    }

    else {

        QVERIFY(currentModel->columnCount() > 0);

        QCOMPARE(currentModel->hasChildren(), true);

    }

    // check top row

    QModelIndex topIndex = currentModel->index(0, 0, QModelIndex());

    int columns = currentModel->columnCount(topIndex);

    // check a row count where parent is valid

    columns = currentModel->columnCount(currentModel->index(0, 0, topIndex));

    QVERIFY(columns >= 0);

    // columnCount is tested more extensivly more later in checkChildren(),

    // but this catches the big mistakes

}

void tst_QItemModel::hasIndex_data()

{

    setupWithNoTestData();

}

/*!

    Tests model's implimentation of QAbstractItemModel::hasIndex()

 */

void tst_QItemModel::hasIndex()

{

    QFETCH(QString, modelType);

    currentModel = testModels->createModel(modelType);

    // Make sure that invalid values returns an invalid index

    QCOMPARE(currentModel->hasIndex(-2, -2), false);

    QCOMPARE(currentModel->hasIndex(-2, 0), false);

    QCOMPARE(currentModel->hasIndex(0, -2), false);

    int rows = currentModel->rowCount();

    int columns = currentModel->columnCount();

    QCOMPARE(currentModel->hasIndex(rows, columns), false);

    QCOMPARE(currentModel->hasIndex(rows+1, columns+1), false);

    QFETCH(bool, isEmpty);

    if (isEmpty)

        return;

    QCOMPARE(currentModel->hasIndex(0,0), true);

    // hasIndex is tested more extensivly more later in checkChildren(),

    // but this catches the big mistakes

}

void tst_QItemModel::index_data()

{

    setupWithNoTestData();

}

/*!

    Tests model's implimentation of QAbstractItemModel::index()

 */

void tst_QItemModel::index()

{

    QFETCH(QString, modelType);

    currentModel = testModels->createModel(modelType);

    // Make sure that invalid values returns an invalid index

    QCOMPARE(currentModel->index(-2, -2), QModelIndex());

    QCOMPARE(currentModel->index(-2, 0), QModelIndex());

    QCOMPARE(currentModel->index(0, -2), QModelIndex());

    QFETCH(bool, isEmpty);

    if (isEmpty)

        return;

    int rows = currentModel->rowCount();

    int columns = currentModel->columnCount();

    // Catch off by one errors

    QCOMPARE(currentModel->index(rows,columns), QModelIndex());

    QCOMPARE(currentModel->index(0,0).isValid(), true);

    // Make sure that the same index is always returned

    QModelIndex a = currentModel->index(0,0);

    QModelIndex b = currentModel->index(0,0);

    QVERIFY(a == b);

    // index is tested more extensivly more later in checkChildren(),

    // but this catches the big mistakes

}

void tst_QItemModel::parent_data()

{

    setupWithNoTestData();

}

/*!

    A model that returns an index of parent X should also return X when asking

    for the parent of the index.

    This recursive function does pretty extensive testing on the whole model in an

    effort to catch edge cases.

    This function assumes that rowCount(), columnCount() and index() work.  If they have

    a bug it will point it out, but the above tests should have already found the basic bugs

    because it is easier to figure out the problem in those tests then this one.

 */

void checkChildren(QAbstractItemModel *currentModel, const QModelIndex &parent, int currentDepth=0)

{

    QFETCH(bool, readOnly);

    if (currentModel->canFetchMore(parent))

        currentModel->fetchMore(parent);

    int rows = currentModel->rowCount(parent);

    int columns = currentModel->columnCount(parent);

    QCOMPARE(rows > 0, (currentModel->hasChildren(parent)));

    // Some reasuring testing against rows(),columns(), and hasChildren()

    QVERIFY(rows >= 0);

    QVERIFY(columns >= 0);

    if (rows > 0 || columns > 0)

        QCOMPARE(currentModel->hasChildren(parent), true);

    else

        QCOMPARE(currentModel->hasChildren(parent), false);

    //qDebug() << "parent:" << currentModel->data(parent).toString() << "rows:" << rows

    //         << "columns:" << columns << "parent column:" << parent.column();

    QCOMPARE(currentModel->hasIndex(rows+1, 0, parent), false);

    for (int r = 0; r < rows; ++r) {

        if (currentModel->canFetchMore(parent))

            currentModel->fetchMore(parent);

        QCOMPARE(currentModel->hasIndex(r, columns+1, parent), false);

        for (int c = 0; c < columns; ++c) {

            QCOMPARE(currentModel->hasIndex(r, c, parent), true);

            QModelIndex index = currentModel->index(r, c, parent);

            QCOMPARE(index.isValid(), true);

            if (!readOnly)

                currentModel->setData(index, "I'm a little tea pot short and stout");

            QModelIndex modifiedIndex = currentModel->index(r, c, parent);

            QCOMPARE(index, modifiedIndex);

            // Make sure we get the same index if we request it twice in a row

            QModelIndex a = currentModel->index(r, c, parent);

            QModelIndex b = currentModel->index(r, c, parent);

            QVERIFY(a == b);

            // Some basic checking on the index that is returned

            QVERIFY(index.model() == currentModel);

            QCOMPARE(index.row(), r);

            QCOMPARE(index.column(), c);

            QCOMPARE(currentModel->data(index, Qt::DisplayRole).isValid(), true);

            // If the next test fails here is some somewhat usefull debug you play with.

            /*

            if (currentModel->parent(index) != parent) {

                qDebug() << r << c << currentDepth << currentModel->data(index).toString()

                         << currentModel->data(parent).toString();

                qDebug() << index << parent << currentModel->parent(index);

                QTreeView view;

                view.setModel(currentModel);

                view.show();

                QTest::qWait(9000);

            }*/

            QCOMPARE(currentModel->parent(index), parent);

            // recursivly go down

            if (currentModel->hasChildren(index) && currentDepth < 5) {

                //qDebug() << r << c << "has children" << currentModel->rowCount(index);

                checkChildren(currentModel, index, ++currentDepth);

                // Because this is recursive we will return at the first failure rather then

                // reporting it over and over

                if (QTest::currentTestFailed())

                    return;

            }

            // make sure that after testing the children that the index pointer doesn't change.

            QModelIndex newerIndex = currentModel->index(r, c, parent);

            QCOMPARE(index, newerIndex);

        }

    }

}

/*!

    Tests model's implimentation of QAbstractItemModel::parent()

 */

void tst_QItemModel::parent()

{

    QFETCH(QString, modelType);

    currentModel = testModels->createModel(modelType);

    // Make sure the model wont crash and will return an invalid QModelIndex

    // when asked for the parent of an invalid index.

    QCOMPARE(currentModel->parent(QModelIndex()), QModelIndex());

    QFETCH(bool, isEmpty);

    if (isEmpty)

        return;

    // Common error test #1, make sure that a top level index has a parent

    // that is a invalid QModelIndex.  You model

    QModelIndex topIndex = currentModel->index(0, 0, QModelIndex());

    QCOMPARE(currentModel->parent(topIndex), QModelIndex());

    // Common error test #2, make sure that a second level index has a parent

    // that is the top level index.

    if (currentModel->rowCount(topIndex) > 0) {

        QModelIndex childIndex = currentModel->index(0, 0, topIndex);

        QCOMPARE(currentModel->parent(childIndex), topIndex);

    }

    // Common error test #3, the second colum has the same children

    // as the first column in a row.

    QModelIndex topIndex1 = currentModel->index(0, 1, QModelIndex());

    if (currentModel->rowCount(topIndex1) > 0) {

        QModelIndex childIndex = currentModel->index(0, 0, topIndex);

        QModelIndex childIndex1 = currentModel->index(0, 0, topIndex1);

        QVERIFY(childIndex != childIndex1);

    }

    // Full test, walk 10 levels deap through the model making sure that all

    // parents's children correctly specify their parent

    QModelIndex top = QModelIndex();

    checkChildren(currentModel, top);

}