Long live Qt 4.5!

1 files changed, 1397 insertions, 0 deletions

diff --git a/tests/auto/qitemmodel/tst_qitemmodel.cpp b/tests/auto/qitemmodel/tst_qitemmodel.cpp
new file mode 100644
index 0000000..ea1972e
--- /dev/null
+++ b/tests/auto/qitemmodel/tst_qitemmodel.cpp
@@ -0,0 +1,1397 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtCore>
+#include <qdebug.h>
+#include <modelstotest.cpp>
+#include <QMetaType>
+
+Q_DECLARE_METATYPE(QModelIndex)
+
+//TESTED_CLASS=
+//TESTED_FILES=gui/itemviews/qstandarditemmodel.h gui/itemviews/qstandarditemmodel.cpp
+
+/*!
+    See modelstotest.cpp for instructions on how to have your model tested with these tests.
+
+    Each test such as rowCount have a _data() function which populate the QTest data with
+    the tests specified by modelstotest.cpp and any extra data needed for that perticular test.
+
+    setupWithNoTestData() fills the QTest data with just the tests and is used by most tests.
+
+    There are some basic qDebug statements sprikled about that might be helpfull for fixing
+    your issues.
+ */
+class tst_QItemModel : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QItemModel() {};
+    virtual ~tst_QItemModel() {};
+
+public slots:
+    void init();
+    void cleanup();
+
+private slots:
+    void nonDestructiveBasicTest_data();
+    void nonDestructiveBasicTest();
+
+    void rowCount_data();
+    void rowCount();
+    void columnCount_data();
+    void columnCount();
+
+    void hasIndex_data();
+    void hasIndex();
+    void index_data();
+    void index();
+
+    void parent_data();
+    void parent();
+
+    void data_data();
+    void data();
+
+    void setData_data();
+    void setData();
+
+    void setHeaderData_data();
+    void setHeaderData();
+
+    void remove_data();
+    void remove();
+
+    void insert_data();
+    void insert();
+
+    void sort_data();
+    void sort();
+
+protected slots:
+    void slot_rowsAboutToRemove(const QModelIndex &parent);
+    void slot_rowsRemoved(const QModelIndex &parent);
+    void slot_columnsAboutToRemove(const QModelIndex &parent);
+    void slot_columnsRemoved(const QModelIndex &parent);
+
+    void slot_rowsAboutToInserted(const QModelIndex &parent);
+    void slot_rowsInserted(const QModelIndex &parent);
+    void slot_columnsAboutToInserted(const QModelIndex &parent);
+    void slot_columnsInserted(const QModelIndex &parent);
+private:
+    void setupWithNoTestData();
+    QAbstractItemModel *currentModel;
+    ModelsToTest *testModels;
+
+    // used by remove()
+    QPersistentModelIndex parentOfRemoved;
+    int afterAboutToRemoveRowCount;
+    int afterRemoveRowCount;
+    int afterAboutToRemoveColumnCount;
+    int afterRemoveColumnCount;
+
+    // remove() recursive
+    bool removeRecursively;
+
+    // used by insert()
+    QPersistentModelIndex parentOfInserted;
+    int afterAboutToInsertRowCount;
+    int afterInsertRowCount;
+    int afterAboutToInsertColumnCount;
+    int afterInsertColumnCount;
+
+    // insert() recursive
+    bool insertRecursively;
+};
+
+void tst_QItemModel::init()
+{
+    testModels = new ModelsToTest();
+    removeRecursively = false;
+    insertRecursively = false;
+}
+
+void tst_QItemModel::cleanup()
+{
+    testModels->cleanupTestArea(currentModel);
+    delete testModels;
+    delete currentModel;
+    currentModel = 0;
+}
+
+void tst_QItemModel::setupWithNoTestData()
+{
+    ModelsToTest modelsToTest;
+    QTest::addColumn<QString>("modelType");
+    QTest::addColumn<bool>("readOnly");
+    QTest::addColumn<bool>("isEmpty");
+    for (int i = 0; i < modelsToTest.tests.size(); ++i) {
+        ModelsToTest::test t = modelsToTest.tests.at(i);
+        bool readOnly = (t.read == ModelsToTest::ReadOnly);
+        bool isEmpty = (t.contains == ModelsToTest::Empty);
+        QTest::newRow(t.modelType.toLatin1().data()) << t.modelType << readOnly << isEmpty;
+    }
+}
+
+void tst_QItemModel::nonDestructiveBasicTest_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    nonDestructiveBasicTest trys to call a number of the basic functions (not all)
+    to make sure the model doesn't segfault, testing the functions that makes sense.
+ */
+void tst_QItemModel::nonDestructiveBasicTest()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    QCOMPARE(currentModel->buddy(QModelIndex()), QModelIndex());
+    currentModel->canFetchMore(QModelIndex());
+    QVERIFY(currentModel->columnCount(QModelIndex()) >= 0);
+    QCOMPARE(currentModel->data(QModelIndex()), QVariant());
+    currentModel->fetchMore(QModelIndex());
+    Qt::ItemFlags flags = currentModel->flags(QModelIndex());
+    QVERIFY(flags == Qt::ItemIsDropEnabled || flags == 0);
+    currentModel->hasChildren(QModelIndex());
+    currentModel->hasIndex(0, 0);
+    currentModel->headerData(0, Qt::Horizontal);
+    currentModel->index(0,0), QModelIndex();
+    currentModel->itemData(QModelIndex());
+    QVariant cache;
+    currentModel->match(QModelIndex(), -1, cache);
+    currentModel->mimeTypes();
+    QCOMPARE(currentModel->parent(QModelIndex()), QModelIndex());
+    QVERIFY(currentModel->rowCount() >= 0);
+    QVariant variant;
+    currentModel->setData(QModelIndex(), variant, -1);
+    currentModel->setHeaderData(-1, Qt::Horizontal, QVariant());
+    currentModel->setHeaderData(0, Qt::Horizontal, QVariant());
+    currentModel->setHeaderData(currentModel->columnCount() + 100, Qt::Horizontal, QVariant());
+    QMap<int, QVariant> roles;
+    currentModel->setItemData(QModelIndex(), roles);
+    currentModel->sibling(0,0,QModelIndex());
+    currentModel->span(QModelIndex());
+    currentModel->supportedDropActions();
+    currentModel->revert();
+    currentModel->submit();
+}
+
+
+void tst_QItemModel::rowCount_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::rowCount() and hasChildren()
+ */
+void tst_QItemModel::rowCount()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty) {
+        QCOMPARE(currentModel->rowCount(), 0);
+        QCOMPARE(currentModel->hasChildren(), false);
+    }
+    else {
+        QVERIFY(currentModel->rowCount() > 0);
+        QCOMPARE(currentModel->hasChildren(), true);
+    }
+
+    // check top row
+    QModelIndex topIndex = currentModel->index(0, 0, QModelIndex());
+    int rows = currentModel->rowCount(topIndex);
+    QVERIFY(rows >= 0);
+    if (rows > 0)
+        QCOMPARE(currentModel->hasChildren(topIndex), true);
+    else
+        QCOMPARE(currentModel->hasChildren(topIndex), false);
+
+    QModelIndex secondLevelIndex = currentModel->index(0, 0, topIndex);
+    if (secondLevelIndex.isValid()) { // not the top level
+        // check a row count where parent is valid
+        rows = currentModel->rowCount(secondLevelIndex);
+        QVERIFY(rows >= 0);
+        if (rows > 0)
+            QCOMPARE(currentModel->hasChildren(secondLevelIndex), true);
+        else
+            QCOMPARE(currentModel->hasChildren(secondLevelIndex), false);
+    }
+
+    // rowCount is tested more extensivly more later in checkChildren(),
+    // but this catches the big mistakes
+}
+
+void tst_QItemModel::columnCount_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::columnCount() and hasChildren()
+ */
+void tst_QItemModel::columnCount()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty) {
+        QCOMPARE(currentModel->hasChildren(), false);
+    }
+    else {
+        QVERIFY(currentModel->columnCount() > 0);
+        QCOMPARE(currentModel->hasChildren(), true);
+    }
+
+    // check top row
+    QModelIndex topIndex = currentModel->index(0, 0, QModelIndex());
+    int columns = currentModel->columnCount(topIndex);
+
+    // check a row count where parent is valid
+    columns = currentModel->columnCount(currentModel->index(0, 0, topIndex));
+    QVERIFY(columns >= 0);
+
+    // columnCount is tested more extensivly more later in checkChildren(),
+    // but this catches the big mistakes
+}
+
+void tst_QItemModel::hasIndex_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::hasIndex()
+ */
+void tst_QItemModel::hasIndex()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    // Make sure that invalid values returns an invalid index
+    QCOMPARE(currentModel->hasIndex(-2, -2), false);
+    QCOMPARE(currentModel->hasIndex(-2, 0), false);
+    QCOMPARE(currentModel->hasIndex(0, -2), false);
+
+    int rows = currentModel->rowCount();
+    int columns = currentModel->columnCount();
+
+    QCOMPARE(currentModel->hasIndex(rows, columns), false);
+    QCOMPARE(currentModel->hasIndex(rows+1, columns+1), false);
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    QCOMPARE(currentModel->hasIndex(0,0), true);
+
+    // hasIndex is tested more extensivly more later in checkChildren(),
+    // but this catches the big mistakes
+}
+
+void tst_QItemModel::index_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::index()
+ */
+void tst_QItemModel::index()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    // Make sure that invalid values returns an invalid index
+    QCOMPARE(currentModel->index(-2, -2), QModelIndex());
+    QCOMPARE(currentModel->index(-2, 0), QModelIndex());
+    QCOMPARE(currentModel->index(0, -2), QModelIndex());
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    int rows = currentModel->rowCount();
+    int columns = currentModel->columnCount();
+
+    // Catch off by one errors
+    QCOMPARE(currentModel->index(rows,columns), QModelIndex());
+    QCOMPARE(currentModel->index(0,0).isValid(), true);
+
+    // Make sure that the same index is always returned
+    QModelIndex a = currentModel->index(0,0);
+    QModelIndex b = currentModel->index(0,0);
+    QVERIFY(a == b);
+
+    // index is tested more extensivly more later in checkChildren(),
+    // but this catches the big mistakes
+}
+
+
+void tst_QItemModel::parent_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    A model that returns an index of parent X should also return X when asking
+    for the parent of the index.
+
+    This recursive function does pretty extensive testing on the whole model in an
+    effort to catch edge cases.
+
+    This function assumes that rowCount(), columnCount() and index() work.  If they have
+    a bug it will point it out, but the above tests should have already found the basic bugs
+    because it is easier to figure out the problem in those tests then this one.
+ */
+void checkChildren(QAbstractItemModel *currentModel, const QModelIndex &parent, int currentDepth=0)
+{
+    QFETCH(bool, readOnly);
+
+    if (currentModel->canFetchMore(parent))
+        currentModel->fetchMore(parent);
+
+    int rows = currentModel->rowCount(parent);
+    int columns = currentModel->columnCount(parent);
+
+    QCOMPARE(rows > 0, (currentModel->hasChildren(parent)));
+
+    // Some reasuring testing against rows(),columns(), and hasChildren()
+    QVERIFY(rows >= 0);
+    QVERIFY(columns >= 0);
+    if (rows > 0 || columns > 0)
+        QCOMPARE(currentModel->hasChildren(parent), true);
+    else
+        QCOMPARE(currentModel->hasChildren(parent), false);
+
+    //qDebug() << "parent:" << currentModel->data(parent).toString() << "rows:" << rows
+    //         << "columns:" << columns << "parent column:" << parent.column();
+
+    QCOMPARE(currentModel->hasIndex(rows+1, 0, parent), false);
+    for (int r = 0; r < rows; ++r) {
+        if (currentModel->canFetchMore(parent))
+            currentModel->fetchMore(parent);
+
+        QCOMPARE(currentModel->hasIndex(r, columns+1, parent), false);
+        for (int c = 0; c < columns; ++c) {
+            QCOMPARE(currentModel->hasIndex(r, c, parent), true);
+            QModelIndex index = currentModel->index(r, c, parent);
+            QCOMPARE(index.isValid(), true);
+
+            if (!readOnly)
+                currentModel->setData(index, "I'm a little tea pot short and stout");
+            QModelIndex modifiedIndex = currentModel->index(r, c, parent);
+            QCOMPARE(index, modifiedIndex);
+
+            // Make sure we get the same index if we request it twice in a row
+            QModelIndex a = currentModel->index(r, c, parent);
+            QModelIndex b = currentModel->index(r, c, parent);
+            QVERIFY(a == b);
+
+            // Some basic checking on the index that is returned
+            QVERIFY(index.model() == currentModel);
+            QCOMPARE(index.row(), r);
+            QCOMPARE(index.column(), c);
+            QCOMPARE(currentModel->data(index, Qt::DisplayRole).isValid(), true);
+
+            // If the next test fails here is some somewhat usefull debug you play with.
+            /*
+            if (currentModel->parent(index) != parent) {
+                qDebug() << r << c << currentDepth << currentModel->data(index).toString()
+                         << currentModel->data(parent).toString();
+                qDebug() << index << parent << currentModel->parent(index);
+                QTreeView view;
+                view.setModel(currentModel);
+                view.show();
+                QTest::qWait(9000);
+            }*/
+            QCOMPARE(currentModel->parent(index), parent);
+
+            // recursivly go down
+            if (currentModel->hasChildren(index) && currentDepth < 5) {
+                //qDebug() << r << c << "has children" << currentModel->rowCount(index);
+                checkChildren(currentModel, index, ++currentDepth);
+                // Because this is recursive we will return at the first failure rather then
+                // reporting it over and over
+                if (QTest::currentTestFailed())
+                    return;
+            }
+
+            // make sure that after testing the children that the index pointer doesn't change.
+            QModelIndex newerIndex = currentModel->index(r, c, parent);
+            QCOMPARE(index, newerIndex);
+        }
+    }
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::parent()
+ */
+void tst_QItemModel::parent()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    // Make sure the model wont crash and will return an invalid QModelIndex
+    // when asked for the parent of an invalid index.
+    QCOMPARE(currentModel->parent(QModelIndex()), QModelIndex());
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    // Common error test #1, make sure that a top level index has a parent
+    // that is a invalid QModelIndex.  You model
+    QModelIndex topIndex = currentModel->index(0, 0, QModelIndex());
+    QCOMPARE(currentModel->parent(topIndex), QModelIndex());
+
+    // Common error test #2, make sure that a second level index has a parent
+    // that is the top level index.
+    if (currentModel->rowCount(topIndex) > 0) {
+        QModelIndex childIndex = currentModel->index(0, 0, topIndex);
+        QCOMPARE(currentModel->parent(childIndex), topIndex);
+    }
+
+    // Common error test #3, the second colum has the same children
+    // as the first column in a row.
+    QModelIndex topIndex1 = currentModel->index(0, 1, QModelIndex());
+    if (currentModel->rowCount(topIndex1) > 0) {
+        QModelIndex childIndex = currentModel->index(0, 0, topIndex);
+        QModelIndex childIndex1 = currentModel->index(0, 0, topIndex1);
+        QVERIFY(childIndex != childIndex1);
+    }
+
+    // Full test, walk 10 levels deap through the model making sure that all
+    // parents's children correctly specify their parent
+    QModelIndex top = QModelIndex();
+    checkChildren(currentModel, top);
+}
+
+
+void tst_QItemModel::data_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::data()
+ */
+void tst_QItemModel::data()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    // Invalid index should return an invalid qvariant
+    QVERIFY(!currentModel->data(QModelIndex()).isValid());
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    // A valid index should have a valid qvariant data
+    QVERIFY(currentModel->index(0,0).isValid());
+
+    // shouldn't be able to set data on an invalid index
+    QCOMPARE(currentModel->setData(QModelIndex(), "foo", Qt::DisplayRole), false);
+
+    // General Purpose roles
+    QVariant variant = currentModel->data(currentModel->index(0,0), Qt::ToolTipRole);
+    if (variant.isValid()) {
+        QVERIFY(qVariantCanConvert<QString>(variant));
+    }
+    variant = currentModel->data(currentModel->index(0,0), Qt::StatusTipRole);
+    if (variant.isValid()) {
+        QVERIFY(qVariantCanConvert<QString>(variant));
+    }
+    variant = currentModel->data(currentModel->index(0,0), Qt::WhatsThisRole);
+    if (variant.isValid()) {
+        QVERIFY(qVariantCanConvert<QString>(variant));
+    }
+
+    variant = currentModel->data(currentModel->index(0,0), Qt::SizeHintRole);
+    if (variant.isValid()) {
+        QVERIFY(qVariantCanConvert<QSize>(variant));
+    }
+
+
+    // Appearance roles
+    QVariant fontVariant = currentModel->data(currentModel->index(0,0), Qt::FontRole);
+    if (fontVariant.isValid()) {
+        QVERIFY(qVariantCanConvert<QFont>(fontVariant));
+    }
+
+    QVariant textAlignmentVariant = currentModel->data(currentModel->index(0,0), Qt::TextAlignmentRole);
+    if (textAlignmentVariant.isValid()) {
+        int alignment = textAlignmentVariant.toInt();
+        QVERIFY(alignment == Qt::AlignLeft ||
+                alignment == Qt::AlignRight ||
+                alignment == Qt::AlignHCenter ||
+                alignment == Qt::AlignJustify);
+    }
+
+    QVariant colorVariant = currentModel->data(currentModel->index(0,0), Qt::BackgroundColorRole);
+    if (colorVariant.isValid()) {
+        QVERIFY(qVariantCanConvert<QColor>(colorVariant));
+    }
+
+    colorVariant = currentModel->data(currentModel->index(0,0), Qt::TextColorRole);
+    if (colorVariant.isValid()) {
+        QVERIFY(qVariantCanConvert<QColor>(colorVariant));
+    }
+
+    QVariant checkStateVariant = currentModel->data(currentModel->index(0,0), Qt::CheckStateRole);
+    if (checkStateVariant.isValid()) {
+        int state = checkStateVariant.toInt();
+        QVERIFY(state == Qt::Unchecked ||
+                state == Qt::PartiallyChecked ||
+                state == Qt::Checked);
+    }
+}
+
+void tst_QItemModel::setData_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::setData()
+ */
+void tst_QItemModel::setData()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    QSignalSpy spy(currentModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)));
+    QCOMPARE(currentModel->setData(QModelIndex(), QVariant()), false);
+    QCOMPARE(spy.count(), 0);
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    QFETCH(bool, readOnly);
+    if (readOnly)
+        return;
+
+    // Populate the test area so we can chage stuff.  See: cleanup()
+    QModelIndex topIndex = testModels->populateTestArea(currentModel);
+    QVERIFY(currentModel->hasChildren(topIndex));
+    QModelIndex index = currentModel->index(0, 0, topIndex);
+    QVERIFY(index.isValid());
+
+    spy.clear();
+    QString text = "Index private pointers should always be the same";
+    QCOMPARE(currentModel->setData(index, text, Qt::EditRole), true);
+    QCOMPARE(index.data(Qt::EditRole).toString(), text);
+
+    // Changing the text shouldn't change the layout, parent, pointer etc.
+    QModelIndex changedIndex = currentModel->index(0, 0, topIndex);
+    QCOMPARE(changedIndex, index);
+    QCOMPARE(spy.count(), 1);
+}
+
+void tst_QItemModel::setHeaderData_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::setHeaderData()
+ */
+void tst_QItemModel::setHeaderData()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    QCOMPARE(currentModel->setHeaderData(-1, Qt::Horizontal, QVariant()), false);
+    QCOMPARE(currentModel->setHeaderData(-1, Qt::Vertical, QVariant()), false);
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    QFETCH(bool, readOnly);
+    if (readOnly)
+        return;
+
+    // Populate the test area so we can change stuff.  See: cleanup()
+    QModelIndex topIndex = testModels->populateTestArea(currentModel);
+    QVERIFY(currentModel->hasChildren(topIndex));
+    QModelIndex index = currentModel->index(0, 0, topIndex);
+    QVERIFY(index.isValid());
+
+    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
+    QSignalSpy spy(currentModel, SIGNAL(headerDataChanged( Qt::Orientation, int , int )));
+
+    QString text = "Index private pointers should always be the same";
+    int signalCount = 0;
+    for (int i = 0; i < 4; ++i){
+        if(currentModel->setHeaderData(i, Qt::Horizontal, text)) {
+            QCOMPARE(currentModel->headerData(i, Qt::Horizontal).toString(), text);
+            ++signalCount;
+        }
+        if(currentModel->setHeaderData(i, Qt::Vertical, text)) {
+            QCOMPARE(currentModel->headerData(i, Qt::Vertical).toString(), text);
+            ++signalCount;
+        }
+    }
+    QCOMPARE(spy.count(), signalCount);
+}
+
+void tst_QItemModel::sort_data()
+{
+    setupWithNoTestData();
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::sort()
+ */
+void tst_QItemModel::sort()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    QFETCH(bool, isEmpty);
+    if (isEmpty)
+        return;
+
+    // Populate the test area so we can chage stuff.  See: cleanup()
+    QPersistentModelIndex topIndex = testModels->populateTestArea(currentModel);
+    QVERIFY(currentModel->hasChildren(topIndex));
+    QModelIndex index = currentModel->index(0, 0, topIndex);
+    QVERIFY(index.isValid());
+    QSignalSpy spy(currentModel, SIGNAL(layoutChanged()));
+    for (int i=-1; i < 10; ++i){
+        currentModel->sort(i);
+        if (index != currentModel->index(0, 0, topIndex)){
+            QVERIFY(spy.count() > 0);
+            index = currentModel->index(0, 0, topIndex);
+            spy.clear();
+        }
+    }
+    currentModel->sort(99999);
+}
+
+/*!
+    Tests model's implimentation of QAbstractItemModel::removeRow() and QAbstractItemModel::removeColumn()
+ */
+#define START 0
+#define MIDDLE 6
+#define END -1
+#define MANY 9
+#define ALL -1
+#define NOSIGNALS 0
+#define DEFAULTCOUNT 1
+#define DNS 1 // DefaultNumberOfSignals
+#define RECURSIVE true
+#define SUCCESS true
+#define FAIL false
+void tst_QItemModel::remove_data()
+{
+    ModelsToTest modelsToTest;
+    QTest::addColumn<QString>("modelType");
+    QTest::addColumn<bool>("readOnly");
+    QTest::addColumn<bool>("isEmpty");
+
+    QTest::addColumn<int>("start");
+    QTest::addColumn<int>("count");
+
+    QTest::addColumn<int>("numberOfRowsAboutToBeRemovedSignals");
+    QTest::addColumn<int>("numberOfColumnsAboutToBeRemovedSignals");
+    QTest::addColumn<int>("numberOfRowsRemovedSignals");
+    QTest::addColumn<int>("numberOfColumnsRemovedSignals");
+
+    QTest::addColumn<bool>("recursive");
+    QTest::addColumn<int>("recursiveRow");
+    QTest::addColumn<int>("recursiveCount");
+
+    QTest::addColumn<bool>("shouldSucceed");
+
+#define makeTestRow(testName, start, count, sar, srr, sac, src, r, rr, rc, s) \
+        QTest::newRow((t.modelType + testName).toLatin1().data()) << t.modelType << readOnly << isEmpty << \
+        start << count << \
+        sar << srr << sac << src << \
+        r << rr << rc << \
+        s;
+
+    for (int i = 0; i < modelsToTest.tests.size(); ++i) {
+        ModelsToTest::test t = modelsToTest.tests.at(i);
+        QString name = t.modelType;
+        bool readOnly = (t.read == ModelsToTest::ReadOnly);
+        bool isEmpty = (t.contains == ModelsToTest::Empty);
+
+        // half these
+        makeTestRow(":one at the start",  START,  DEFAULTCOUNT, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":one at the middle", MIDDLE, DEFAULTCOUNT, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":one at the end",    END,    DEFAULTCOUNT, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+
+        makeTestRow(":many at the start",  START,  MANY, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":many at the middle", MIDDLE, MANY, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":many at the end",    END,    MANY, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+
+        makeTestRow(":remove all",        START,  ALL,  DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+
+        makeTestRow(":none at the start",  START,  0, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":none at the middle", MIDDLE, 0, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":none at the end",    END,    0, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+
+        makeTestRow(":invalid start, valid count", -99,  0,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", 9999, 0,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", -99,  1,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", 9999, 1,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", -99,  MANY, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", 9999, MANY, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+
+        makeTestRow(":valid start, invalid count",  START,  -2,   NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  MIDDLE, -2,   NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  END,    -2,   NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  START,  9999, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  MIDDLE, 9999, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  END,    9999, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+
+        // Recursive remove's might assert, havn't decided yet...
+        //makeTestRow(":one at the start recursivly",  START,  DEFAULTCOUNT, 2, DNS, 2, DNS, RECURSIVE, START, DEFAULTCOUNT, FAIL);
+        //makeTestRow(":one at the middle recursivly", MIDDLE, DEFAULTCOUNT, 2, DNS, 2, DNS, RECURSIVE, START, DEFAULTCOUNT, SUCCESS);
+        //makeTestRow(":one at the end recursivly",    END,    DEFAULTCOUNT, 2, DNS, 2, DNS, RECURSIVE, START, DEFAULTCOUNT, SUCCESS);
+    }
+}
+
+void tst_QItemModel::remove()
+{
+    QFETCH(QString, modelType);
+
+    currentModel = testModels->createModel(modelType);
+
+    QFETCH(bool, readOnly);
+    if (readOnly)
+        return;
+
+    QFETCH(int, start);
+    QFETCH(int, count);
+
+    QFETCH(bool, recursive);
+    removeRecursively = recursive;
+
+/*!
+    Removes count number of rows starting at start
+    if count is -1 it removes all rows
+    if start is -1 then it starts at the last row - count
+ */
+    QFETCH(bool, shouldSucceed);
+
+    // Populate the test area so we can remove something.  See: cleanup()
+    // parentOfRemoved is stored so that the slots can make sure parentOfRemoved is the index that is emited.
+    parentOfRemoved = testModels->populateTestArea(currentModel);
+
+    if (count == -1)
+        count = currentModel->rowCount(parentOfRemoved);
+    if (start == -1)
+        start = currentModel->rowCount(parentOfRemoved)-count;
+
+    if (currentModel->rowCount(parentOfRemoved) == 0 ||
+        currentModel->columnCount(parentOfRemoved) == 0) {
+        qWarning() << "model test area doesn't have any rows or columns, can't fully test remove(). Skipping";
+        return;
+    }
+
+    //qDebug() << "remove start:" << start << "count:" << count << "rowCount:" << currentModel->rowCount(parentOfRemoved);
+
+    // When a row or column is removed there should be two signals.
+    // Watch to make sure they are emited and get the row/column count when they do get emited by connecting them to a slot
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    QSignalSpy columnsAboutToBeRemovedSpy(currentModel, SIGNAL(columnsAboutToBeRemoved( const QModelIndex &, int , int )));
+    QSignalSpy rowsAboutToBeRemovedSpy(currentModel, SIGNAL(rowsAboutToBeRemoved( const QModelIndex &, int , int )));
+    QSignalSpy columnsRemovedSpy(currentModel, SIGNAL(columnsRemoved( const QModelIndex &, int, int )));
+    QSignalSpy rowsRemovedSpy(currentModel, SIGNAL(rowsRemoved( const QModelIndex &, int, int )));
+    QSignalSpy modelResetSpy(currentModel, SIGNAL(modelReset()));
+    QSignalSpy modelLayoutChangedSpy(currentModel, SIGNAL(layoutChanged()));
+
+    QFETCH(int, numberOfRowsAboutToBeRemovedSignals);
+    QFETCH(int, numberOfColumnsAboutToBeRemovedSignals);
+    QFETCH(int, numberOfRowsRemovedSignals);
+    QFETCH(int, numberOfColumnsRemovedSignals);
+
+    //
+    // test removeRow()
+    //
+    connect(currentModel, SIGNAL(rowsAboutToBeRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsAboutToRemove(const QModelIndex &)));
+    connect(currentModel, SIGNAL(rowsRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsRemoved(const QModelIndex &)));
+    int beforeRemoveRowCount = currentModel->rowCount(parentOfRemoved);
+    QPersistentModelIndex dyingIndex = currentModel->index(start + count + 1, 0, parentOfRemoved);
+    QCOMPARE(currentModel->removeRows(start, count, parentOfRemoved), shouldSucceed);
+    currentModel->submit();
+    if (shouldSucceed && dyingIndex.isValid())
+        QCOMPARE(dyingIndex.row(), start + 1);
+
+    if (rowsAboutToBeRemovedSpy.count() > 0){
+        QList<QVariant> arguments = rowsAboutToBeRemovedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfRemoved == parent);
+    }
+
+    if (rowsRemovedSpy.count() > 0){
+        QList<QVariant> arguments = rowsRemovedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfRemoved == parent);
+    }
+
+    // Only the row signals should have been emited
+    if (modelResetSpy.count() >= 1 || modelLayoutChangedSpy.count() >=1 ){
+        QCOMPARE(columnsAboutToBeRemovedSpy.count(), 0);
+        QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
+        QCOMPARE(columnsRemovedSpy.count(), 0);
+        QCOMPARE(rowsRemovedSpy.count(), 0);
+    }
+    else {
+        QCOMPARE(columnsAboutToBeRemovedSpy.count(), 0);
+        QCOMPARE(rowsAboutToBeRemovedSpy.count(), numberOfRowsAboutToBeRemovedSignals);
+        QCOMPARE(columnsRemovedSpy.count(), 0);
+        QCOMPARE(rowsRemovedSpy.count(), numberOfRowsRemovedSignals);
+    }
+
+    // The row count should only change *after* rowsAboutToBeRemoved has been emited
+    //qDebug() << beforeRemoveRowCount << afterAboutToRemoveRowCount << afterRemoveRowCount << currentModel->rowCount(parentOfRemoved);
+    if (shouldSucceed) {
+        if (modelResetSpy.count() == 0 && modelLayoutChangedSpy.count() == 0){
+            QCOMPARE(afterAboutToRemoveRowCount, beforeRemoveRowCount);
+            QCOMPARE(afterRemoveRowCount, beforeRemoveRowCount-count-(numberOfRowsRemovedSignals-1));
+        }
+        if (modelResetSpy.count() == 0 )
+            QCOMPARE(currentModel->rowCount(parentOfRemoved), beforeRemoveRowCount-count-(numberOfRowsRemovedSignals-1));
+    }
+    else {
+        if (recursive)
+            QCOMPARE(currentModel->rowCount(parentOfRemoved), beforeRemoveRowCount-1);
+        else
+            QCOMPARE(currentModel->rowCount(parentOfRemoved), beforeRemoveRowCount);
+
+    }
+    disconnect(currentModel, SIGNAL(rowsAboutToBeRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsAboutToRemove(const QModelIndex &)));
+    disconnect(currentModel, SIGNAL(rowsRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsRemoved(const QModelIndex &)));
+    modelResetSpy.clear();
+    QCOMPARE(modelResetSpy.count(), 0);
+
+    //
+    // Test remove column
+    //
+    connect(currentModel, SIGNAL(columnsAboutToBeRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsAboutToRemove(const QModelIndex &)));
+    connect(currentModel, SIGNAL(columnsRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsRemoved(const QModelIndex &)));
+    int beforeRemoveColumnCount = currentModel->columnCount(parentOfRemoved);
+
+    // Some models don't let you remove the column, only row
+    if (currentModel->removeColumns(start, count, parentOfRemoved)) {
+        currentModel->submit();
+        // Didn't reset the rows, so they should still be at the same value
+        if (modelResetSpy.count() >= 1 || modelLayoutChangedSpy.count() >= 1){
+            QCOMPARE(columnsAboutToBeRemovedSpy.count(), 0);
+            //QCOMPARE(rowsAboutToBeRemovedSpy.count(), numberOfRowsAboutToBeRemovedSignals);
+            QCOMPARE(columnsRemovedSpy.count(), 0);
+            //QCOMPARE(rowsRemovedSpy.count(), numberOfRowsRemovedSignals);
+        }
+        else {
+            QCOMPARE(columnsAboutToBeRemovedSpy.count(), numberOfColumnsAboutToBeRemovedSignals);
+            QCOMPARE(rowsAboutToBeRemovedSpy.count(), numberOfRowsAboutToBeRemovedSignals);
+            QCOMPARE(columnsRemovedSpy.count(), numberOfColumnsRemovedSignals);
+            QCOMPARE(rowsRemovedSpy.count(), numberOfRowsRemovedSignals);
+        }
+
+        // The column count should only change *after* rowsAboutToBeRemoved has been emited
+        if (shouldSucceed) {
+            if (modelResetSpy.count() == 0 && modelLayoutChangedSpy.count() == 0){
+                QCOMPARE(afterAboutToRemoveColumnCount, beforeRemoveColumnCount);
+                QCOMPARE(afterRemoveColumnCount, beforeRemoveColumnCount-count-(numberOfColumnsRemovedSignals-1));
+            }
+            if (modelResetSpy.count() == 0)
+                QCOMPARE(currentModel->columnCount(parentOfRemoved), beforeRemoveColumnCount-count-(numberOfColumnsRemovedSignals-1));
+        }
+        else
+            QCOMPARE(currentModel->rowCount(parentOfRemoved), beforeRemoveRowCount);
+    }
+    disconnect(currentModel, SIGNAL(columnsAboutToBeRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsAboutToRemove(const QModelIndex &)));
+    disconnect(currentModel, SIGNAL(columnsRemoved( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsRemoved(const QModelIndex &)));
+
+    if (columnsAboutToBeRemovedSpy.count() > 0){
+        QList<QVariant> arguments = columnsAboutToBeRemovedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfRemoved == parent);
+    }
+
+    if (columnsRemovedSpy.count() > 0){
+        QList<QVariant> arguments = columnsRemovedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfRemoved == parent);
+    }
+
+    // Cleanup the test area because remove::() is called multiple times in a test
+    testModels->cleanupTestArea(currentModel);
+}
+
+/*!
+    Developers like to use the slots to then *do* something on the model so it needs to be
+    in a working state.
+ */
+void verifyState(QAbstractItemModel *currentModel) {
+    // Make sure the model isn't confused right now and still knows what is root
+    if (currentModel->hasChildren()) {
+        QCOMPARE(currentModel->hasIndex(0, 0), true);
+        QModelIndex index = currentModel->index(0,0);
+        QCOMPARE(index.isValid(), true);
+        QCOMPARE(currentModel->parent(index).isValid(), false);
+    } else {
+        QModelIndex index = currentModel->index(0,0);
+        QCOMPARE(index.isValid(), false);
+    }
+}
+
+void tst_QItemModel::slot_rowsAboutToRemove(const QModelIndex &parent)
+{
+    QVERIFY(parentOfRemoved == parent);
+    //qDebug() << "slot_rowsAboutToRemove" << currentModel->rowCount(parent);
+    afterAboutToRemoveRowCount = currentModel->rowCount(parent);
+    // hasChildren() should still work
+    if (afterAboutToRemoveRowCount > 0)
+        QCOMPARE(currentModel->hasChildren(parent), true);
+    else
+        QCOMPARE(currentModel->hasChildren(parent), false);
+
+    verifyState(currentModel);
+
+    // This does happen
+    if (removeRecursively) {
+        QFETCH(int, recursiveRow);
+        QFETCH(int, recursiveCount);
+        //qDebug() << recursiveRow << recursiveCount;
+        removeRecursively = false;
+        QCOMPARE(currentModel->removeRows(recursiveRow, recursiveCount, parent), true);
+    }
+}
+
+void tst_QItemModel::slot_rowsRemoved(const QModelIndex &parent)
+{
+    QVERIFY(parentOfRemoved == parent);
+    //qDebug() << "slot_rowsRemoved" << currentModel->rowCount(parent);
+    afterRemoveRowCount = currentModel->rowCount(parent);
+    if (afterRemoveRowCount > 0)
+        QCOMPARE(currentModel->hasChildren(parent), true);
+    else
+        QCOMPARE(currentModel->hasChildren(parent), false);
+
+    verifyState(currentModel);
+}
+
+void tst_QItemModel::slot_columnsAboutToRemove(const QModelIndex &parent)
+{
+    QVERIFY(parentOfRemoved == parent);
+    afterAboutToRemoveColumnCount = currentModel->columnCount(parent);
+    // hasChildren() should still work
+    if (afterAboutToRemoveColumnCount > 0 && currentModel->rowCount(parent) > 0)
+        QCOMPARE(currentModel->hasChildren(parent), true);
+    else
+        QCOMPARE(currentModel->hasChildren(parent), false);
+
+    verifyState(currentModel);
+}
+
+void tst_QItemModel::slot_columnsRemoved(const QModelIndex &parent)
+{
+    QVERIFY(parentOfRemoved == parent);
+    afterRemoveColumnCount = currentModel->columnCount(parent);
+    if (afterRemoveColumnCount > 0)
+        QCOMPARE(currentModel->hasChildren(parent), true);
+    else
+        QCOMPARE(currentModel->hasChildren(parent), false);
+
+    verifyState(currentModel);
+}
+
+/*!
+    Tests the model's insertRow/Column()
+ */
+void tst_QItemModel::insert_data()
+{
+    ModelsToTest modelsToTest;
+    QTest::addColumn<QString>("modelType");
+    QTest::addColumn<bool>("readOnly");
+    QTest::addColumn<bool>("isEmpty");
+
+    QTest::addColumn<int>("start");
+    QTest::addColumn<int>("count");
+
+    QTest::addColumn<int>("numberOfRowsAboutToBeInsertedSignals");
+    QTest::addColumn<int>("numberOfColumnsAboutToBeInsertedSignals");
+    QTest::addColumn<int>("numberOfRowsInsertedSignals");
+    QTest::addColumn<int>("numberOfColumnsInsertedSignals");
+
+    QTest::addColumn<bool>("recursive");
+    QTest::addColumn<int>("recursiveRow");
+    QTest::addColumn<int>("recursiveCount");
+
+    QTest::addColumn<bool>("shouldSucceed");
+
+#define makeTestRow(testName, start, count, sar, srr, sac, src, r, rr, rc, s) \
+        QTest::newRow((t.modelType + testName).toLatin1().data()) << t.modelType << readOnly << isEmpty << \
+        start << count << \
+        sar << srr << sac << src << \
+        r << rr << rc << \
+        s;
+
+    for (int i = 0; i < modelsToTest.tests.size(); ++i) {
+        ModelsToTest::test t = modelsToTest.tests.at(i);
+        QString name = t.modelType;
+        bool readOnly = (t.read == ModelsToTest::ReadOnly);
+        bool isEmpty = (t.contains == ModelsToTest::Empty);
+
+        // half these
+        makeTestRow(":one at the start",  START,  DEFAULTCOUNT, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":one at the middle", MIDDLE, DEFAULTCOUNT, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":one at the end",    END,    DEFAULTCOUNT, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+
+        makeTestRow(":many at the start",  START,  MANY, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":many at the middle", MIDDLE, MANY, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+        makeTestRow(":many at the end",    END,    MANY, DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+
+        makeTestRow(":add row count",        START,  ALL,  DNS, DNS, DNS, DNS, !RECURSIVE, 0, 0, SUCCESS);
+
+        makeTestRow(":none at the start",  START,  0, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":none at the middle", MIDDLE, 0, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":none at the end",    END,    0, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+
+        makeTestRow(":invalid start, valid count", -99,  0,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", 9999, 0,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", -99,  1,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", 9999, 1,    NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", -99,  MANY, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":invalid start, valid count", 9999, MANY, NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+
+        makeTestRow(":valid start, invalid count",  START,  -2,   NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  MIDDLE, -2,   NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+        makeTestRow(":valid start, invalid count",  END,    -2,   NOSIGNALS, NOSIGNALS, NOSIGNALS, NOSIGNALS, !RECURSIVE, 0, 0, FAIL);
+
+        // Recursive insert's might assert, havn't decided yet...
+        //makeTestRow(":one at the start recursivly",  START,  DEFAULTCOUNT, 2, DNS, 2, DNS, RECURSIVE, START, DEFAULTCOUNT, FAIL);
+        //makeTestRow(":one at the middle recursivly", MIDDLE, DEFAULTCOUNT, 2, DNS, 2, DNS, RECURSIVE, START, DEFAULTCOUNT, SUCCESS);
+        //makeTestRow(":one at the end recursivly",    END,    DEFAULTCOUNT, 2, DNS, 2, DNS, RECURSIVE, START, DEFAULTCOUNT, SUCCESS);
+    }
+}
+
+void tst_QItemModel::insert()
+{
+    QFETCH(QString, modelType);
+    currentModel = testModels->createModel(modelType);
+
+    QFETCH(bool, readOnly);
+    if (readOnly)
+        return;
+
+    QFETCH(int, start);
+    QFETCH(int, count);
+
+    QFETCH(bool, recursive);
+    insertRecursively = recursive;
+
+/*!
+    Inserts count number of rows starting at start
+    if count is -1 it inserts all rows
+    if start is -1 then it starts at the last row - count
+ */
+    QFETCH(bool, shouldSucceed);
+
+    // Populate the test area so we can insert something.  See: cleanup()
+    // parentOfInserted is stored so that the slots can make sure parentOfInserted is the index that is emited.
+    parentOfInserted = testModels->populateTestArea(currentModel);
+
+    if (count == -1)
+        count = currentModel->rowCount(parentOfInserted);
+    if (start == -1)
+        start = currentModel->rowCount(parentOfInserted)-count;
+
+    if (currentModel->rowCount(parentOfInserted) == 0 ||
+        currentModel->columnCount(parentOfInserted) == 0) {
+        qWarning() << "model test area doesn't have any rows, can't fully test insert(). Skipping";
+        return;
+    }
+
+    //qDebug() << "insert start:" << start << "count:" << count << "rowCount:" << currentModel->rowCount(parentOfInserted);
+
+    // When a row or column is inserted there should be two signals.
+    // Watch to make sure they are emited and get the row/column count when they do get emited by connecting them to a slot
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    QSignalSpy columnsAboutToBeInsertedSpy(currentModel, SIGNAL(columnsAboutToBeInserted( const QModelIndex &, int , int )));
+    QSignalSpy rowsAboutToBeInsertedSpy(currentModel, SIGNAL(rowsAboutToBeInserted( const QModelIndex &, int , int )));
+    QSignalSpy columnsInsertedSpy(currentModel, SIGNAL(columnsInserted( const QModelIndex &, int, int )));
+    QSignalSpy rowsInsertedSpy(currentModel, SIGNAL(rowsInserted( const QModelIndex &, int, int )));
+    QSignalSpy modelResetSpy(currentModel, SIGNAL(modelReset()));
+    QSignalSpy modelLayoutChangedSpy(currentModel, SIGNAL(layoutChanged()));
+
+    QFETCH(int, numberOfRowsAboutToBeInsertedSignals);
+    QFETCH(int, numberOfColumnsAboutToBeInsertedSignals);
+    QFETCH(int, numberOfRowsInsertedSignals);
+    QFETCH(int, numberOfColumnsInsertedSignals);
+
+    //
+    // test insertRow()
+    //
+    connect(currentModel, SIGNAL(rowsAboutToBeInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsAboutToInserted(const QModelIndex &)));
+    connect(currentModel, SIGNAL(rowsInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsInserted(const QModelIndex &)));
+    int beforeInsertRowCount = currentModel->rowCount(parentOfInserted);
+    QCOMPARE(currentModel->insertRows(start, count, parentOfInserted), shouldSucceed);
+    currentModel->submit();
+
+    if (rowsAboutToBeInsertedSpy.count() > 0){
+        QList<QVariant> arguments = rowsAboutToBeInsertedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfInserted == parent);
+    }
+
+    if (rowsInsertedSpy.count() > 0){
+        QList<QVariant> arguments = rowsInsertedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfInserted == parent);
+    }
+
+    // Only the row signals should have been emited
+    if (modelResetSpy.count() >= 1 || modelLayoutChangedSpy.count() >= 1) {
+        QCOMPARE(columnsAboutToBeInsertedSpy.count(), 0);
+        QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
+        QCOMPARE(columnsInsertedSpy.count(), 0);
+        QCOMPARE(rowsInsertedSpy.count(), 0);
+    }
+    else {
+        QCOMPARE(columnsAboutToBeInsertedSpy.count(), 0);
+        QCOMPARE(rowsAboutToBeInsertedSpy.count(), numberOfRowsAboutToBeInsertedSignals);
+        QCOMPARE(columnsInsertedSpy.count(), 0);
+        QCOMPARE(rowsInsertedSpy.count(), numberOfRowsInsertedSignals);
+    }
+    // The row count should only change *after* rowsAboutToBeInserted has been emited
+    //qDebug() << beforeInsertRowCount << afterAboutToInsertRowCount << afterInsertRowCount << currentModel->rowCount(parentOfInserted);
+    if (shouldSucceed) {
+        if (modelResetSpy.count() == 0 && modelLayoutChangedSpy.count() == 0) {
+            QCOMPARE(afterAboutToInsertRowCount, beforeInsertRowCount);
+            QCOMPARE(afterInsertRowCount, beforeInsertRowCount+count+(numberOfRowsInsertedSignals-1));
+        }
+        if (modelResetSpy.count() == 0)
+            QCOMPARE(currentModel->rowCount(parentOfInserted), beforeInsertRowCount+count+(numberOfRowsInsertedSignals-1));
+    }
+    else {
+        if (recursive)
+            QCOMPARE(currentModel->rowCount(parentOfInserted), beforeInsertRowCount+1);
+        else
+            QCOMPARE(currentModel->rowCount(parentOfInserted), beforeInsertRowCount);
+
+    }
+    disconnect(currentModel, SIGNAL(rowsAboutToBeInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsAboutToInserted(const QModelIndex &)));
+    disconnect(currentModel, SIGNAL(rowsInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_rowsInserted(const QModelIndex &)));
+    modelResetSpy.clear();
+
+    //
+    // Test insertColumn()
+    //
+    connect(currentModel, SIGNAL(columnsAboutToBeInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsAboutToInserted(const QModelIndex &)));
+    connect(currentModel, SIGNAL(columnsInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsInserted(const QModelIndex &)));
+    int beforeInsertColumnCount = currentModel->columnCount(parentOfInserted);
+
+    // Some models don't let you insert the column, only row
+    if (currentModel->insertColumns(start, count, parentOfInserted)) {
+        currentModel->submit();
+        if (modelResetSpy.count() >= 1 || modelLayoutChangedSpy.count() >= 1) {
+            // Didn't reset the rows, so they should still be at the same value
+            QCOMPARE(columnsAboutToBeInsertedSpy.count(), 0);
+            //QCOMPARE(rowsAboutToBeInsertedSpy.count(), numberOfRowsAboutToBeInsertedSignals);
+            QCOMPARE(columnsInsertedSpy.count(), 0);
+            //QCOMPARE(rowsInsertedSpy.count(), numberOfRowsInsertedSignals);
+        }
+        else {
+            // Didn't reset the rows, so they should still be at the same value
+            QCOMPARE(columnsAboutToBeInsertedSpy.count(), numberOfColumnsAboutToBeInsertedSignals);
+            QCOMPARE(rowsAboutToBeInsertedSpy.count(), numberOfRowsAboutToBeInsertedSignals);
+            QCOMPARE(columnsInsertedSpy.count(), numberOfColumnsInsertedSignals);
+            QCOMPARE(rowsInsertedSpy.count(), numberOfRowsInsertedSignals);
+        }
+        // The column count should only change *after* rowsAboutToBeInserted has been emited
+        if (shouldSucceed) {
+            if (modelResetSpy.count() == 0 &&  modelLayoutChangedSpy.count() == 0) {
+                QCOMPARE(afterAboutToInsertColumnCount, beforeInsertColumnCount);
+                QCOMPARE(afterInsertColumnCount, beforeInsertColumnCount+count+(numberOfColumnsInsertedSignals-1));
+            }
+            if (modelResetSpy.count() == 0)
+                QCOMPARE(currentModel->columnCount(parentOfInserted), beforeInsertColumnCount+count+(numberOfColumnsInsertedSignals-1));
+        }
+        else
+            QCOMPARE(currentModel->rowCount(parentOfInserted), beforeInsertRowCount);
+    }
+    disconnect(currentModel, SIGNAL(columnsAboutToBeInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsAboutToInserted(const QModelIndex &)));
+    disconnect(currentModel, SIGNAL(columnsInserted( const QModelIndex &, int , int )),
+            this, SLOT(slot_columnsInserted(const QModelIndex &)));
+
+    if (columnsAboutToBeInsertedSpy.count() > 0){
+        QList<QVariant> arguments = columnsAboutToBeInsertedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfInserted == parent);
+    }
+
+    if (columnsInsertedSpy.count() > 0){
+        QList<QVariant> arguments = columnsInsertedSpy.at(0);
+        QModelIndex parent = (qvariant_cast<QModelIndex>(arguments.at(0)));
+        int first = arguments.at(1).toInt();
+        int last = arguments.at(2).toInt();
+        QCOMPARE(first, start);
+        QCOMPARE(last,  start + count - 1);
+        QVERIFY(parentOfInserted == parent);
+    }
+
+    // Cleanup the test area because insert::() is called multiple times in a test
+    testModels->cleanupTestArea(currentModel);
+}
+
+void tst_QItemModel::slot_rowsAboutToInserted(const QModelIndex &parent)
+{
+    QVERIFY(parentOfInserted == parent);
+    //qDebug() << "slot_rowsAboutToInsert" << currentModel->rowCount(parent);
+    afterAboutToInsertRowCount = currentModel->rowCount(parent);
+    bool hasChildren = currentModel->hasChildren(parent);
+    bool hasDimensions = currentModel->columnCount(parent) > 0 && currentModel->rowCount(parent) > 0;
+    QCOMPARE(hasChildren, hasDimensions);
+    verifyState(currentModel);
+
+    // This does happen
+    if (insertRecursively) {
+        QFETCH(int, recursiveRow);
+        QFETCH(int, recursiveCount);
+        //qDebug() << recursiveRow << recursiveCount;
+        insertRecursively = false;
+        QCOMPARE(currentModel->insertRows(recursiveRow, recursiveCount, parent), true);
+    }
+}
+
+void tst_QItemModel::slot_rowsInserted(const QModelIndex &parent)
+{
+    QVERIFY(parentOfInserted == parent);
+    afterInsertRowCount = currentModel->rowCount(parent);
+    bool hasChildren = currentModel->hasChildren(parent);
+    bool hasDimensions = currentModel->columnCount(parent) > 0 && currentModel->rowCount(parent) > 0;
+    QCOMPARE(hasChildren, hasDimensions);
+    verifyState(currentModel);
+}
+
+void tst_QItemModel::slot_columnsAboutToInserted(const QModelIndex &parent)
+{
+    QVERIFY(parentOfInserted == parent);
+    afterAboutToInsertColumnCount = currentModel->columnCount(parent);
+    bool hasChildren = currentModel->hasChildren(parent);
+    bool hasDimensions = currentModel->columnCount(parent) > 0 && currentModel->rowCount(parent) > 0;
+    QCOMPARE(hasChildren, hasDimensions);
+    verifyState(currentModel);
+}
+
+void tst_QItemModel::slot_columnsInserted(const QModelIndex &parent)
+{
+    QVERIFY(parentOfInserted == parent);
+    afterInsertColumnCount = currentModel->columnCount(parent);
+    bool hasChildren = currentModel->hasChildren(parent);
+    bool hasDimensions = currentModel->columnCount(parent) > 0 && currentModel->rowCount(parent) > 0;
+    QCOMPARE(hasChildren, hasDimensions);
+    verifyState(currentModel);
+}
+
+QTEST_MAIN(tst_QItemModel)
+#include "tst_qitemmodel.moc"