summaryrefslogtreecommitdiffstats
path: root/tests/auto/modeltest
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/modeltest')
-rw-r--r--tests/auto/modeltest/dynamictreemodel.cpp336
-rw-r--r--tests/auto/modeltest/dynamictreemodel.h197
-rw-r--r--tests/auto/modeltest/modeltest.cpp566
-rw-r--r--tests/auto/modeltest/modeltest.h94
-rw-r--r--tests/auto/modeltest/modeltest.pro6
-rw-r--r--tests/auto/modeltest/tst_modeltest.cpp309
6 files changed, 1508 insertions, 0 deletions
diff --git a/tests/auto/modeltest/dynamictreemodel.cpp b/tests/auto/modeltest/dynamictreemodel.cpp
new file mode 100644
index 0000000000..fa634b6a5f
--- /dev/null
+++ b/tests/auto/modeltest/dynamictreemodel.cpp
@@ -0,0 +1,336 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Stephen Kelly <steveire@gmail.com>
+** 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 "dynamictreemodel.h"
+
+#include <QtCore/QHash>
+#include <QtCore/QList>
+#include <QtCore/QTimer>
+
+
+DynamicTreeModel::DynamicTreeModel(QObject *parent)
+ : QAbstractItemModel(parent),
+ nextId(1)
+{
+}
+
+QModelIndex DynamicTreeModel::index(int row, int column, const QModelIndex &parent) const
+{
+// if (column != 0)
+// return QModelIndex();
+
+
+ if ( column < 0 || row < 0 )
+ return QModelIndex();
+
+ QList<QList<qint64> > childIdColumns = m_childItems.value(parent.internalId());
+
+ const qint64 grandParent = findParentId(parent.internalId());
+ if (grandParent >= 0) {
+ QList<QList<qint64> > parentTable = m_childItems.value(grandParent);
+ Q_ASSERT(parent.column() < parentTable.size());
+ QList<qint64> parentSiblings = parentTable.at(parent.column());
+ Q_ASSERT(parent.row() < parentSiblings.size());
+ }
+
+ if (childIdColumns.size() == 0)
+ return QModelIndex();
+
+ if (column >= childIdColumns.size())
+ return QModelIndex();
+
+ QList<qint64> rowIds = childIdColumns.at(column);
+
+ if ( row >= rowIds.size())
+ return QModelIndex();
+
+ qint64 id = rowIds.at(row);
+
+ return createIndex(row, column, reinterpret_cast<void *>(id));
+
+}
+
+qint64 DynamicTreeModel::findParentId(qint64 searchId) const
+{
+ if (searchId <= 0)
+ return -1;
+
+ QHashIterator<qint64, QList<QList<qint64> > > i(m_childItems);
+ while (i.hasNext())
+ {
+ i.next();
+ QListIterator<QList<qint64> > j(i.value());
+ while (j.hasNext())
+ {
+ QList<qint64> l = j.next();
+ if (l.contains(searchId))
+ {
+ return i.key();
+ }
+ }
+ }
+ return -1;
+}
+
+QModelIndex DynamicTreeModel::parent(const QModelIndex &index) const
+{
+ if (!index.isValid())
+ return QModelIndex();
+
+ qint64 searchId = index.internalId();
+ qint64 parentId = findParentId(searchId);
+ // Will never happen for valid index, but what the hey...
+ if (parentId <= 0)
+ return QModelIndex();
+
+ qint64 grandParentId = findParentId(parentId);
+ if (grandParentId < 0)
+ grandParentId = 0;
+
+ int column = 0;
+ QList<qint64> childList = m_childItems.value(grandParentId).at(column);
+
+ int row = childList.indexOf(parentId);
+
+ return createIndex(row, column, reinterpret_cast<void *>(parentId));
+
+}
+
+int DynamicTreeModel::rowCount(const QModelIndex &index ) const
+{
+ QList<QList<qint64> > cols = m_childItems.value(index.internalId());
+
+ if (cols.size() == 0 )
+ return 0;
+
+ if (index.column() > 0)
+ return 0;
+
+ return cols.at(0).size();
+}
+
+int DynamicTreeModel::columnCount(const QModelIndex &index ) const
+{
+// Q_UNUSED(index);
+ return m_childItems.value(index.internalId()).size();
+}
+
+QVariant DynamicTreeModel::data(const QModelIndex &index, int role) const
+{
+ if (!index.isValid())
+ return QVariant();
+
+ if (Qt::DisplayRole == role)
+ {
+ return m_items.value(index.internalId());
+ }
+ return QVariant();
+}
+
+void DynamicTreeModel::clear()
+{
+ beginResetModel();
+ m_items.clear();
+ m_childItems.clear();
+ nextId = 1;
+ endResetModel();
+}
+
+
+ModelChangeCommand::ModelChangeCommand( DynamicTreeModel *model, QObject *parent )
+ : QObject(parent), m_model(model), m_numCols(1), m_startRow(-1), m_endRow(-1)
+{
+
+}
+
+QModelIndex ModelChangeCommand::findIndex(QList<int> rows)
+{
+ const int col = 0;
+ QModelIndex parent = QModelIndex();
+ QListIterator<int> i(rows);
+ while (i.hasNext())
+ {
+ parent = m_model->index(i.next(), col, parent);
+ Q_ASSERT(parent.isValid());
+ }
+ return parent;
+}
+
+ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent )
+ : ModelChangeCommand(model, parent)
+{
+
+}
+
+void ModelInsertCommand::doCommand()
+{
+ QModelIndex parent = findIndex(m_rowNumbers);
+ m_model->beginInsertRows(parent, m_startRow, m_endRow);
+ qint64 parentId = parent.internalId();
+ for (int row = m_startRow; row <= m_endRow; row++)
+ {
+ for(int col = 0; col < m_numCols; col++ )
+ {
+ if (m_model->m_childItems[parentId].size() <= col)
+ {
+ m_model->m_childItems[parentId].append(QList<qint64>());
+ }
+// QString name = QUuid::createUuid().toString();
+ qint64 id = m_model->newId();
+ QString name = QString::number(id);
+
+ m_model->m_items.insert(id, name);
+ m_model->m_childItems[parentId][col].insert(row, id);
+
+ }
+ }
+ m_model->endInsertRows();
+}
+
+
+ModelMoveCommand::ModelMoveCommand(DynamicTreeModel *model, QObject *parent)
+ : ModelChangeCommand(model, parent)
+{
+
+}
+bool ModelMoveCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
+{
+ return m_model->beginMoveRows(srcParent, srcStart, srcEnd, destParent, destRow);
+}
+
+void ModelMoveCommand::doCommand()
+{
+ QModelIndex srcParent = findIndex(m_rowNumbers);
+ QModelIndex destParent = findIndex(m_destRowNumbers);
+
+ if (!emitPreSignal(srcParent, m_startRow, m_endRow, destParent, m_destRow))
+ {
+ return;
+ }
+
+ for (int column = 0; column < m_numCols; ++column)
+ {
+ QList<qint64> l = m_model->m_childItems.value(srcParent.internalId())[column].mid(m_startRow, m_endRow - m_startRow + 1 );
+
+ for (int i = m_startRow; i <= m_endRow ; i++)
+ {
+ m_model->m_childItems[srcParent.internalId()][column].removeAt(m_startRow);
+ }
+ int d;
+ if (m_destRow < m_startRow)
+ d = m_destRow;
+ else
+ {
+ if (srcParent == destParent)
+ d = m_destRow - (m_endRow - m_startRow + 1);
+ else
+ d = m_destRow - (m_endRow - m_startRow) + 1;
+ }
+
+ foreach(const qint64 id, l)
+ {
+ m_model->m_childItems[destParent.internalId()][column].insert(d++, id);
+ }
+ }
+
+ emitPostSignal();
+}
+
+void ModelMoveCommand::emitPostSignal()
+{
+ m_model->endMoveRows();
+}
+
+ModelResetCommand::ModelResetCommand(DynamicTreeModel* model, QObject* parent)
+ : ModelMoveCommand(model, parent)
+{
+
+}
+
+ModelResetCommand::~ModelResetCommand()
+{
+
+}
+
+bool ModelResetCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
+{
+ Q_UNUSED(srcParent);
+ Q_UNUSED(srcStart);
+ Q_UNUSED(srcEnd);
+ Q_UNUSED(destParent);
+ Q_UNUSED(destRow);
+
+ return true;
+}
+
+void ModelResetCommand::emitPostSignal()
+{
+ m_model->reset();
+}
+
+ModelResetCommandFixed::ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent)
+ : ModelMoveCommand(model, parent)
+{
+
+}
+
+ModelResetCommandFixed::~ModelResetCommandFixed()
+{
+
+}
+
+bool ModelResetCommandFixed::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
+{
+ Q_UNUSED(srcParent);
+ Q_UNUSED(srcStart);
+ Q_UNUSED(srcEnd);
+ Q_UNUSED(destParent);
+ Q_UNUSED(destRow);
+
+ m_model->beginResetModel();
+ return true;
+}
+
+void ModelResetCommandFixed::emitPostSignal()
+{
+ m_model->endResetModel();
+}
+
diff --git a/tests/auto/modeltest/dynamictreemodel.h b/tests/auto/modeltest/dynamictreemodel.h
new file mode 100644
index 0000000000..9633755456
--- /dev/null
+++ b/tests/auto/modeltest/dynamictreemodel.h
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Stephen Kelly <steveire@gmail.com>
+** 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$
+**
+****************************************************************************/
+
+#ifndef DYNAMICTREEMODEL_H
+#define DYNAMICTREEMODEL_H
+
+#include <QtCore/QAbstractItemModel>
+
+#include <QtCore/QHash>
+#include <QtCore/QList>
+
+
+class DynamicTreeModel : public QAbstractItemModel
+{
+ Q_OBJECT
+
+public:
+ DynamicTreeModel(QObject *parent = 0);
+
+ QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+ QModelIndex parent(const QModelIndex &index) const;
+ int rowCount(const QModelIndex &index = QModelIndex()) const;
+ int columnCount(const QModelIndex &index = QModelIndex()) const;
+
+ QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+ void clear();
+
+protected slots:
+
+ /**
+ Finds the parent id of the string with id @p searchId.
+
+ Returns -1 if not found.
+ */
+ qint64 findParentId(qint64 searchId) const;
+
+private:
+ QHash<qint64, QString> m_items;
+ QHash<qint64, QList<QList<qint64> > > m_childItems;
+ qint64 nextId;
+ qint64 newId() { return nextId++; };
+
+ QModelIndex m_nextParentIndex;
+ int m_nextRow;
+
+ int m_depth;
+ int maxDepth;
+
+ friend class ModelInsertCommand;
+ friend class ModelMoveCommand;
+ friend class ModelResetCommand;
+ friend class ModelResetCommandFixed;
+
+};
+
+
+class ModelChangeCommand : public QObject
+{
+ Q_OBJECT
+public:
+
+ ModelChangeCommand( DynamicTreeModel *model, QObject *parent = 0 );
+
+ virtual ~ModelChangeCommand() {}
+
+ void setAncestorRowNumbers(QList<int> rowNumbers) { m_rowNumbers = rowNumbers; }
+
+ QModelIndex findIndex(QList<int> rows);
+
+ void setStartRow(int row) { m_startRow = row; }
+
+ void setEndRow(int row) { m_endRow = row; }
+
+ void setNumCols(int cols) { m_numCols = cols; }
+
+ virtual void doCommand() = 0;
+
+protected:
+ DynamicTreeModel* m_model;
+ QList<int> m_rowNumbers;
+ int m_numCols;
+ int m_startRow;
+ int m_endRow;
+
+};
+
+typedef QList<ModelChangeCommand*> ModelChangeCommandList;
+
+class ModelInsertCommand : public ModelChangeCommand
+{
+ Q_OBJECT
+
+public:
+
+ ModelInsertCommand(DynamicTreeModel *model, QObject *parent = 0 );
+ virtual ~ModelInsertCommand() {}
+
+ virtual void doCommand();
+};
+
+
+class ModelMoveCommand : public ModelChangeCommand
+{
+ Q_OBJECT
+public:
+ ModelMoveCommand(DynamicTreeModel *model, QObject *parent);
+
+ virtual ~ModelMoveCommand() {}
+
+ virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
+
+ virtual void doCommand();
+
+ virtual void emitPostSignal();
+
+ void setDestAncestors( QList<int> rows ) { m_destRowNumbers = rows; }
+
+ void setDestRow(int row) { m_destRow = row; }
+
+protected:
+ QList<int> m_destRowNumbers;
+ int m_destRow;
+};
+
+/**
+ A command which does a move and emits a reset signal.
+*/
+class ModelResetCommand : public ModelMoveCommand
+{
+ Q_OBJECT
+public:
+ ModelResetCommand(DynamicTreeModel* model, QObject* parent = 0);
+
+ virtual ~ModelResetCommand();
+
+ virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
+ virtual void emitPostSignal();
+
+};
+
+/**
+ A command which does a move and emits a beginResetModel and endResetModel signals.
+*/
+class ModelResetCommandFixed : public ModelMoveCommand
+{
+ Q_OBJECT
+public:
+ ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent = 0);
+
+ virtual ~ModelResetCommandFixed();
+
+ virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
+ virtual void emitPostSignal();
+
+};
+
+
+#endif
diff --git a/tests/auto/modeltest/modeltest.cpp b/tests/auto/modeltest/modeltest.cpp
new file mode 100644
index 0000000000..98d707c8da
--- /dev/null
+++ b/tests/auto/modeltest/modeltest.cpp
@@ -0,0 +1,566 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 <QtGui/QtGui>
+
+#include "modeltest.h"
+
+#include <QtTest/QtTest>
+#undef Q_ASSERT
+#define Q_ASSERT QVERIFY
+
+Q_DECLARE_METATYPE ( QModelIndex )
+
+/*!
+ Connect to all of the models signals. Whenever anything happens recheck everything.
+*/
+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();
+}
+
+/*!
+ nonDestructiveBasicTest tries to call a number of the basic functions (not all)
+ to make sure the model doesn't outright segfault, testing the functions that makes sense.
+*/
+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 );
+ 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 ( 999999, Qt::Horizontal, QVariant() );
+ QMap<int, QVariant> roles;
+ model->sibling ( 0, 0, QModelIndex() );
+ model->span ( QModelIndex() );
+ model->supportedDropActions();
+}
+
+/*!
+ Tests model's implementation of QAbstractItemModel::rowCount() and hasChildren()
+
+ Models that are dynamically populated are not as fully tested here.
+ */
+void ModelTest::rowCount()
+{
+// qDebug() << "rc";
+ // 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
+}
+
+/*!
+ Tests model's implementation of QAbstractItemModel::columnCount() and hasChildren()
+ */
+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
+}
+
+/*!
+ Tests model's implementation of QAbstractItemModel::hasIndex()
+ */
+void ModelTest::hasIndex()
+{
+// qDebug() << "hi";
+ // 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
+}
+
+/*!
+ Tests model's implementation of QAbstractItemModel::index()
+ */
+void ModelTest::index()
+{
+// qDebug() << "i";
+ // 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
+}
+
+/*!
+ Tests model's implementation of QAbstractItemModel::parent()
+ */
+void ModelTest::parent()
+{
+// qDebug() << "p";
+ // Make sure the model wont 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() );
+}
+
+/*!
+ Called from the parent() test.
+
+ 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() already 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 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.
+// qDebug() << model->parent ( index ) << 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 );
+ }
+ }
+}
+
+/*!
+ Tests model's implementation of QAbstractItemModel::data()
+ */
+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 ( qVariantCanConvert<QString> ( variant ) );
+ }
+ variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );
+ if ( variant.isValid() ) {
+ Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
+ }
+ variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );
+ if ( variant.isValid() ) {
+ Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
+ }
+
+ // General Purpose roles that should return a QSize
+ variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );
+ if ( variant.isValid() ) {
+ Q_ASSERT ( qVariantCanConvert<QSize> ( variant ) );
+ }
+
+ // General Purpose roles that should return a QFont
+ QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole );
+ if ( fontVariant.isValid() ) {
+ Q_ASSERT ( qVariantCanConvert<QFont> ( fontVariant ) );
+ }
+
+ // 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 == ( alignment & ( Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask ) ) );
+ }
+
+ // General Purpose roles that should return a QColor
+ QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole );
+ if ( colorVariant.isValid() ) {
+ Q_ASSERT ( qVariantCanConvert<QColor> ( colorVariant ) );
+ }
+
+ colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );
+ if ( colorVariant.isValid() ) {
+ Q_ASSERT ( qVariantCanConvert<QColor> ( colorVariant ) );
+ }
+
+ // 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 );
+ }
+}
+
+/*!
+ Store what is about to be inserted to make sure it actually happens
+
+ \sa rowsInserted()
+ */
+void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, int end )
+{
+// Q_UNUSED(end);
+// qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).toString()
+// << "current count of parent=" << model->rowCount ( parent ); // << "display of last=" << model->data( model->index(start-1, 0, parent) );
+// qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );
+ 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 );
+}
+
+/*!
+ Confirm that what was said was going to happen actually did
+
+ \sa rowsAboutToBeInserted()
+ */
+void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
+{
+ Changing c = insert.pop();
+ Q_ASSERT ( c.parent == parent );
+// qDebug() << "rowsInserted" << "start=" << start << "end=" << end << "oldsize=" << c.oldSize
+// << "parent=" << model->data ( parent ).toString() << "current rowcount of parent=" << model->rowCount ( parent );
+
+// for (int ii=start; ii <= end; ii++)
+// {
+// qDebug() << "itemWasInserted:" << ii << model->data ( model->index ( ii, 0, parent ));
+// }
+// qDebug();
+
+ 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();
+}
+
+/*!
+ Store what is about to be inserted to make sure it actually happens
+
+ \sa rowsRemoved()
+ */
+void ModelTest::rowsAboutToBeRemoved ( const QModelIndex &parent, int start, int end )
+{
+qDebug() << "ratbr" << parent << start << 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 );
+}
+
+/*!
+ Confirm that what was said was going to happen actually did
+
+ \sa rowsAboutToBeRemoved()
+ */
+void ModelTest::rowsRemoved ( const QModelIndex & parent, int start, int end )
+{
+ qDebug() << "rr" << parent << start << 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 ) ) );
+}
+
+
diff --git a/tests/auto/modeltest/modeltest.h b/tests/auto/modeltest/modeltest.h
new file mode 100644
index 0000000000..52b45d9d8d
--- /dev/null
+++ b/tests/auto/modeltest/modeltest.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+
+#ifndef MODELTEST_H
+#define MODELTEST_H
+
+#include <QtCore/QObject>
+#include <QtCore/QAbstractItemModel>
+#include <QtCore/QStack>
+
+class ModelTest : public QObject
+{
+ Q_OBJECT
+
+public:
+ ModelTest( QAbstractItemModel *model, QObject *parent = 0 );
+
+private Q_SLOTS:
+ void nonDestructiveBasicTest();
+ void rowCount();
+ void columnCount();
+ void hasIndex();
+ void index();
+ void parent();
+ void data();
+
+protected Q_SLOTS:
+ void runAllTests();
+ void layoutAboutToBeChanged();
+ void layoutChanged();
+ void rowsAboutToBeInserted( const QModelIndex &parent, int start, int end );
+ void rowsInserted( const QModelIndex & parent, int start, int end );
+ void rowsAboutToBeRemoved( const QModelIndex &parent, int start, int end );
+ void rowsRemoved( const QModelIndex & parent, int start, int end );
+
+private:
+ void checkChildren( const QModelIndex &parent, int currentDepth = 0 );
+
+ QAbstractItemModel *model;
+
+ struct Changing {
+ QModelIndex parent;
+ int oldSize;
+ QVariant last;
+ QVariant next;
+ };
+ QStack<Changing> insert;
+ QStack<Changing> remove;
+
+ bool fetchingMore;
+
+ QList<QPersistentModelIndex> changing;
+};
+
+#endif
diff --git a/tests/auto/modeltest/modeltest.pro b/tests/auto/modeltest/modeltest.pro
new file mode 100644
index 0000000000..f157da0cee
--- /dev/null
+++ b/tests/auto/modeltest/modeltest.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+SOURCES += tst_modeltest.cpp modeltest.cpp dynamictreemodel.cpp
+HEADERS += modeltest.h dynamictreemodel.h
+
+
+
diff --git a/tests/auto/modeltest/tst_modeltest.cpp b/tests/auto/modeltest/tst_modeltest.cpp
new file mode 100644
index 0000000000..a75fe5b3c0
--- /dev/null
+++ b/tests/auto/modeltest/tst_modeltest.cpp
@@ -0,0 +1,309 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 <QtGui/QtGui>
+
+#include "modeltest.h"
+#include "dynamictreemodel.h"
+
+
+class tst_ModelTest : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_ModelTest() {}
+ virtual ~tst_ModelTest() {}
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+ void init();
+ void cleanup();
+
+private slots:
+ void stringListModel();
+ void treeWidgetModel();
+ void standardItemModel();
+ void testInsertThroughProxy();
+ void moveSourceItems();
+ void testResetThroughProxy();
+};
+
+
+
+void tst_ModelTest::initTestCase()
+{
+}
+
+void tst_ModelTest::cleanupTestCase()
+{
+}
+
+void tst_ModelTest::init()
+{
+
+}
+
+void tst_ModelTest::cleanup()
+{
+}
+/*
+ tests
+*/
+
+void tst_ModelTest::stringListModel()
+{
+ QStringListModel model;
+ QSortFilterProxyModel proxy;
+
+ ModelTest t1(&model);
+ ModelTest t2(&proxy);
+
+ proxy.setSourceModel(&model);
+
+ model.setStringList(QStringList() << "2" << "3" << "1");
+ model.setStringList(QStringList() << "a" << "e" << "plop" << "b" << "c" );
+
+ proxy.setDynamicSortFilter(true);
+ proxy.setFilterRegExp(QRegExp("[^b]"));
+}
+
+void tst_ModelTest::treeWidgetModel()
+{
+ QTreeWidget widget;
+
+ ModelTest t1(widget.model());
+
+ QTreeWidgetItem *root = new QTreeWidgetItem(&widget, QStringList("root"));
+ for (int i = 0; i < 20; ++i) {
+ new QTreeWidgetItem(root, QStringList(QString::number(i)));
+ }
+ QTreeWidgetItem *remove = root->child(2);
+ root->removeChild(remove);
+ QTreeWidgetItem *parent = new QTreeWidgetItem(&widget, QStringList("parent"));
+ new QTreeWidgetItem(parent, QStringList("child"));
+ widget.setItemHidden(parent, true);
+
+ widget.sortByColumn(0);
+}
+
+void tst_ModelTest::standardItemModel()
+{
+ QStandardItemModel model(10,10);
+ QSortFilterProxyModel proxy;
+
+
+ ModelTest t1(&model);
+ ModelTest t2(&proxy);
+
+ proxy.setSourceModel(&model);
+
+ model.insertRows(2, 5);
+ model.removeRows(4, 5);
+
+ model.insertColumns(2, 5);
+ model.removeColumns(4, 5);
+
+ model.insertRows(0,5, model.index(1,1));
+ model.insertColumns(0,5, model.index(1,3));
+}
+
+void tst_ModelTest::testInsertThroughProxy()
+{
+ DynamicTreeModel *model = new DynamicTreeModel(this);
+
+ QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
+ proxy->setSourceModel(model);
+
+ new ModelTest(proxy, this);
+
+ ModelInsertCommand *insertCommand = new ModelInsertCommand(model, this);
+ insertCommand->setNumCols(4);
+ insertCommand->setStartRow(0);
+ insertCommand->setEndRow(9);
+ // Parent is QModelIndex()
+ insertCommand->doCommand();
+
+ insertCommand = new ModelInsertCommand(model, this);
+ insertCommand->setNumCols(4);
+ insertCommand->setAncestorRowNumbers(QList<int>() << 5);
+ insertCommand->setStartRow(0);
+ insertCommand->setEndRow(9);
+ insertCommand->doCommand();
+
+ ModelMoveCommand *moveCommand = new ModelMoveCommand(model, this);
+ moveCommand->setNumCols(4);
+ moveCommand->setStartRow(0);
+ moveCommand->setEndRow(0);
+ moveCommand->setDestRow(9);
+ moveCommand->setDestAncestors(QList<int>() << 5);
+ moveCommand->doCommand();
+}
+
+/**
+ Makes the persistent index list publicly accessible
+*/
+class AccessibleProxyModel : public QSortFilterProxyModel
+{
+ Q_OBJECT
+public:
+ AccessibleProxyModel(QObject *parent = 0) : QSortFilterProxyModel(parent) {}
+
+ QModelIndexList persistent()
+ {
+ return persistentIndexList();
+ }
+};
+
+class ObservingObject : public QObject
+{
+ Q_OBJECT
+public:
+ ObservingObject(AccessibleProxyModel *proxy, QObject *parent = 0)
+ : QObject(parent),
+ m_proxy(proxy)
+ {
+ connect(m_proxy, SIGNAL(layoutAboutToBeChanged()), SLOT(storePersistent()));
+ connect(m_proxy, SIGNAL(layoutChanged()), SLOT(checkPersistent()));
+ }
+
+public slots:
+
+ void storePersistent(const QModelIndex &parent)
+ {
+ for (int row = 0; row < m_proxy->rowCount(parent); ++row) {
+ QModelIndex proxyIndex = m_proxy->index(row, 0, parent);
+ QModelIndex sourceIndex = m_proxy->mapToSource(proxyIndex);
+ Q_ASSERT(proxyIndex.isValid());
+ Q_ASSERT(sourceIndex.isValid());
+ m_persistentSourceIndexes.append(sourceIndex);
+ m_persistentProxyIndexes.append(proxyIndex);
+ if (m_proxy->hasChildren(proxyIndex))
+ storePersistent(proxyIndex);
+ }
+ }
+
+ void storePersistent()
+ {
+ foreach(const QModelIndex &idx, m_persistentProxyIndexes)
+ Q_ASSERT(idx.isValid()); // This is called from layoutAboutToBeChanged. Persistent indexes should be valid
+
+ Q_ASSERT(m_proxy->persistent().isEmpty());
+ storePersistent(QModelIndex());
+ Q_ASSERT(!m_proxy->persistent().isEmpty());
+ }
+
+ void checkPersistent()
+ {
+ for (int row = 0; row < m_persistentProxyIndexes.size(); ++row) {
+ QModelIndex updatedProxy = m_persistentProxyIndexes.at(row);
+ QModelIndex updatedSource = m_persistentSourceIndexes.at(row);
+ }
+ for (int row = 0; row < m_persistentProxyIndexes.size(); ++row) {
+ QModelIndex updatedProxy = m_persistentProxyIndexes.at(row);
+ QModelIndex updatedSource = m_persistentSourceIndexes.at(row);
+ QCOMPARE(m_proxy->mapToSource(updatedProxy), updatedSource);
+ }
+ m_persistentSourceIndexes.clear();
+ m_persistentProxyIndexes.clear();
+ }
+
+private:
+ AccessibleProxyModel *m_proxy;
+ QList<QPersistentModelIndex> m_persistentSourceIndexes;
+ QList<QPersistentModelIndex> m_persistentProxyIndexes;
+};
+
+void tst_ModelTest::moveSourceItems()
+{
+ DynamicTreeModel *model = new DynamicTreeModel(this);
+ AccessibleProxyModel *proxy = new AccessibleProxyModel(this);
+ proxy->setSourceModel(model);
+
+ ModelInsertCommand *insertCommand = new ModelInsertCommand(model, this);
+ insertCommand->setStartRow(0);
+ insertCommand->setEndRow(2);
+ insertCommand->doCommand();
+
+ insertCommand = new ModelInsertCommand(model, this);
+ insertCommand->setAncestorRowNumbers(QList<int>() << 1);
+ insertCommand->setStartRow(0);
+ insertCommand->setEndRow(2);
+ insertCommand->doCommand();
+
+ ObservingObject observer(proxy);
+
+ ModelMoveCommand *moveCommand = new ModelMoveCommand(model, this);
+ moveCommand->setStartRow(0);
+ moveCommand->setEndRow(0);
+ moveCommand->setDestAncestors(QList<int>() << 1);
+ moveCommand->setDestRow(0);
+ moveCommand->doCommand();
+}
+
+void tst_ModelTest::testResetThroughProxy()
+{
+ DynamicTreeModel *model = new DynamicTreeModel(this);
+
+ ModelInsertCommand *insertCommand = new ModelInsertCommand(model, this);
+ insertCommand->setStartRow(0);
+ insertCommand->setEndRow(2);
+ insertCommand->doCommand();
+
+ QPersistentModelIndex persistent = model->index(0, 0);
+
+ AccessibleProxyModel *proxy = new AccessibleProxyModel(this);
+ proxy->setSourceModel(model);
+
+ ObservingObject observer(proxy);
+ observer.storePersistent();
+
+ ModelResetCommand *resetCommand = new ModelResetCommand(model, this);
+ resetCommand->setNumCols(0);
+ resetCommand->doCommand();
+}
+
+
+QTEST_MAIN(tst_ModelTest)
+#include "tst_modeltest.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-07 19:04:33 +0000