modeltest: code reformatting to the Qt coding style, using uncrustify

Change-Id: I39026fe0dbc0dacfada5ec2dc6dd81f20b05967c
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>

5 files changed, 463 insertions, 460 deletions

diff --git a/tests/auto/other/modeltest/dynamictreemodel.cpp b/tests/auto/other/modeltest/dynamictreemodel.cpp
index 1f6463db8a..fc979bce2d 100644
--- a/tests/auto/other/modeltest/dynamictreemodel.cpp
+++ b/tests/auto/other/modeltest/dynamictreemodel.cpp
@@ -33,9 +33,8 @@
 #include <QtCore/QTimer>
 #include <QtCore/QDebug>
 
-
-DynamicTreeModel::DynamicTreeModel(QObject *parent)
-  : QAbstractItemModel(parent),
+DynamicTreeModel::DynamicTreeModel(QObject *parent) :
+    QAbstractItemModel(parent),
     nextId(1)
 {
 }
@@ -45,186 +44,172 @@ QModelIndex DynamicTreeModel::index(int row, int column, const QModelIndex &pare
 //   if (column != 0)
 //     return QModelIndex();
 
+    if (column < 0 || row < 0)
+        return QModelIndex();
 
-  if ( column < 0 || row < 0 )
-    return QModelIndex();
-
-  QList<QList<qint64> > childIdColumns = m_childItems.value(parent.internalId());
+    QList<QList<qint64> > childIdColumns = m_childItems.value(parent.internalId());
 
-  const qint64 grandParent = findParentId(parent.internalId());
-  if (grandParent >= 0) {
-    QList<QList<qint64> > parentTable = m_childItems.value(grandParent);
-    if (parent.column() >= parentTable.size())
-        qFatal("%s: parent.column() must be less than parentTable.size()", Q_FUNC_INFO);
-    QList<qint64> parentSiblings = parentTable.at(parent.column());
-    if (parent.row() >= parentSiblings.size())
-        qFatal("%s: parent.row() must be less than parentSiblings.size()", Q_FUNC_INFO);
-  }
-
-  if (childIdColumns.size() == 0)
-    return QModelIndex();
+    const qint64 grandParent = findParentId(parent.internalId());
+    if (grandParent >= 0) {
+        QList<QList<qint64> > parentTable = m_childItems.value(grandParent);
+        if (parent.column() >= parentTable.size())
+            qFatal("%s: parent.column() must be less than parentTable.size()", Q_FUNC_INFO);
+        QList<qint64> parentSiblings = parentTable.at(parent.column());
+        if (parent.row() >= parentSiblings.size())
+            qFatal("%s: parent.row() must be less than parentSiblings.size()", Q_FUNC_INFO);
+    }
 
-  if (column >= childIdColumns.size())
-    return QModelIndex();
+    if (childIdColumns.size() == 0)
+        return QModelIndex();
 
-  QList<qint64> rowIds = childIdColumns.at(column);
+    if (column >= childIdColumns.size())
+        return QModelIndex();
 
-  if ( row >= rowIds.size())
-    return QModelIndex();
+    QList<qint64> rowIds = childIdColumns.at(column);
 
-  qint64 id = rowIds.at(row);
+    if (row >= rowIds.size())
+        return QModelIndex();
 
-  return createIndex(row, column, reinterpret_cast<void *>(id));
+    qint64 id = rowIds.at(row);
 
+    return createIndex(row, column, reinterpret_cast<void *>(id));
 }
 
 qint64 DynamicTreeModel::findParentId(qint64 searchId) const
 {
-  if (searchId <= 0)
-    return -1;
-
-  QHashIterator<qint64, QList<QList<qint64> > > i(m_childItems);
-  while (i.hasNext())
-  {
-    i.next();
-    QListIterator<QList<qint64> > j(i.value());
-    while (j.hasNext())
-    {
-      QList<qint64> l = j.next();
-      if (l.contains(searchId))
-      {
-        return i.key();
-      }
+    if (searchId <= 0)
+        return -1;
+
+    QHashIterator<qint64, QList<QList<qint64> > > i(m_childItems);
+    while (i.hasNext()) {
+        i.next();
+        QListIterator<QList<qint64> > j(i.value());
+        while (j.hasNext()) {
+            QList<qint64> l = j.next();
+            if (l.contains(searchId))
+                return i.key();
+        }
     }
-  }
-  return -1;
+    return -1;
 }
 
 QModelIndex DynamicTreeModel::parent(const QModelIndex &index) const
 {
-  if (!index.isValid())
-    return QModelIndex();
+    if (!index.isValid())
+        return QModelIndex();
 
-  qint64 searchId = index.internalId();
-  qint64 parentId = findParentId(searchId);
-  // Will never happen for valid index, but what the hey...
-  if (parentId <= 0)
-    return QModelIndex();
+    qint64 searchId = index.internalId();
+    qint64 parentId = findParentId(searchId);
+    // Will never happen for valid index, but what the hey...
+    if (parentId <= 0)
+        return QModelIndex();
 
-  qint64 grandParentId = findParentId(parentId);
-  if (grandParentId < 0)
-    grandParentId = 0;
+    qint64 grandParentId = findParentId(parentId);
+    if (grandParentId < 0)
+        grandParentId = 0;
 
-  int column = 0;
-  QList<qint64> childList = m_childItems.value(grandParentId).at(column);
+    int column = 0;
+    QList<qint64> childList = m_childItems.value(grandParentId).at(column);
 
-  int row = childList.indexOf(parentId);
-
-  return createIndex(row, column, reinterpret_cast<void *>(parentId));
+    int row = childList.indexOf(parentId);
 
+    return createIndex(row, column, reinterpret_cast<void *>(parentId));
 }
 
-int DynamicTreeModel::rowCount(const QModelIndex &index ) const
+int DynamicTreeModel::rowCount(const QModelIndex &index) const
 {
-  QList<QList<qint64> > cols = m_childItems.value(index.internalId());
+    QList<QList<qint64> > cols = m_childItems.value(index.internalId());
 
-  if (cols.size() == 0 )
-    return 0;
+    if (cols.size() == 0)
+        return 0;
 
-  if (index.column() > 0)
-    return 0;
+    if (index.column() > 0)
+        return 0;
 
-  return cols.at(0).size();
+    return cols.at(0).size();
 }
 
-int DynamicTreeModel::columnCount(const QModelIndex &index ) const
+int DynamicTreeModel::columnCount(const QModelIndex &index) const
 {
 //   Q_UNUSED(index);
-  return m_childItems.value(index.internalId()).size();
+    return m_childItems.value(index.internalId()).size();
 }
 
 QVariant DynamicTreeModel::data(const QModelIndex &index, int role) const
 {
-  if (!index.isValid())
-    return QVariant();
+    if (!index.isValid())
+        return QVariant();
 
-  if (Qt::DisplayRole == role)
-  {
-    return m_items.value(index.internalId());
-  }
-  return QVariant();
+    if (Qt::DisplayRole == role)
+        return m_items.value(index.internalId());
+    return QVariant();
 }
 
 void DynamicTreeModel::clear()
 {
-  beginResetModel();
-  m_items.clear();
-  m_childItems.clear();
-  nextId = 1;
-  endResetModel();
+    beginResetModel();
+    m_items.clear();
+    m_childItems.clear();
+    nextId = 1;
+    endResetModel();
 }
 
-
-ModelChangeCommand::ModelChangeCommand( DynamicTreeModel *model, QObject *parent )
-    : QObject(parent), m_model(model), m_numCols(1), m_startRow(-1), m_endRow(-1)
+ModelChangeCommand::ModelChangeCommand(DynamicTreeModel *model, QObject *parent) :
+    QObject(parent),
+    m_model(model),
+    m_numCols(1),
+    m_startRow(-1),
+    m_endRow(-1)
 {
-
 }
 
 QModelIndex ModelChangeCommand::findIndex(QList<int> rows)
 {
-  const int col = 0;
-  QModelIndex parent = QModelIndex();
-  QListIterator<int> i(rows);
-  while (i.hasNext())
-  {
-    parent = m_model->index(i.next(), col, parent);
-    if (!parent.isValid())
-        qFatal("%s: parent must be valid", Q_FUNC_INFO);
-  }
-  return parent;
+    const int col = 0;
+    QModelIndex parent = QModelIndex();
+    QListIterator<int> i(rows);
+    while (i.hasNext()) {
+        parent = m_model->index(i.next(), col, parent);
+        if (!parent.isValid())
+            qFatal("%s: parent must be valid", Q_FUNC_INFO);
+    }
+    return parent;
 }
 
-ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent )
-    : ModelChangeCommand(model, parent)
+ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent) :
+    ModelChangeCommand(model, parent)
 {
-
 }
 
 void ModelInsertCommand::doCommand()
 {
-  QModelIndex parent = findIndex(m_rowNumbers);
-  m_model->beginInsertRows(parent, m_startRow, m_endRow);
-  qint64 parentId = parent.internalId();
-  for (int row = m_startRow; row <= m_endRow; row++)
-  {
-    for(int col = 0; col < m_numCols; col++ )
-    {
-      if (m_model->m_childItems[parentId].size() <= col)
-      {
-        m_model->m_childItems[parentId].append(QList<qint64>());
-      }
+    QModelIndex parent = findIndex(m_rowNumbers);
+    m_model->beginInsertRows(parent, m_startRow, m_endRow);
+    qint64 parentId = parent.internalId();
+    for (int row = m_startRow; row <= m_endRow; row++) {
+        for (int col = 0; col < m_numCols; col++) {
+            if (m_model->m_childItems[parentId].size() <= col)
+                m_model->m_childItems[parentId].append(QList<qint64>());
 //       QString name = QUuid::createUuid().toString();
-      qint64 id = m_model->newId();
-      QString name = QString::number(id);
-
-      m_model->m_items.insert(id, name);
-      m_model->m_childItems[parentId][col].insert(row, id);
+            qint64 id = m_model->newId();
+            QString name = QString::number(id);
 
+            m_model->m_items.insert(id, name);
+            m_model->m_childItems[parentId][col].insert(row, id);
+        }
     }
-  }
-  m_model->endInsertRows();
+    m_model->endInsertRows();
 }
 
-
-ModelMoveCommand::ModelMoveCommand(DynamicTreeModel *model, QObject *parent)
-  : ModelChangeCommand(model, parent)
+ModelMoveCommand::ModelMoveCommand(DynamicTreeModel *model, QObject *parent) :
+    ModelChangeCommand(model, parent)
 {
-
 }
-bool ModelMoveCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
+
+bool ModelMoveCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd,
+                                     const QModelIndex &destParent, int destRow)
 {
-  return m_model->beginMoveRows(srcParent, srcStart, srcEnd, destParent, destRow);
+    return m_model->beginMoveRows(srcParent, srcStart, srcEnd, destParent, destRow);
 }
 
 void ModelMoveCommand::doCommand()
@@ -233,33 +218,26 @@ void ModelMoveCommand::doCommand()
     QModelIndex destParent = findIndex(m_destRowNumbers);
 
     if (!emitPreSignal(srcParent, m_startRow, m_endRow, destParent, m_destRow))
-    {
         return;
-    }
 
-    for (int column = 0; column < m_numCols; ++column)
-    {
-        QList<qint64> l = m_model->m_childItems.value(srcParent.internalId())[column].mid(m_startRow, m_endRow - m_startRow + 1 );
+    for (int column = 0; column < m_numCols; ++column) {
+        QList<qint64> l = m_model->m_childItems.value(srcParent.internalId())[column].mid(
+            m_startRow, m_endRow - m_startRow + 1);
 
-        for (int i = m_startRow; i <= m_endRow ; i++)
-        {
+        for (int i = m_startRow; i <= m_endRow; i++)
             m_model->m_childItems[srcParent.internalId()][column].removeAt(m_startRow);
-        }
         int d;
-        if (m_destRow < m_startRow)
+        if (m_destRow < m_startRow) {
             d = m_destRow;
-        else
-        {
+        } else {
             if (srcParent == destParent)
                 d = m_destRow - (m_endRow - m_startRow + 1);
             else
                 d = m_destRow - (m_endRow - m_startRow) + 1;
         }
 
-        foreach(const qint64 id, l)
-        {
+        foreach (const qint64 id, l)
             m_model->m_childItems[destParent.internalId()][column].insert(d++, id);
-        }
     }
 
     emitPostSignal();
@@ -270,18 +248,17 @@ void ModelMoveCommand::emitPostSignal()
     m_model->endMoveRows();
 }
 
-ModelResetCommand::ModelResetCommand(DynamicTreeModel* model, QObject* parent)
-  : ModelMoveCommand(model, parent)
+ModelResetCommand::ModelResetCommand(DynamicTreeModel *model, QObject *parent) :
+    ModelMoveCommand(model, parent)
 {
-
 }
 
 ModelResetCommand::~ModelResetCommand()
 {
-
 }
 
-bool ModelResetCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
+bool ModelResetCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd,
+                                      const QModelIndex &destParent, int destRow)
 {
     Q_UNUSED(srcParent);
     Q_UNUSED(srcStart);
@@ -298,18 +275,17 @@ void ModelResetCommand::emitPostSignal()
     m_model->endResetModel();
 }
 
-ModelResetCommandFixed::ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent)
-  : ModelMoveCommand(model, parent)
+ModelResetCommandFixed::ModelResetCommandFixed(DynamicTreeModel *model, QObject *parent) :
+    ModelMoveCommand(model, parent)
 {
-
 }
 
 ModelResetCommandFixed::~ModelResetCommandFixed()
 {
-
 }
 
-bool ModelResetCommandFixed::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
+bool ModelResetCommandFixed::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd,
+                                           const QModelIndex &destParent, int destRow)
 {
     Q_UNUSED(srcParent);
     Q_UNUSED(srcStart);
@@ -326,10 +302,10 @@ void ModelResetCommandFixed::emitPostSignal()
     m_model->endResetModel();
 }
 
-ModelChangeChildrenLayoutsCommand::ModelChangeChildrenLayoutsCommand(DynamicTreeModel* model, QObject* parent)
-  : ModelChangeCommand(model, parent)
+ModelChangeChildrenLayoutsCommand::ModelChangeChildrenLayoutsCommand(DynamicTreeModel *model,
+                                                                     QObject *parent) :
+    ModelChangeCommand(model, parent)
 {
-
 }
 
 void ModelChangeChildrenLayoutsCommand::doCommand()
@@ -346,17 +322,16 @@ void ModelChangeChildrenLayoutsCommand::doCommand()
     int rowSize1 = -1;
     int rowSize2 = -1;
 
-    for (int column = 0; column < m_numCols; ++column)
-    {
+    for (int column = 0; column < m_numCols; ++column) {
         {
-          QList<qint64> &l = m_model->m_childItems[parent1.internalId()][column];
-          rowSize1 = l.size();
-          l.prepend(l.takeLast());
+            QList<qint64> &l = m_model->m_childItems[parent1.internalId()][column];
+            rowSize1 = l.size();
+            l.prepend(l.takeLast());
         }
         {
-          QList<qint64> &l = m_model->m_childItems[parent2.internalId()][column];
-          rowSize2 = l.size();
-          l.append(l.takeFirst());
+            QList<qint64> &l = m_model->m_childItems[parent2.internalId()][column];
+            rowSize2 = l.size();
+            l.append(l.takeFirst());
         }
     }
 
@@ -373,15 +348,23 @@ void ModelChangeChildrenLayoutsCommand::doCommand()
     foreach (const QModelIndex &idx, persistent) {
         if (idx.parent() == parent1) {
             if (idx.row() == rowSize1 - 1) {
-                m_model->changePersistentIndex(idx, m_model->createIndex(0, idx.column(), idx.internalPointer()));
+                m_model->changePersistentIndex(idx,
+                                               m_model->createIndex(0, idx.column(),
+                                                                    idx.internalPointer()));
             } else {
-                m_model->changePersistentIndex(idx, m_model->createIndex(idx.row() + 1, idx.column(), idx.internalPointer()));
+                m_model->changePersistentIndex(idx,
+                                               m_model->createIndex(idx.row() + 1, idx.column(),
+                                                                    idx.internalPointer()));
             }
         } else if (idx.parent() == parent2) {
             if (idx.row() == 0) {
-                m_model->changePersistentIndex(idx, m_model->createIndex(rowSize2 - 1, idx.column(), idx.internalPointer()));
+                m_model->changePersistentIndex(idx,
+                                               m_model->createIndex(rowSize2 - 1, idx.column(),
+                                                                    idx.internalPointer()));
             } else {
-                m_model->changePersistentIndex(idx, m_model->createIndex(idx.row() - 1, idx.column(), idx.internalPointer()));
+                m_model->changePersistentIndex(idx,
+                                               m_model->createIndex(idx.row() - 1, idx.column(),
+                                                                    idx.internalPointer()));
             }
         }
     }
diff --git a/tests/auto/other/modeltest/dynamictreemodel.h b/tests/auto/other/modeltest/dynamictreemodel.h
index e31c4569fd..709751dd27 100644
--- a/tests/auto/other/modeltest/dynamictreemodel.h
+++ b/tests/auto/other/modeltest/dynamictreemodel.h
@@ -34,119 +34,142 @@
 #include <QtCore/QHash>
 #include <QtCore/QList>
 
-
 class DynamicTreeModel : public QAbstractItemModel
 {
-  Q_OBJECT
+    Q_OBJECT
 
 public:
-  DynamicTreeModel(QObject *parent = 0);
+    DynamicTreeModel(QObject *parent = 0);
 
-  QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
-  QModelIndex parent(const QModelIndex &index) const;
-  int rowCount(const QModelIndex &index = QModelIndex()) const;
-  int columnCount(const QModelIndex &index = QModelIndex()) const;
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex &index) const;
+    int rowCount(const QModelIndex &index = QModelIndex()) const;
+    int columnCount(const QModelIndex &index = QModelIndex()) const;
 
-  QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
 
-  void clear();
+    void clear();
 
 protected slots:
 
-  /**
-  Finds the parent id of the string with id @p searchId.
+    /**
+    Finds the parent id of the string with id @p searchId.
 
-  Returns -1 if not found.
-  */
-  qint64 findParentId(qint64 searchId) const;
+    Returns -1 if not found.
+    */
+    qint64 findParentId(qint64 searchId) const;
 
 private:
-  QHash<qint64, QString> m_items;
-  QHash<qint64, QList<QList<qint64> > > m_childItems;
-  qint64 nextId;
-  qint64 newId() { return nextId++; };
-
-  QModelIndex m_nextParentIndex;
-  int m_nextRow;
-
-  int m_depth;
-  int maxDepth;
-
-  friend class ModelInsertCommand;
-  friend class ModelMoveCommand;
-  friend class ModelResetCommand;
-  friend class ModelResetCommandFixed;
-  friend class ModelChangeChildrenLayoutsCommand;
-
+    QHash<qint64, QString> m_items;
+    QHash<qint64, QList<QList<qint64> > > m_childItems;
+    qint64 nextId;
+    qint64 newId()
+    {
+        return nextId++;
+    }
+
+    QModelIndex m_nextParentIndex;
+    int m_nextRow;
+
+    int m_depth;
+    int maxDepth;
+
+    friend class ModelInsertCommand;
+    friend class ModelMoveCommand;
+    friend class ModelResetCommand;
+    friend class ModelResetCommandFixed;
+    friend class ModelChangeChildrenLayoutsCommand;
 };
 
-
 class ModelChangeCommand : public QObject
 {
-  Q_OBJECT
+    Q_OBJECT
 public:
 
-  ModelChangeCommand( DynamicTreeModel *model, QObject *parent = 0 );
+    ModelChangeCommand(DynamicTreeModel *model, QObject *parent = 0);
 
-  virtual ~ModelChangeCommand() {}
+    virtual ~ModelChangeCommand()
+    {
+    }
 
-  void setAncestorRowNumbers(QList<int> rowNumbers) { m_rowNumbers = rowNumbers; }
+    void setAncestorRowNumbers(QList<int> rowNumbers)
+    {
+        m_rowNumbers = rowNumbers;
+    }
 
-  QModelIndex findIndex(QList<int> rows);
+    QModelIndex findIndex(QList<int> rows);
 
-  void setStartRow(int row) { m_startRow = row; }
+    void setStartRow(int row)
+    {
+        m_startRow = row;
+    }
 
-  void setEndRow(int row) { m_endRow = row; }
+    void setEndRow(int row)
+    {
+        m_endRow = row;
+    }
 
-  void setNumCols(int cols) { m_numCols = cols; }
+    void setNumCols(int cols)
+    {
+        m_numCols = cols;
+    }
 
-  virtual void doCommand() = 0;
+    virtual void doCommand() = 0;
 
 protected:
-  DynamicTreeModel* m_model;
-  QList<int> m_rowNumbers;
-  int m_numCols;
-  int m_startRow;
-  int m_endRow;
-
+    DynamicTreeModel *m_model;
+    QList<int> m_rowNumbers;
+    int m_numCols;
+    int m_startRow;
+    int m_endRow;
 };
 
-typedef QList<ModelChangeCommand*> ModelChangeCommandList;
+typedef QList<ModelChangeCommand *> ModelChangeCommandList;
 
 class ModelInsertCommand : public ModelChangeCommand
 {
-  Q_OBJECT
+    Q_OBJECT
 
 public:
 
-  ModelInsertCommand(DynamicTreeModel *model, QObject *parent = 0 );
-  virtual ~ModelInsertCommand() {}
+    ModelInsertCommand(DynamicTreeModel *model, QObject *parent = 0);
+    virtual ~ModelInsertCommand()
+    {
+    }
 
-  virtual void doCommand();
+    virtual void doCommand();
 };
 
-
 class ModelMoveCommand : public ModelChangeCommand
 {
-  Q_OBJECT
+    Q_OBJECT
 public:
-  ModelMoveCommand(DynamicTreeModel *model, QObject *parent);
+    ModelMoveCommand(DynamicTreeModel *model, QObject *parent);
 
-  virtual ~ModelMoveCommand() {}
+    virtual ~ModelMoveCommand()
+    {
+    }
 
-  virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
+    virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd,
+                               const QModelIndex &destParent, int destRow);
 
-  virtual void doCommand();
+    virtual void doCommand();
 
-  virtual void emitPostSignal();
+    virtual void emitPostSignal();
 
-  void setDestAncestors( QList<int> rows ) { m_destRowNumbers = rows; }
+    void setDestAncestors(QList<int> rows)
+    {
+        m_destRowNumbers = rows;
+    }
 
-  void setDestRow(int row) { m_destRow = row; }
+    void setDestRow(int row)
+    {
+        m_destRow = row;
+    }
 
 protected:
-  QList<int> m_destRowNumbers;
-  int m_destRow;
+    QList<int> m_destRowNumbers;
+    int m_destRow;
 };
 
 /**
@@ -154,15 +177,15 @@ protected:
 */
 class ModelResetCommand : public ModelMoveCommand
 {
-  Q_OBJECT
+    Q_OBJECT
 public:
-  ModelResetCommand(DynamicTreeModel* model, QObject* parent = 0);
+    ModelResetCommand(DynamicTreeModel *model, QObject *parent = 0);
 
-  virtual ~ModelResetCommand();
-
-  virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
-  virtual void emitPostSignal();
+    virtual ~ModelResetCommand();
 
+    virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd,
+                               const QModelIndex &destParent, int destRow);
+    virtual void emitPostSignal();
 };
 
 /**
@@ -170,32 +193,37 @@ public:
 */
 class ModelResetCommandFixed : public ModelMoveCommand
 {
-  Q_OBJECT
+    Q_OBJECT
 public:
-  ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent = 0);
-
-  virtual ~ModelResetCommandFixed();
+    ModelResetCommandFixed(DynamicTreeModel *model, QObject *parent = 0);
 
-  virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
-  virtual void emitPostSignal();
+    virtual ~ModelResetCommandFixed();
 
+    virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd,
+                               const QModelIndex &destParent, int destRow);
+    virtual void emitPostSignal();
 };
 
 class ModelChangeChildrenLayoutsCommand : public ModelChangeCommand
 {
-  Q_OBJECT
+    Q_OBJECT
 public:
-  ModelChangeChildrenLayoutsCommand(DynamicTreeModel *model, QObject *parent);
+    ModelChangeChildrenLayoutsCommand(DynamicTreeModel *model, QObject *parent);
 
-  virtual ~ModelChangeChildrenLayoutsCommand() {}
+    virtual ~ModelChangeChildrenLayoutsCommand()
+    {
+    }
 
-  virtual void doCommand();
+    virtual void doCommand();
 
-  void setSecondAncestorRowNumbers( QList<int> rows ) { m_secondRowNumbers = rows; }
+    void setSecondAncestorRowNumbers(QList<int> rows)
+    {
+        m_secondRowNumbers = rows;
+    }
 
 protected:
-  QList<int> m_secondRowNumbers;
-  int m_destRow;
+    QList<int> m_secondRowNumbers;
+    int m_destRow;
 };
 
 #endif
diff --git a/tests/auto/other/modeltest/modeltest.cpp b/tests/auto/other/modeltest/modeltest.cpp
index 4da00bda4d..76d23d0091 100644
--- a/tests/auto/other/modeltest/modeltest.cpp
+++ b/tests/auto/other/modeltest/modeltest.cpp
@@ -34,60 +34,62 @@
 /*!
     Connect to all of the models signals.  Whenever anything happens recheck everything.
 */
-ModelTest::ModelTest ( QAbstractItemModel *_model, QObject *parent ) : QObject ( parent ), model ( _model ), fetchingMore ( false )
+ModelTest::ModelTest(QAbstractItemModel *_model, QObject *parent) : QObject(parent),
+    model(_model),
+    fetchingMore(false)
 {
     if (!model)
         qFatal("%s: model must not be null", Q_FUNC_INFO);
 
     connect(model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(columnsInserted(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
-            this, SLOT(runAllTests()) );
+            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()) );
+            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(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
     connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
-            this, SLOT(runAllTests()) );
+            this, SLOT(runAllTests()));
 
     // Special checks for changes
     connect(model, SIGNAL(layoutAboutToBeChanged()),
-            this, SLOT(layoutAboutToBeChanged()) );
+            this, SLOT(layoutAboutToBeChanged()));
     connect(model, SIGNAL(layoutChanged()),
-            this, SLOT(layoutChanged()) );
+            this, SLOT(layoutChanged()));
 
     connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
-            this, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)) );
+            this, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)));
     connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
-            this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)) );
+            this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
     connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
-            this, SLOT(rowsInserted(QModelIndex,int,int)) );
+            this, SLOT(rowsInserted(QModelIndex,int,int)));
     connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
-            this, SLOT(rowsRemoved(QModelIndex,int,int)) );
+            this, SLOT(rowsRemoved(QModelIndex,int,int)));
     connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
-            this, SLOT(dataChanged(QModelIndex,QModelIndex)) );
+            this, SLOT(dataChanged(QModelIndex,QModelIndex)));
     connect(model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
-            this, SLOT(headerDataChanged(Qt::Orientation,int,int)) );
+            this, SLOT(headerDataChanged(Qt::Orientation,int,int)));
 
     runAllTests();
 }
 
 void ModelTest::runAllTests()
 {
-    if ( fetchingMore )
+    if (fetchingMore)
         return;
     nonDestructiveBasicTest();
     rowCount();
@@ -105,31 +107,31 @@ void ModelTest::runAllTests()
 void ModelTest::nonDestructiveBasicTest()
 {
     QVERIFY(!model->buddy(QModelIndex()).isValid());
-    model->canFetchMore ( QModelIndex() );
-    QVERIFY( model->columnCount ( QModelIndex() ) >= 0 );
+    model->canFetchMore(QModelIndex());
+    QVERIFY(model->columnCount(QModelIndex()) >= 0);
     QCOMPARE(model->data(QModelIndex()), QVariant());
     fetchingMore = true;
-    model->fetchMore ( QModelIndex() );
+    model->fetchMore(QModelIndex());
     fetchingMore = false;
-    Qt::ItemFlags flags = model->flags ( QModelIndex() );
-    QVERIFY( flags == Qt::ItemIsDropEnabled || flags == 0 );
-    model->hasChildren ( QModelIndex() );
-    model->hasIndex ( 0, 0 );
-    model->headerData ( 0, Qt::Horizontal );
-    model->index ( 0, 0 );
-    model->itemData ( QModelIndex() );
+    Qt::ItemFlags flags = model->flags(QModelIndex());
+    QVERIFY(flags == Qt::ItemIsDropEnabled || flags == 0);
+    model->hasChildren(QModelIndex());
+    model->hasIndex(0, 0);
+    model->headerData(0, Qt::Horizontal);
+    model->index(0, 0);
+    model->itemData(QModelIndex());
     QVariant cache;
-    model->match ( QModelIndex(), -1, cache );
+    model->match(QModelIndex(), -1, cache);
     model->mimeTypes();
     QVERIFY(!model->parent(QModelIndex()).isValid());
-    QVERIFY( model->rowCount() >= 0 );
+    QVERIFY(model->rowCount() >= 0);
     QVariant variant;
-    model->setData ( QModelIndex(), variant, -1 );
-    model->setHeaderData ( -1, Qt::Horizontal, QVariant() );
-    model->setHeaderData ( 999999, Qt::Horizontal, QVariant() );
+    model->setData(QModelIndex(), variant, -1);
+    model->setHeaderData(-1, Qt::Horizontal, QVariant());
+    model->setHeaderData(999999, Qt::Horizontal, QVariant());
     QMap<int, QVariant> roles;
-    model->sibling ( 0, 0, QModelIndex() );
-    model->span ( QModelIndex() );
+    model->sibling(0, 0, QModelIndex());
+    model->span(QModelIndex());
     model->supportedDropActions();
 }
 
@@ -142,19 +144,19 @@ void ModelTest::rowCount()
 {
 //     qDebug() << "rc";
     // check top row
-    QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );
-    int rows = model->rowCount ( topIndex );
-    QVERIFY( rows >= 0 );
-    if ( rows > 0 )
-        QVERIFY( model->hasChildren ( topIndex ) );
-
-    QModelIndex secondLevelIndex = model->index ( 0, 0, topIndex );
-    if ( secondLevelIndex.isValid() ) { // not the top level
+    QModelIndex topIndex = model->index(0, 0, QModelIndex());
+    int rows = model->rowCount(topIndex);
+    QVERIFY(rows >= 0);
+    if (rows > 0)
+        QVERIFY(model->hasChildren(topIndex));
+
+    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 );
-        QVERIFY( rows >= 0 );
-        if ( rows > 0 )
-            QVERIFY( model->hasChildren ( secondLevelIndex ) );
+        rows = model->rowCount(secondLevelIndex);
+        QVERIFY(rows >= 0);
+        if (rows > 0)
+            QVERIFY(model->hasChildren(secondLevelIndex));
     }
 
     // The models rowCount() is tested more extensively in checkChildren(),
@@ -167,13 +169,13 @@ void ModelTest::rowCount()
 void ModelTest::columnCount()
 {
     // check top row
-    QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );
-    QVERIFY( model->columnCount ( topIndex ) >= 0 );
+    QModelIndex topIndex = model->index(0, 0, QModelIndex());
+    QVERIFY(model->columnCount(topIndex) >= 0);
 
     // check a column count where parent is valid
-    QModelIndex childIndex = model->index ( 0, 0, topIndex );
-    if ( childIndex.isValid() )
-        QVERIFY( model->columnCount ( childIndex ) >= 0 );
+    QModelIndex childIndex = model->index(0, 0, topIndex);
+    if (childIndex.isValid())
+        QVERIFY(model->columnCount(childIndex) >= 0);
 
     // columnCount() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
@@ -186,19 +188,19 @@ void ModelTest::hasIndex()
 {
 //     qDebug() << "hi";
     // Make sure that invalid values returns an invalid index
-    QVERIFY( !model->hasIndex ( -2, -2 ) );
-    QVERIFY( !model->hasIndex ( -2, 0 ) );
-    QVERIFY( !model->hasIndex ( 0, -2 ) );
+    QVERIFY(!model->hasIndex(-2, -2));
+    QVERIFY(!model->hasIndex(-2, 0));
+    QVERIFY(!model->hasIndex(0, -2));
 
     int rows = model->rowCount();
     int columns = model->columnCount();
 
     // check out of bounds
-    QVERIFY( !model->hasIndex ( rows, columns ) );
-    QVERIFY( !model->hasIndex ( rows + 1, columns + 1 ) );
+    QVERIFY(!model->hasIndex(rows, columns));
+    QVERIFY(!model->hasIndex(rows + 1, columns + 1));
 
-    if ( rows > 0 )
-        QVERIFY( model->hasIndex ( 0, 0 ) );
+    if (rows > 0)
+        QVERIFY(model->hasIndex(0, 0));
 
     // hasIndex() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
@@ -218,7 +220,7 @@ void ModelTest::index()
     int rows = model->rowCount();
     int columns = model->columnCount();
 
-    if ( rows == 0 )
+    if (rows == 0)
         return;
 
     // Catch off by one errors
@@ -226,8 +228,8 @@ void ModelTest::index()
     QVERIFY(model->index(0, 0).isValid());
 
     // Make sure that the same index is *always* returned
-    QModelIndex a = model->index ( 0, 0 );
-    QModelIndex b = model->index ( 0, 0 );
+    QModelIndex a = model->index(0, 0);
+    QModelIndex b = model->index(0, 0);
     QCOMPARE(a, b);
 
     // index() is tested more extensively in checkChildren(),
@@ -244,7 +246,7 @@ void ModelTest::parent()
     // when asked for the parent of an invalid index.
     QVERIFY(!model->parent(QModelIndex()).isValid());
 
-    if ( model->rowCount() == 0 )
+    if (model->rowCount() == 0)
         return;
 
     // Column 0                | Column 1    |
@@ -254,29 +256,29 @@ void ModelTest::parent()
 
     // 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() );
+    QModelIndex topIndex = model->index(0, 0, QModelIndex());
     QVERIFY(!model->parent(topIndex).isValid());
 
     // 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 );
+    if (model->rowCount(topIndex) > 0) {
+        QModelIndex childIndex = model->index(0, 0, topIndex);
         QCOMPARE(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 );
-        QVERIFY( childIndex != childIndex1 );
+    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);
+        QVERIFY(childIndex != childIndex1);
     }
 
     // Full test, walk n levels deep through the model making sure that all
     // parent's children correctly specify their parent.
-    checkChildren ( QModelIndex() );
+    checkChildren(QModelIndex());
 }
 
 /*!
@@ -293,73 +295,73 @@ void ModelTest::parent()
     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 )
+void ModelTest::checkChildren(const QModelIndex &parent, int currentDepth)
 {
     // First just try walking back up the tree.
     QModelIndex p = parent;
-    while ( p.isValid() )
+    while (p.isValid())
         p = p.parent();
 
     // For models that are dynamically populated
-    if ( model->canFetchMore ( parent ) ) {
+    if (model->canFetchMore(parent)) {
         fetchingMore = true;
-        model->fetchMore ( parent );
+        model->fetchMore(parent);
         fetchingMore = false;
     }
 
-    int rows = model->rowCount ( parent );
-    int columns = model->columnCount ( parent );
+    int rows = model->rowCount(parent);
+    int columns = model->columnCount(parent);
 
-    if ( rows > 0 )
-        QVERIFY( model->hasChildren ( parent ) );
+    if (rows > 0)
+        QVERIFY(model->hasChildren(parent));
 
     // Some further testing against rows(), columns(), and hasChildren()
-    QVERIFY( rows >= 0 );
-    QVERIFY( columns >= 0 );
-    if ( rows > 0 )
-        QVERIFY( model->hasChildren ( parent ) );
+    QVERIFY(rows >= 0);
+    QVERIFY(columns >= 0);
+    if (rows > 0)
+        QVERIFY(model->hasChildren(parent));
 
     //qDebug() << "parent:" << model->data(parent).toString() << "rows:" << rows
     //         << "columns:" << columns << "parent column:" << parent.column();
 
-    const QModelIndex topLeftChild = model->index( 0, 0, parent );
+    const QModelIndex topLeftChild = model->index(0, 0, parent);
 
-    QVERIFY( !model->hasIndex ( rows + 1, 0, parent ) );
-    for ( int r = 0; r < rows; ++r ) {
-        if ( model->canFetchMore ( parent ) ) {
+    QVERIFY(!model->hasIndex(rows + 1, 0, parent));
+    for (int r = 0; r < rows; ++r) {
+        if (model->canFetchMore(parent)) {
             fetchingMore = true;
-            model->fetchMore ( parent );
+            model->fetchMore(parent);
             fetchingMore = false;
         }
-        QVERIFY( !model->hasIndex ( r, columns + 1, parent ) );
-        for ( int c = 0; c < columns; ++c ) {
-            QVERIFY( model->hasIndex ( r, c, parent ) );
-            QModelIndex index = model->index ( r, c, parent );
+        QVERIFY(!model->hasIndex(r, columns + 1, parent));
+        for (int c = 0; c < columns; ++c) {
+            QVERIFY(model->hasIndex(r, c, parent));
+            QModelIndex index = model->index(r, c, parent);
             // rowCount() and columnCount() said that it existed...
             QVERIFY(index.isValid());
 
             // index() should always return the same index when called twice in a row
-            QModelIndex modifiedIndex = model->index ( r, c, parent );
+            QModelIndex modifiedIndex = model->index(r, c, parent);
             QCOMPARE(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 );
+            QModelIndex a = model->index(r, c, parent);
+            QModelIndex b = model->index(r, c, parent);
             QCOMPARE(a, b);
 
             {
-                const QModelIndex sibling = model->sibling( r, c, topLeftChild );
+                const QModelIndex sibling = model->sibling(r, c, topLeftChild);
                 QCOMPARE(index, sibling);
             }
             {
-                const QModelIndex sibling = topLeftChild.sibling( r, c );
+                const QModelIndex sibling = topLeftChild.sibling(r, c);
                 QCOMPARE(index, sibling);
             }
 
             // Some basic checking on the index that is returned
             QCOMPARE(index.model(), model);
-            QCOMPARE( index.row(), r );
-            QCOMPARE( index.column(), c );
+            QCOMPARE(index.row(), r);
+            QCOMPARE(index.column(), c);
             // While you can technically return a QVariant usually this is a sign
             // of a bug in data().  Disable if this really is ok in your model.
 //            QVERIFY( model->data ( index, Qt::DisplayRole ).isValid() );
@@ -377,16 +379,16 @@ void ModelTest::checkChildren ( const QModelIndex &parent, int currentDepth )
             }
 
             // Check that we can get back our real parent.
-            QCOMPARE( model->parent ( index ), parent );
+            QCOMPARE(model->parent(index), parent);
 
             // recursively go down the children
-            if ( model->hasChildren ( index ) && currentDepth < 10 ) {
+            if (model->hasChildren(index) && currentDepth < 10) {
                 //qDebug() << r << c << "has children" << model->rowCount(index);
-                checkChildren ( index, ++currentDepth );
+                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 );
+            QModelIndex newerIndex = model->index(r, c, parent);
             QCOMPARE(index, newerIndex);
         }
     }
@@ -398,68 +400,61 @@ void ModelTest::checkChildren ( const QModelIndex &parent, int currentDepth )
 void ModelTest::data()
 {
     // Invalid index should return an invalid qvariant
-    QVERIFY( !model->data ( QModelIndex() ).isValid() );
+    QVERIFY(!model->data(QModelIndex()).isValid());
 
-    if ( model->rowCount() == 0 )
+    if (model->rowCount() == 0)
         return;
 
     // A valid index should have a valid QVariant data
-    QVERIFY( model->index ( 0, 0 ).isValid() );
+    QVERIFY(model->index(0, 0).isValid());
 
     // shouldn't be able to set data on an invalid index
-    QVERIFY( !model->setData ( QModelIndex(), QLatin1String ( "foo" ), Qt::DisplayRole ) );
+    QVERIFY(!model->setData(QModelIndex(), QLatin1String("foo"), Qt::DisplayRole));
 
     // General Purpose roles that should return a QString
-    QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole );
-    if ( variant.isValid() ) {
-        QVERIFY( variant.canConvert<QString>() );
-    }
-    variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );
-    if ( variant.isValid() ) {
-        QVERIFY( variant.canConvert<QString>() );
-    }
-    variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );
-    if ( variant.isValid() ) {
-        QVERIFY( variant.canConvert<QString>() );
-    }
+    QVariant variant = model->data(model->index(0, 0), Qt::ToolTipRole);
+    if (variant.isValid())
+        QVERIFY(variant.canConvert<QString>());
+    variant = model->data(model->index(0, 0), Qt::StatusTipRole);
+    if (variant.isValid())
+        QVERIFY(variant.canConvert<QString>());
+    variant = model->data(model->index(0, 0), Qt::WhatsThisRole);
+    if (variant.isValid())
+        QVERIFY(variant.canConvert<QString>());
 
     // General Purpose roles that should return a QSize
-    variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );
-    if ( variant.isValid() ) {
-        QVERIFY( variant.canConvert<QSize>() );
-    }
+    variant = model->data(model->index(0, 0), Qt::SizeHintRole);
+    if (variant.isValid())
+        QVERIFY(variant.canConvert<QSize>());
 
     // General Purpose roles that should return a QFont
-    QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole );
-    if ( fontVariant.isValid() ) {
-        QVERIFY( fontVariant.canConvert<QFont>() );
-    }
+    QVariant fontVariant = model->data(model->index(0, 0), Qt::FontRole);
+    if (fontVariant.isValid())
+        QVERIFY(fontVariant.canConvert<QFont>());
 
     // Check that the alignment is one we know about
-    QVariant textAlignmentVariant = model->data ( model->index ( 0, 0 ), Qt::TextAlignmentRole );
-    if ( textAlignmentVariant.isValid() ) {
+    QVariant textAlignmentVariant = model->data(model->index(0, 0), Qt::TextAlignmentRole);
+    if (textAlignmentVariant.isValid()) {
         Qt::Alignment alignment = textAlignmentVariant.value<Qt::Alignment>();
-        QCOMPARE( alignment, ( alignment & ( Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask ) ) );
+        QCOMPARE(alignment, (alignment & (Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask)));
     }
 
     // General Purpose roles that should return a QColor
-    QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole );
-    if ( colorVariant.isValid() ) {
-        QVERIFY( colorVariant.canConvert<QColor>() );
-    }
+    QVariant colorVariant = model->data(model->index(0, 0), Qt::BackgroundColorRole);
+    if (colorVariant.isValid())
+        QVERIFY(colorVariant.canConvert<QColor>());
 
-    colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );
-    if ( colorVariant.isValid() ) {
-        QVERIFY( colorVariant.canConvert<QColor>() );
-    }
+    colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);
+    if (colorVariant.isValid())
+        QVERIFY(colorVariant.canConvert<QColor>());
 
     // Check that the "check state" is one we know about.
-    QVariant checkStateVariant = model->data ( model->index ( 0, 0 ), Qt::CheckStateRole );
-    if ( checkStateVariant.isValid() ) {
+    QVariant checkStateVariant = model->data(model->index(0, 0), Qt::CheckStateRole);
+    if (checkStateVariant.isValid()) {
         int state = checkStateVariant.toInt();
-        QVERIFY( state == Qt::Unchecked ||
-                 state == Qt::PartiallyChecked ||
-                 state == Qt::Checked );
+        QVERIFY(state == Qt::Unchecked
+                || state == Qt::PartiallyChecked
+                || state == Qt::Checked);
     }
 }
 
@@ -468,7 +463,7 @@ void ModelTest::data()
 
     \sa rowsInserted()
  */
-void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, int /* end */)
+void ModelTest::rowsAboutToBeInserted(const QModelIndex &parent, int start, int /* end */)
 {
 //     Q_UNUSED(end);
 //    qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).toString()
@@ -476,10 +471,10 @@ void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, in
 //     qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );
     Changing c;
     c.parent = parent;
-    c.oldSize = model->rowCount ( parent );
-    c.last = model->data ( model->index ( start - 1, 0, parent ) );
-    c.next = model->data ( model->index ( start, 0, parent ) );
-    insert.push ( c );
+    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);
 }
 
 /*!
@@ -487,7 +482,7 @@ void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, in
 
     \sa rowsAboutToBeInserted()
  */
-void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
+void ModelTest::rowsInserted(const QModelIndex &parent, int start, int end)
 {
     Changing c = insert.pop();
     QCOMPARE(c.parent, parent);
@@ -505,7 +500,7 @@ void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
 
     if (c.next != model->data(model->index(end + 1, 0, c.parent))) {
         qDebug() << start << end;
-        for (int i=0; i < model->rowCount(); ++i)
+        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));
     }
@@ -515,13 +510,13 @@ void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
 
 void ModelTest::layoutAboutToBeChanged()
 {
-    for ( int i = 0; i < qBound ( 0, model->rowCount(), 100 ); ++i )
-        changing.append ( QPersistentModelIndex ( model->index ( i, 0 ) ) );
+    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 ) {
+    for (int i = 0; i < changing.count(); ++i) {
         QPersistentModelIndex p = changing[i];
         QCOMPARE(QModelIndex(p), model->index(p.row(), p.column(), p.parent()));
     }
@@ -533,15 +528,15 @@ void ModelTest::layoutChanged()
 
     \sa rowsRemoved()
  */
-void ModelTest::rowsAboutToBeRemoved ( const QModelIndex &parent, int start, int end )
+void ModelTest::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
 {
-qDebug() << "ratbr" << parent << start << end;
+    qDebug() << "ratbr" << parent << start << end;
     Changing c;
     c.parent = parent;
-    c.oldSize = model->rowCount ( parent );
-    c.last = model->data ( model->index ( start - 1, 0, parent ) );
-    c.next = model->data ( model->index ( end + 1, 0, parent ) );
-    remove.push ( c );
+    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);
 }
 
 /*!
@@ -549,9 +544,9 @@ qDebug() << "ratbr" << parent << start << end;
 
     \sa rowsAboutToBeRemoved()
  */
-void ModelTest::rowsRemoved ( const QModelIndex & parent, int start, int end )
+void ModelTest::rowsRemoved(const QModelIndex &parent, int start, int end)
 {
-  qDebug() << "rr" << parent << start << end;
+    qDebug() << "rr" << parent << start << end;
     Changing c = remove.pop();
     QCOMPARE(c.parent, parent);
     QCOMPARE(c.oldSize - (end - start + 1), model->rowCount(parent));
@@ -582,4 +577,3 @@ void ModelTest::headerDataChanged(Qt::Orientation orientation, int start, int en
     QVERIFY(start < itemCount);
     QVERIFY(end < itemCount);
 }
-
diff --git a/tests/auto/other/modeltest/modeltest.h b/tests/auto/other/modeltest/modeltest.h
index 735a422729..4676bf4434 100644
--- a/tests/auto/other/modeltest/modeltest.h
+++ b/tests/auto/other/modeltest/modeltest.h
@@ -26,7 +26,6 @@
 **
 ****************************************************************************/
 
-
 #ifndef MODELTEST_H
 #define MODELTEST_H
 
@@ -36,48 +35,48 @@
 
 class ModelTest : public QObject
 {
-  Q_OBJECT
+    Q_OBJECT
 
 public:
-  ModelTest( QAbstractItemModel *model, QObject *parent = 0 );
+    ModelTest(QAbstractItemModel *model, QObject *parent = 0);
 
 private Q_SLOTS:
-  void nonDestructiveBasicTest();
-  void rowCount();
-  void columnCount();
-  void hasIndex();
-  void index();
-  void parent();
-  void data();
+    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 );
-  void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
-  void headerDataChanged(Qt::Orientation orientation, int start, int end);
+    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);
+    void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
+    void headerDataChanged(Qt::Orientation orientation, int start, int end);
 
 private:
-  void checkChildren( const QModelIndex &parent, int currentDepth = 0 );
+    void checkChildren(const QModelIndex &parent, int currentDepth = 0);
 
-  QAbstractItemModel *model;
+    QAbstractItemModel *model;
 
-  struct Changing {
-    QModelIndex parent;
-    int oldSize;
-    QVariant last;
-    QVariant next;
-  };
-  QStack<Changing> insert;
-  QStack<Changing> remove;
+    struct Changing {
+        QModelIndex parent;
+        int oldSize;
+        QVariant last;
+        QVariant next;
+    };
+    QStack<Changing> insert;
+    QStack<Changing> remove;
 
-  bool fetchingMore;
+    bool fetchingMore;
 
-  QList<QPersistentModelIndex> changing;
+    QList<QPersistentModelIndex> changing;
 };
 
 #endif
diff --git a/tests/auto/other/modeltest/tst_modeltest.cpp b/tests/auto/other/modeltest/tst_modeltest.cpp
index f81fefe9d1..e2d002844b 100644
--- a/tests/auto/other/modeltest/tst_modeltest.cpp
+++ b/tests/auto/other/modeltest/tst_modeltest.cpp
@@ -26,7 +26,6 @@
 **
 ****************************************************************************/
 
-
 #include <QtTest/QtTest>
 #include <QtGui/QtGui>
 #include <QtWidgets/QtWidgets>
@@ -34,7 +33,6 @@
 #include "modeltest.h"
 #include "dynamictreemodel.h"
 
-
 class tst_ModelTest : public QObject
 {
     Q_OBJECT
@@ -63,7 +61,7 @@ void tst_ModelTest::stringListModel()
     proxy.setSourceModel(&model);
 
     model.setStringList(QStringList() << "2" << "3" << "1");
-    model.setStringList(QStringList() << "a" << "e" << "plop" << "b" << "c" );
+    model.setStringList(QStringList() << "a" << "e" << "plop" << "b" << "c");
 
     proxy.setDynamicSortFilter(true);
     proxy.setFilterRegExp(QRegExp("[^b]"));
@@ -76,9 +74,8 @@ void tst_ModelTest::treeWidgetModel()
     ModelTest t1(widget.model());
 
     QTreeWidgetItem *root = new QTreeWidgetItem(&widget, QStringList("root"));
-    for (int i = 0; i < 20; ++i) {
+    for (int i = 0; i < 20; ++i)
         new QTreeWidgetItem(root, QStringList(QString::number(i)));
-    }
     QTreeWidgetItem *remove = root->child(2);
     root->removeChild(remove);
     QTreeWidgetItem *parent = new QTreeWidgetItem(&widget, QStringList("parent"));
@@ -90,10 +87,9 @@ void tst_ModelTest::treeWidgetModel()
 
 void tst_ModelTest::standardItemModel()
 {
-    QStandardItemModel model(10,10);
+    QStandardItemModel model(10, 10);
     QSortFilterProxyModel proxy;
 
-
     ModelTest t1(&model);
     ModelTest t2(&proxy);
 
@@ -105,8 +101,8 @@ void tst_ModelTest::standardItemModel()
     model.insertColumns(2, 5);
     model.removeColumns(4, 5);
 
-    model.insertRows(0,5, model.index(1,1));
-    model.insertColumns(0,5, model.index(1,3));
+    model.insertRows(0, 5, model.index(1, 1));
+    model.insertColumns(0, 5, model.index(1, 3));
 }
 
 void tst_ModelTest::testInsertThroughProxy()
@@ -148,7 +144,9 @@ class AccessibleProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 public:
-    AccessibleProxyModel(QObject *parent = 0) : QSortFilterProxyModel(parent) {}
+    AccessibleProxyModel(QObject *parent = 0) : QSortFilterProxyModel(parent)
+    {
+    }
 
     QModelIndexList persistent()
     {
@@ -160,14 +158,16 @@ class ObservingObject : public QObject
 {
     Q_OBJECT
 public:
-    ObservingObject(AccessibleProxyModel  *proxy, QObject *parent = 0)
-    : QObject(parent)
-    , m_proxy(proxy)
-    , storePersistentFailureCount(0)
-    , checkPersistentFailureCount(0)
+    ObservingObject(AccessibleProxyModel *proxy, QObject *parent = 0) :
+        QObject(parent),
+        m_proxy(proxy),
+        storePersistentFailureCount(0),
+        checkPersistentFailureCount(0)
     {
-        connect(m_proxy, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(storePersistent()));
-        connect(m_proxy, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(checkPersistent()));
+        connect(m_proxy, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
+                SLOT(storePersistent()));
+        connect(m_proxy, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
+                SLOT(checkPersistent()));
     }
 
 public slots:
@@ -195,7 +195,7 @@ public slots:
     void storePersistent()
     {
         // This method is called from rowsAboutToBeMoved. Persistent indexes should be valid
-        foreach(const QModelIndex &idx, m_persistentProxyIndexes)
+        foreach (const QModelIndex &idx, m_persistentProxyIndexes)
             if (!idx.isValid()) {
                 qWarning("%s: persistentProxyIndexes contains invalid index", Q_FUNC_INFO);
                 ++storePersistentFailureCount;
@@ -233,7 +233,7 @@ public slots:
     }
 
 private:
-    AccessibleProxyModel  *m_proxy;
+    AccessibleProxyModel *m_proxy;
     QList<QPersistentModelIndex> m_persistentSourceIndexes;
     QList<QPersistentModelIndex> m_persistentProxyIndexes;
 public:
@@ -296,6 +296,5 @@ void tst_ModelTest::testResetThroughProxy()
     QCOMPARE(observer.checkPersistentFailureCount, 0);
 }
 
-
 QTEST_MAIN(tst_ModelTest)
 #include "tst_modeltest.moc"