Data model for settings/options updates

Intermediate unfinished state with unit tests (including ones
from Nokia Qt Labs)

git-svn-id: file:///svnroot/qtrapids/trunk@50 42ac0dd5-4c8c-4c71-bb3e-ecdfe252ffda

diff --git a/CMakeLists.txt b/CMakeLists.txt
index adee58e..bd61dcd 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,4 +9,5 @@ find_package(Qt4 REQUIRED)
 add_subdirectory(./dbus)
 add_subdirectory(./src/client)
 add_subdirectory(./src/server)
+add_subdirectory(./src/utest)
 

diff --git a/src/utest/CMakeLists.txt b/src/utest/CMakeLists.txt
new file mode 100644 (file)
index 0000000..4e80627
--- /dev/null
+++ b/src/utest/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(./options)

diff --git a/src/utest/options/CMakeLists.txt b/src/utest/options/CMakeLists.txt
new file mode 100644 (file)
index 0000000..5034d87
--- /dev/null
+++ b/src/utest/options/CMakeLists.txt
@@ -0,0 +1,62 @@
+INCLUDE(${QT_USE_FILE})
+
+INCLUDE_DIRECTORIES(../include)
+
+INCLUDE_DIRECTORIES(
+   ${QT_INCLUDE_DIR}
+   ${QT_QTTEST_INCLUDE_DIR}
+   ${QT_QTGUI}
+)
+
+
+SET(MOC_HEADERS
+  ./Options.hpp
+  ./modeltest.h
+)
+
+SET(SRC
+  ./Options.cpp
+  ./modeltest.cpp
+)
+
+QT4_WRAP_CPP(SRC ${MOC_HEADERS})
+
+
+SET(MOC_UIHEADERS
+  ./MainUI.hpp
+)
+
+SET(UISRC
+  ./MainUI.cpp
+  ./Options.cpp
+)
+
+QT4_WRAP_CPP(UISRC ${MOC_UIHEADERS})
+
+SET(MOC_UTESTHEADERS
+  ./TestSettingsModel.hpp
+)
+
+SET(UTESTSRC
+  ./TestSettingsModel.cpp
+)
+
+QT4_WRAP_CPP(UTESTSRC ${MOC_UTESTHEADERS})
+
+
+ADD_EXECUTABLE(uitestopt ${UISRC} ${MOC_UIHEADERS} ${SRC} ${MOC_HEADERS} mainui.cpp)
+ADD_EXECUTABLE(testopt ${SRC} ${MOC_HEADERS} ${UTESTSRC} ${MOC_UTESTHEADERS}  main.cpp)
+
+ADD_DEFINITIONS(-DQT_SHARED)
+
+TARGET_LINK_LIBRARIES(uitestopt 
+  ${QT_QTGUI_LIBRARY} 
+  ${QT_QTCORE_LIBRARY} 
+)
+
+TARGET_LINK_LIBRARIES(testopt 
+  ${QT_QTGUI_LIBRARY} 
+  ${QT_QTCORE_LIBRARY} 
+  ${QT_QTTEST_LIBRARY}
+)
+

diff --git a/src/utest/options/MainUI.cpp b/src/utest/options/MainUI.cpp
new file mode 100644 (file)
index 0000000..b75cbba
--- /dev/null
+++ b/src/utest/options/MainUI.cpp
@@ -0,0 +1,27 @@
+#include "MainUI.hpp"
+#include "Options.hpp"
+
+#include <QTabWidget>
+#include <QBoxLayout>
+#include <QLabel>
+
+namespace testopt
+{
+
+
+using qtplus::SettingsModel;
+using qtplus::OptionsGroup;
+
+MainDialog::MainDialog()
+               : tabs_(new QTabWidget(this))
+               , model_(new SettingsModel(this))
+{
+       setWindowTitle("Test options");
+
+       QLabel *lbl = new QLabel();
+       tabs_->addTab(lbl, "Options");
+       setCentralWidget(tabs_);
+       model_->addGroup(SettingsModel::group_ptr(new OptionsGroup("Group1")));
+}
+
+} // namespace testopt

diff --git a/src/utest/options/MainUI.hpp b/src/utest/options/MainUI.hpp
new file mode 100644 (file)
index 0000000..92eb19d
--- /dev/null
+++ b/src/utest/options/MainUI.hpp
@@ -0,0 +1,30 @@
+#include <QMainWindow>
+#include <memory>
+
+
+class QTabWidget;
+
+namespace qtplus
+{
+class SettingsModel;
+}
+
+namespace testopt
+{
+
+class MainDialog : public QMainWindow
+{
+       Q_OBJECT;
+
+public:
+       MainDialog();
+
+private slots:
+
+private:
+       QTabWidget *tabs_;
+       std::auto_ptr<qtplus::SettingsModel> model_;
+};
+
+} // namespace testopt
+

diff --git a/src/utest/options/Options.cpp b/src/utest/options/Options.cpp
new file mode 100644 (file)
index 0000000..10cd514
--- /dev/null
+++ b/src/utest/options/Options.cpp
@@ -0,0 +1,142 @@
+#include "Options.hpp"
+
+#include <QVariant>
+
+#include <algorithm>
+
+namespace qtplus
+{
+
+SettingsModel::SettingsModel(QObject *parent)
+               : QAbstractItemModel(parent)
+{
+
+}
+
+QModelIndex SettingsModel::index(int row, int col, const QModelIndex &parent) const
+{
+       if (row < 0 || col < 0) {
+               return QModelIndex();
+       }
+
+       if ( !parent.isValid()) {
+
+               if (col == 0 && row < groups_.size() ) {
+                       return QAbstractItemModel::createIndex(row, col, groups_[row].data());
+               } else if (col == 2 && row < options_.size()) {
+                       return QAbstractItemModel::createIndex(row, col, options_[row].data());
+               }
+               return QModelIndex();
+       }
+
+       if (parent.parent().isValid() || col > 0) {
+               // only one nesting level is support
+               return QModelIndex();
+       }
+
+       OptionsGroup *group = reinterpret_cast<OptionsGroup*>(parent.internalPointer());
+       if (!group) {
+               thrown std::exception();
+       }
+       return QAbstractItemModel::createIndex(row, col, options_[group->getOptionPos(row)].data());
+}
+
+QModelIndex SettingsModel::parent(const QModelIndex &child) const
+{
+       return QModelIndex();
+}
+
+int SettingsModel::rowCount(const QModelIndex &parent) const
+{
+       if (!parent.isValid()) {
+               return std::max(groups_.size(), options_.size());
+       }
+
+       // only one level of nesting is supported (group/option)
+       if (parent.parent().isValid() || parent.column() || index.column() > 0) {
+               throw std::exception();
+       }
+
+       OptionsGroup *group = reinterpret_cast<OptionsGroup*>(parent.internalPointer());
+       if (!group) {
+               thrown std::exception();
+       }
+
+       return group->optionsCount();
+}
+
+int SettingsModel::columnCount(const QModelIndex &parent) const
+{
+       return ( groups_.size()
+                ? ( options_.size() ? 2 : 1 ) );
+}
+
+static inline QVariant getTopLevelDisplayData_(const QModelIndex &index)
+{
+       if ( index.column() == 0) {
+               OptionsGroup *group = reinterpret_cast<OptionsGroup*>(index.internalPointer());
+               if (!group) {
+                       thrown std::exception();
+               }
+               return QVariant(group->name());
+       }
+
+       Option *option = reinterpret_cast<Option*>(index.internalPointer());
+       if (!option) {
+               thrown std::exception();
+       }
+       return option->value();
+}
+
+QVariant SettingsModel::data(const QModelIndex &index, int role) const
+{
+       if (role != Qt::DisplayRole) {
+               return QVariant();
+       }
+
+       if (!index.isValid()) {
+               return QVariant();
+       }
+
+       if (!index.parent().isValid()) {
+               return getTopLevelDisplayData_(index);
+       }
+
+       if (index.column() > 0) {
+               // only one level of nesting
+               return QVariant();
+       }
+
+       Option *option = reinterpret_cast<Option*>(index.internalPointer());
+       if (!option) {
+               thrown std::exception();
+       }
+       return option.value();
+
+}
+
+bool SettingsModel::addGroup(QString const &name)
+{
+       group_ptr group(new SettingsModel::OptionsGroup(name), this);
+
+       if (idx_.find(name) == idx_.end()) {
+               idx_[name] = group;
+               groups_.push_back(group);
+               return true;
+       }
+
+       return false;
+}
+
+size_t SettingsModel::addOption(OptionsGroup *group, QString const& name, QVariant const& value)
+{
+       if (idx_.find(group->name()) == idx_.end()) {
+               throw std::exception(); // TODO use custom exception
+       }
+
+       options_.push_back(option_ptr(new Option(name, value)));
+       return options_.size();
+}
+
+
+} // namespace qtplus

diff --git a/src/utest/options/Options.hpp b/src/utest/options/Options.hpp
new file mode 100644 (file)
index 0000000..083336a
--- /dev/null
+++ b/src/utest/options/Options.hpp
@@ -0,0 +1,115 @@
+#ifndef _QTUIPLUS_OPTIONS_HPP_
+#define _QTUIPLUS_OPTIONS_HPP_
+
+#include <QPointer>
+#include <QHash>
+#include <QVector>
+#include <QString>
+#include <QAbstractItemModel>
+#include <QSharedPointer>
+
+namespace qtplus
+{
+
+class OptionsGroup;
+
+class Option
+{
+public:
+
+       Option(QString const& name, QVariant const& value)
+                       : name_(name)
+                       , value_(value) { }
+
+       QString const& name() const {
+               return name_;
+       }
+
+       QVariant const& value() const {
+               return value_;
+       }
+
+private:
+       QString name_;
+       QVariant value_;
+};
+
+class OptionsGroup
+{
+       typedef QVector<size_t> options_t;
+       typedef QHash<QString, size_t> index_t;
+
+public:
+
+       typedef SettingsModel* model_ptr;
+
+       OptionsGroup(QString const& name, model_ptr)
+                       : name_(name) { }
+
+       void addOption(QString const& name, QVariant const& value) {
+               if (idx_.find() != idx_.end()) {
+                       return false;
+               }
+
+               size_t pos = model_->addOption(this, name, value);
+               options_.push_back(pos);
+               idx_[name] = pos;
+               return true;
+       }
+
+       QString name() const {
+               return name_;
+       }
+
+       size_t optionsCount() const {
+               return options_.size();
+       }
+
+       size_t getOptionPos(size_t pos) const {
+               return ( (0 <= pos && pos < options_.size())
+                        ? options_[pos]
+                        : 0 );
+       }
+
+private:
+       QString name_;
+       model_ptr model_;
+       options_t options_;
+       index_t idx_;
+};
+
+class SettingsModel : public QAbstractItemModel
+{
+       Q_OBJECT;
+
+public:
+
+       SettingsModel(QObject *parent = 0);
+
+       typedef QSharedPointer<OptionsGroup> group_ptr;
+
+       QModelIndex index(int row, int col, const QModelIndex &parent = QModelIndex() ) const;
+       QModelIndex parent(const QModelIndex &child) const;
+       int rowCount(const QModelIndex &parent = QModelIndex() ) const;
+       int columnCount(const QModelIndex &parent = QModelIndex() ) const;
+       QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+       bool addGroup(QString const& name, SettingsModel*);
+       bool addOption(OptionsGroup *group, QString const& name, QVariant const& value);
+
+private:
+
+       typedef QVector<group_ptr> groups_t;
+       typedef QHash<QString, group_ptr> groups_index_t;
+       typedef QSharedPointer<Option> option_ptr;
+       typedef QVector<option_ptr> options_t;
+
+       groups_t groups_;
+       groups_index_t idx_;
+       options_t options_;
+};
+
+
+} // namespace qtplus
+
+#endif // _QTPLUS_OPTIONS_HPP_

diff --git a/src/utest/options/TestSettingsModel.cpp b/src/utest/options/TestSettingsModel.cpp
new file mode 100644 (file)
index 0000000..ccac7bc
--- /dev/null
+++ b/src/utest/options/TestSettingsModel.cpp
@@ -0,0 +1,48 @@
+#include "TestSettingsModel.hpp"
+#include "Options.hpp"
+
+#include "modeltest.h"
+
+using qtplus::SettingsModel;
+using qtplus::OptionsGroup;
+
+TestSettingsModel::TestSettingsModel()
+               : model_(0)
+{
+}
+
+
+void TestSettingsModel::testAddEmptyGroups()
+{
+       model_.reset(new SettingsModel());
+       std::auto_ptr<ModelTest> modelmon(new ModelTest(model_.get(), 0));
+
+       QVERIFY(model_->rowCount() == 0);
+       QVERIFY(model_->columnCount() == 0);
+       QVERIFY(model_->data(QModelIndex()) == QVariant());
+       QVERIFY(model_->data(model_->index(0, 0)) == QVariant());
+       QVERIFY(model_->data(model_->index(1, 0)) == QVariant());
+       QVERIFY(model_->data(model_->index(0, 1)) == QVariant());
+       QVERIFY(model_->data(model_->index(1, 1)) == QVariant());
+
+       model_->addGroup(SettingsModel::group_ptr(new OptionsGroup("Group1")));
+
+       QVERIFY(model_->rowCount() == 1);
+       QVERIFY(model_->columnCount() == 1);
+       QVERIFY(model_->data(QModelIndex()) == QVariant());
+       QVERIFY(model_->data(model_->index(0, 0)) == QVariant("Group1"));
+       QVERIFY(model_->data(model_->index(1, 0)) == QVariant());
+       QVERIFY(model_->data(model_->index(0, 1)) == QVariant());
+       QVERIFY(model_->data(model_->index(1, 1)) == QVariant());
+
+
+       model_->addGroup(SettingsModel::group_ptr(new OptionsGroup("Group2")));
+
+       QVERIFY(model_->rowCount() == 2);
+       QVERIFY(model_->columnCount() == 1);
+       QVERIFY(model_->data(QModelIndex()) == QVariant());
+       QVERIFY(model_->data(model_->index(0, 0)) == QVariant("Group1"));
+       QVERIFY(model_->data(model_->index(1, 0)) == QVariant("Group2"));
+       QVERIFY(model_->data(model_->index(0, 1)) == QVariant());
+       QVERIFY(model_->data(model_->index(1, 1)) == QVariant());
+}

diff --git a/src/utest/options/TestSettingsModel.hpp b/src/utest/options/TestSettingsModel.hpp
new file mode 100644 (file)
index 0000000..4ad5253
--- /dev/null
+++ b/src/utest/options/TestSettingsModel.hpp
@@ -0,0 +1,26 @@
+#ifndef _TESTSETTINGSMODEL_H_
+#define _TESTSETTINGSMODEL_H_
+
+#include <QtTest/QtTest>
+
+#include <memory>
+
+
+namespace qtplus
+{
+class SettingsModel;
+}
+
+class TestSettingsModel : public QObject
+{
+       Q_OBJECT;
+public:
+       TestSettingsModel();
+private slots:
+       void testAddEmptyGroups();
+private:
+       std::auto_ptr<qtplus::SettingsModel> model_;
+
+};
+
+#endif // _TESTSETTINGSMODEL_H_

diff --git a/src/utest/options/main.cpp b/src/utest/options/main.cpp
new file mode 100644 (file)
index 0000000..3f4ff4a
--- /dev/null
+++ b/src/utest/options/main.cpp
@@ -0,0 +1,5 @@
+#include "TestSettingsModel.hpp"
+QTEST_MAIN(TestSettingsModel)
+//#include "TestSettingsModel.moc"
+
+

diff --git a/src/utest/options/mainui.cpp b/src/utest/options/mainui.cpp
new file mode 100644 (file)
index 0000000..123da52
--- /dev/null
+++ b/src/utest/options/mainui.cpp
@@ -0,0 +1,16 @@
+#include "MainUI.hpp"
+
+#include <QApplication>
+#include <QDebug>
+
+using testopt::MainDialog;
+
+
+int main(int argc, char *argv[])
+{
+       QApplication app(argc, argv);
+
+       MainDialog dlg;
+       dlg.show();
+       return app.exec();
+}

diff --git a/src/utest/options/modeltest.cpp b/src/utest/options/modeltest.cpp
new file mode 100644 (file)
index 0000000..62ddbbf
--- /dev/null
+++ b/src/utest/options/modeltest.cpp
@@ -0,0 +1,539 @@
+/****************************************************************************
+**
+** 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 <QtGui/QtGui>
+
+#include "modeltest.h"
+
+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);
+       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();
+}
+
+/*!
+    Tests model's implementation of QAbstractItemModel::rowCount() and hasChildren()
+
+    Models that are dynamically populated are not as fully tested here.
+ */
+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
+}
+
+/*!
+    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()
+{
+       // 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()
+{
+       // 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()
+{
+       // 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.
+                       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);
+               }
+       }
+}
+
+/*!
+    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 == 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(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);
+       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);
+       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)
+{
+       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)
+{
+       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/src/utest/options/modeltest.h b/src/utest/options/modeltest.h
new file mode 100644 (file)
index 0000000..a18c9ab
--- /dev/null
+++ b/src/utest/options/modeltest.h
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** 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.
+**
+****************************************************************************/
+
+#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