modeltest.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2007 Trolltech ASA. All rights reserved.
**
** This file is part of the Qt Concurrent project on Trolltech Labs.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
 
#include "modeltest.h"
 
#include <QtGui/QtGui>
 
Q_DECLARE_METATYPE(QModelIndex)
 
 
ModelTest::ModelTest(QAbstractItemModel* _model, QObject* parent)
    : QObject(parent), model(_model), fetchingMore(false)
{
    Q_ASSERT(model);
 
    connect(model,
            SIGNAL(columnsAboutToBeInserted(const QModelIndex&, int, int)),
            this, SLOT(runAllTests()));
    connect(model,
            SIGNAL(columnsAboutToBeRemoved(const QModelIndex&, int, int)), this,
            SLOT(runAllTests()));
    connect(model, SIGNAL(columnsInserted(const QModelIndex&, int, int)), this,
            SLOT(runAllTests()));
    connect(model, SIGNAL(columnsRemoved(const QModelIndex&, int, int)), this,
            SLOT(runAllTests()));
    connect(model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
            this, SLOT(runAllTests()));
    connect(model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)), this,
            SLOT(runAllTests()));
    connect(model, SIGNAL(layoutAboutToBeChanged()), this, SLOT(runAllTests()));
    connect(model, SIGNAL(layoutChanged()), this, SLOT(runAllTests()));
    connect(model, SIGNAL(modelReset()), this, SLOT(runAllTests()));
    connect(model, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)),
            this, SLOT(runAllTests()));
    connect(model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)),
            this, SLOT(runAllTests()));
    connect(model, SIGNAL(rowsInserted(const QModelIndex&, int, int)), this,
            SLOT(runAllTests()));
    connect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), this,
            SLOT(runAllTests()));
 
    // Special checks for inserting/removing
    connect(model, SIGNAL(layoutAboutToBeChanged()), this,
            SLOT(layoutAboutToBeChanged()));
    connect(model, SIGNAL(layoutChanged()), this, SLOT(layoutChanged()));
 
    connect(model, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)),
            this, SLOT(rowsAboutToBeInserted(const QModelIndex&, int, int)));
    connect(model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)),
            this, SLOT(rowsAboutToBeRemoved(const QModelIndex&, int, int)));
    connect(model, SIGNAL(rowsInserted(const QModelIndex&, int, int)), this,
            SLOT(rowsInserted(const QModelIndex&, int, int)));
    connect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), this,
            SLOT(rowsRemoved(const QModelIndex&, int, int)));
 
    runAllTests();
}
 
void ModelTest::runAllTests()
{
    if (fetchingMore)
        return;
    nonDestructiveBasicTest();
    rowCount();
    columnCount();
    hasIndex();
    index();
    parent();
    data();
}
 
void ModelTest::nonDestructiveBasicTest()
{
    Q_ASSERT(model->buddy(QModelIndex()) == QModelIndex());
    model->canFetchMore(QModelIndex());
    Q_ASSERT(model->columnCount(QModelIndex()) >= 0);
    Q_ASSERT(model->data(QModelIndex()) == QVariant());
    fetchingMore = true;
    model->fetchMore(QModelIndex());
    fetchingMore = false;
    Qt::ItemFlags flags = model->flags(QModelIndex());
    Q_ASSERT(flags == Qt::ItemIsDropEnabled || flags == 0);
    model->hasChildren(QModelIndex());
    model->hasIndex(0, 0);
    model->headerData(0, Qt::Horizontal);
    model->index(0, 0);
    Q_ASSERT(model->index(-1, -1) == QModelIndex());
    model->itemData(QModelIndex());
    QVariant cache;
    model->match(QModelIndex(), -1, cache);
    model->mimeTypes();
    Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
    Q_ASSERT(model->rowCount() >= 0);
    QVariant variant;
    model->setData(QModelIndex(), variant, -1);
    model->setHeaderData(-1, Qt::Horizontal, QVariant());
    model->setHeaderData(0, Qt::Horizontal, QVariant());
    model->setHeaderData(999999, Qt::Horizontal, QVariant());
    QMap<int, QVariant> roles;
    model->sibling(0, 0, QModelIndex());
    model->span(QModelIndex());
    model->supportedDropActions();
}
 
void ModelTest::rowCount()
{
    // check top row
    QModelIndex topIndex = model->index(0, 0, QModelIndex());
    int rows = model->rowCount(topIndex);
    Q_ASSERT(rows >= 0);
    if (rows > 0)
        Q_ASSERT(model->hasChildren(topIndex) == true);
 
    QModelIndex secondLevelIndex = model->index(0, 0, topIndex);
    if (secondLevelIndex.isValid())  // not the top level
    {                                // check a row count where parent is valid
        rows = model->rowCount(secondLevelIndex);
        Q_ASSERT(rows >= 0);
        if (rows > 0)
            Q_ASSERT(model->hasChildren(secondLevelIndex) == true);
    }
 
    // The models rowCount() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}
 
void ModelTest::columnCount()
{
    // check top row
    QModelIndex topIndex = model->index(0, 0, QModelIndex());
    Q_ASSERT(model->columnCount(topIndex) >= 0);
 
    // check a column count where parent is valid
    QModelIndex childIndex = model->index(0, 0, topIndex);
    if (childIndex.isValid())
        Q_ASSERT(model->columnCount(childIndex) >= 0);
 
    // columnCount() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}
 
void ModelTest::hasIndex()
{
    // Make sure that invalid values returns an invalid index
    Q_ASSERT(model->hasIndex(-2, -2) == false);
    Q_ASSERT(model->hasIndex(-2, 0) == false);
    Q_ASSERT(model->hasIndex(0, -2) == false);
 
    int rows = model->rowCount();
    int columns = model->columnCount();
 
    // check out of bounds
    Q_ASSERT(model->hasIndex(rows, columns) == false);
    Q_ASSERT(model->hasIndex(rows + 1, columns + 1) == false);
 
    if (rows > 0)
        Q_ASSERT(model->hasIndex(0, 0) == true);
 
    // hasIndex() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}
 
void ModelTest::index()
{
    // Make sure that invalid values returns an invalid index
    Q_ASSERT(model->index(-2, -2) == QModelIndex());
    Q_ASSERT(model->index(-2, 0) == QModelIndex());
    Q_ASSERT(model->index(0, -2) == QModelIndex());
 
    int rows = model->rowCount();
    int columns = model->columnCount();
 
    if (rows == 0)
        return;
 
    // Catch off by one errors
    Q_ASSERT(model->index(rows, columns) == QModelIndex());
    Q_ASSERT(model->index(0, 0).isValid() == true);
 
    // Make sure that the same index is *always* returned
    QModelIndex a = model->index(0, 0);
    QModelIndex b = model->index(0, 0);
    Q_ASSERT(a == b);
 
    // index() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}
 
void ModelTest::parent()
{
    // Make sure the model won't crash and will return an invalid QModelIndex
    // when asked for the parent of an invalid index.
    Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
 
    if (model->rowCount() == 0)
        return;
 
    // Column 0                | Column 1    |
    // QModelIndex()           |             |
    //    \- topIndex          | topIndex1   |
    //         \- childIndex   | childIndex1 |
 
    // Common error test #1, make sure that a top level index has a parent
    // that is a invalid QModelIndex.
    QModelIndex topIndex = model->index(0, 0, QModelIndex());
    Q_ASSERT(model->parent(topIndex) == QModelIndex());
 
    // Common error test #2, make sure that a second level index has a parent
    // that is the first level index.
    if (model->rowCount(topIndex) > 0)
    {
        QModelIndex childIndex = model->index(0, 0, topIndex);
        Q_ASSERT(model->parent(childIndex) == topIndex);
    }
 
    // Common error test #3, the second column should NOT have the same children
    // as the first column in a row.
    // Usually the second column shouldn't have children.
    QModelIndex topIndex1 = model->index(0, 1, QModelIndex());
    if (model->rowCount(topIndex1) > 0)
    {
        QModelIndex childIndex = model->index(0, 0, topIndex);
        QModelIndex childIndex1 = model->index(0, 0, topIndex1);
        Q_ASSERT(childIndex != childIndex1);
    }
 
    // Full test, walk n levels deep through the model making sure that all
    // parent's children correctly specify their parent.
    checkChildren(QModelIndex());
}
 
void ModelTest::checkChildren(const QModelIndex& parent, int currentDepth)
{
    // First just try walking back up the tree.
    QModelIndex p = parent;
    while (p.isValid())
        p = p.parent();
 
    // For models that are dynamically populated
    if (model->canFetchMore(parent))
    {
        fetchingMore = true;
        model->fetchMore(parent);
        fetchingMore = false;
    }
 
    int rows = model->rowCount(parent);
    int columns = model->columnCount(parent);
 
    if (rows > 0)
        Q_ASSERT(model->hasChildren(parent));
 
    // Some further testing against rows(), columns(), and hasChildren()
    Q_ASSERT(rows >= 0);
    Q_ASSERT(columns >= 0);
    if (rows > 0)
        Q_ASSERT(model->hasChildren(parent) == true);
 
    // qDebug() << "parent:" << model->data(parent).toString() << "rows:" <<
    // rows
    //         << "columns:" << columns << "parent column:" << parent.column();
 
    Q_ASSERT(model->hasIndex(rows + 1, 0, parent) == false);
    for (int r = 0; r < rows; ++r)
    {
        if (model->canFetchMore(parent))
        {
            fetchingMore = true;
            model->fetchMore(parent);
            fetchingMore = false;
        }
        Q_ASSERT(model->hasIndex(r, columns + 1, parent) == false);
        for (int c = 0; c < columns; ++c)
        {
            Q_ASSERT(model->hasIndex(r, c, parent) == true);
            QModelIndex index = model->index(r, c, parent);
            // rowCount() and columnCount() said that it existed...
            Q_ASSERT(index.isValid() == true);
 
            // index() should always return the same index when called twice in
            // a row
            QModelIndex modifiedIndex = model->index(r, c, parent);
            Q_ASSERT(index == modifiedIndex);
 
            // Make sure we get the same index if we request it twice in a row
            QModelIndex a = model->index(r, c, parent);
            QModelIndex b = model->index(r, c, parent);
            Q_ASSERT(a == b);
 
            // Some basic checking on the index that is returned
            Q_ASSERT(index.model() == model);
            Q_ASSERT(index.row() == r);
            Q_ASSERT(index.column() == c);
            // While you can technically return a QVariant usually this is a
            // sign of an bug in data()  Disable if this really is ok in your
            // model.
            // Q_ASSERT(model->data(index, Qt::DisplayRole).isValid() == true);
 
            // If the next test fails here is some somewhat useful debug you
            // play with.
            /*
               if (model->parent(index) != parent) {
                qDebug() << r << c << currentDepth <<
               model->data(index).toString()
                         << model->data(parent).toString();
                qDebug() << index << parent << model->parent(index);
                // And a view that you can even use to show the model.
                //QTreeView view;
                //view.setModel(model);
                //view.show();
               }*/
 
            // Check that we can get back our real parent.
            QModelIndex p = model->parent(index);
            // qDebug() << "child:" << index;
            // qDebug() << p;
            // qDebug() << parent;
            Q_ASSERT(model->parent(index) == parent);
 
            // recursively go down the children
            if (model->hasChildren(index) && currentDepth < 10)
                // qDebug() << r << c << "has children" <<
                // model->rowCount(index);
                checkChildren(index, ++currentDepth);
            /* else { if (currentDepth >= 10) qDebug() << "checked 10 deep";
             * };*/
 
            // make sure that after testing the children that the index doesn't
            // change.
            QModelIndex newerIndex = model->index(r, c, parent);
            Q_ASSERT(index == newerIndex);
        }
    }
}
 
void ModelTest::data()
{
    // Invalid index should return an invalid qvariant
    Q_ASSERT(!model->data(QModelIndex()).isValid());
 
    if (model->rowCount() == 0)
        return;
 
    // A valid index should have a valid QVariant data
    Q_ASSERT(model->index(0, 0).isValid());
 
    // shouldn't be able to set data on an invalid index
    Q_ASSERT(model->setData(QModelIndex(), QLatin1String("foo"),
                            Qt::DisplayRole) == false);
 
    // General Purpose roles that should return a QString
    QVariant variant = model->data(model->index(0, 0), Qt::ToolTipRole);
    if (variant.isValid())
        Q_ASSERT(variant.canConvert(QMetaType::QString)));
    variant = model->data(model->index(0, 0), Qt::StatusTipRole);
    if (variant.isValid())
        Q_ASSERT(variant.canConvert(QMetaType::QString)));
    variant = model->data(model->index(0, 0), Qt::WhatsThisRole);
    if (variant.isValid())
        Q_ASSERT(variant.canConvert(QMetaType::QString)));
 
    // General Purpose roles that should return a QSize
    variant = model->data(model->index(0, 0), Qt::SizeHintRole);
    if (variant.isValid())
        Q_ASSERT(variant.canConvert(QMetaType::QString)));
 
    // General Purpose roles that should return a QFont
    QVariant fontVariant = model->data(model->index(0, 0), Qt::FontRole);
    if (fontVariant.isValid())
        Q_ASSERT(fontVariant.canConvert(QMetaType::QFont)));
 
    // Check that the alignment is one we know about
    QVariant textAlignmentVariant =
        model->data(model->index(0, 0), Qt::TextAlignmentRole);
    if (textAlignmentVariant.isValid())
    {
        int alignment = textAlignmentVariant.toInt();
        Q_ASSERT(
            alignment == Qt::AlignLeft || alignment == Qt::AlignRight ||
            alignment == Qt::AlignHCenter || alignment == Qt::AlignJustify ||
            alignment == Qt::AlignTop || alignment == Qt::AlignBottom ||
            alignment == Qt::AlignVCenter || alignment == Qt::AlignCenter ||
            alignment == Qt::AlignAbsolute || alignment == Qt::AlignLeading ||
            alignment == Qt::AlignTrailing);
    }
 
    // General Purpose roles that should return a QColor
    QVariant colorVariant =
        model->data(model->index(0, 0), Qt::BackgroundColorRole);
    if (colorVariant.isValid())
        Q_ASSERT(colorVariant.canConvert(QMetaType::QColor)));
 
    colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);
    if (colorVariant.isValid())
        Q_ASSERT(colorVariant.canConvert(QMetaType::QColor)));
 
    // Check that the "check state" is one we know about.
    QVariant checkStateVariant =
        model->data(model->index(0, 0), Qt::CheckStateRole);
    if (checkStateVariant.isValid())
    {
        int state = checkStateVariant.toInt();
        Q_ASSERT(state == Qt::Unchecked || state == Qt::PartiallyChecked ||
                 state == Qt::Checked);
    }
}
 
void ModelTest::rowsAboutToBeInserted(const QModelIndex& parent, int start,
                                      int end)
{
    Q_UNUSED(end);
    Changing c;
    c.parent = parent;
    c.oldSize = model->rowCount(parent);
    c.last = model->data(model->index(start - 1, 0, parent));
    c.next = model->data(model->index(start, 0, parent));
    insert.push(c);
}
 
void ModelTest::rowsInserted(const QModelIndex& parent, int start, int end)
{
    Changing c = insert.pop();
    Q_ASSERT(c.parent == parent);
    Q_ASSERT(c.oldSize + (end - start + 1) == model->rowCount(parent));
    Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
    /*
       if (c.next != model->data(model->index(end + 1, 0, c.parent))) {
        qDebug() << start << end;
        for (int i=0; i < model->rowCount(); ++i)
            qDebug() << model->index(i, 0).data().toString();
        qDebug() << c.next << model->data(model->index(end + 1, 0, c.parent));
       }
     */
    Q_ASSERT(c.next == model->data(model->index(end + 1, 0, c.parent)));
}
 
void ModelTest::layoutAboutToBeChanged()
{
    for (int i = 0; i < qBound(0, model->rowCount(), 100); ++i)
        changing.append(QPersistentModelIndex(model->index(i, 0)));
}
 
void ModelTest::layoutChanged()
{
    for (int i = 0; i < changing.count(); ++i)
    {
        QPersistentModelIndex p = changing[i];
        Q_ASSERT(p == model->index(p.row(), p.column(), p.parent()));
    }
    changing.clear();
}
 
void ModelTest::rowsAboutToBeRemoved(const QModelIndex& parent, int start,
                                     int end)
{
    Changing c;
    c.parent = parent;
    c.oldSize = model->rowCount(parent);
    c.last = model->data(model->index(start - 1, 0, parent));
    c.next = model->data(model->index(end + 1, 0, parent));
    remove.push(c);
}
 
void ModelTest::rowsRemoved(const QModelIndex& parent, int start, int end)
{
    Changing c = remove.pop();
    Q_ASSERT(c.parent == parent);
    Q_ASSERT(c.oldSize - (end - start + 1) == model->rowCount(parent));
    Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
    Q_ASSERT(c.next == model->data(model->index(start, 0, c.parent)));
}