Revert "Applied clang-format on source"

This reverts commit 5e5c9c07291f6b09623d31c92b1fb61c4ede576e.

1 files changed, 262 insertions, 232 deletions

diff --git a/src/modeltest.cpp b/src/modeltest.cpp
index d645d464..90061261 100644
--- a/src/modeltest.cpp
+++ b/src/modeltest.cpp
@@ -39,6 +39,7 @@
 **

 ****************************************************************************/

 

+

 #include <QtGui/QtGui>

 

 #include "modeltest.h"

@@ -50,48 +51,61 @@
 #undef QCOMPARE

 #define QCOMPARE(x, y) Q_ASSERT(x == y)

 

-Q_DECLARE_METATYPE(QModelIndex)

+Q_DECLARE_METATYPE ( QModelIndex )

 

 /*!

     Connect to all of the models signals.  Whenever anything happens recheck everything.

 */

-ModelTest::ModelTest(QAbstractItemModel* _model, QObject* parent)

-    : QObject(parent), model(_model), fetchingMore(false) {

+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(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(columnsAboutToBeRemoved(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(columnsInserted(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(columnsRemoved(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(layoutAboutToBeChanged()), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(layoutChanged()), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(modelReset()), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(rowsInserted(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

-    connect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), this, SLOT(runAllTests()));

+    connect ( model, SIGNAL ( columnsAboutToBeInserted ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( columnsAboutToBeRemoved ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( columnsInserted ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( columnsRemoved ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( dataChanged ( const QModelIndex &, const QModelIndex & ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( headerDataChanged ( Qt::Orientation, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( layoutAboutToBeChanged () ), this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( layoutChanged () ), this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( modelReset () ), this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( rowsAboutToBeInserted ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( rowsAboutToBeRemoved ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( rowsInserted ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

+    connect ( model, SIGNAL ( rowsRemoved ( const QModelIndex &, int, int ) ),

+              this, SLOT ( runAllTests() ) );

 

     // Special checks for inserting/removing

-    connect(model, SIGNAL(layoutAboutToBeChanged()), this, SLOT(layoutAboutToBeChanged()));

-    connect(model, SIGNAL(layoutChanged()), this, SLOT(layoutChanged()));

+    connect ( model, SIGNAL ( layoutAboutToBeChanged() ),

+              this, SLOT ( layoutAboutToBeChanged() ) );

+    connect ( model, SIGNAL ( layoutChanged() ),

+              this, SLOT ( layoutChanged() ) );

 

-    connect(model, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)), this,

-            SLOT(rowsAboutToBeInserted(const QModelIndex&, int, int)));

-    connect(model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)), this,

-            SLOT(rowsAboutToBeRemoved(const QModelIndex&, int, int)));

-    connect(model, SIGNAL(rowsInserted(const QModelIndex&, int, int)), this,

-            SLOT(rowsInserted(const QModelIndex&, int, int)));

-    connect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), this,

-            SLOT(rowsRemoved(const QModelIndex&, int, int)));

+    connect ( model, SIGNAL ( rowsAboutToBeInserted ( const QModelIndex &, int, int ) ),

+              this, SLOT ( rowsAboutToBeInserted ( const QModelIndex &, int, int ) ) );

+    connect ( model, SIGNAL ( rowsAboutToBeRemoved ( const QModelIndex &, int, int ) ),

+              this, SLOT ( rowsAboutToBeRemoved ( const QModelIndex &, int, int ) ) );

+    connect ( model, SIGNAL ( rowsInserted ( const QModelIndex &, int, int ) ),

+              this, SLOT ( rowsInserted ( const QModelIndex &, int, int ) ) );

+    connect ( model, SIGNAL ( rowsRemoved ( const QModelIndex &, int, int ) ),

+              this, SLOT ( rowsRemoved ( const QModelIndex &, int, int ) ) );

 

     runAllTests();

 }

 

-void ModelTest::runAllTests() {

-    if (fetchingMore)

+void ModelTest::runAllTests()

+{

+    if ( fetchingMore )

         return;

     nonDestructiveBasicTest();

     rowCount();

@@ -106,33 +120,34 @@ void ModelTest::runAllTests() {
     nonDestructiveBasicTest tries to call a number of the basic functions (not all)

     to make sure the model doesn't outright segfault, testing the functions that makes sense.

 */

-void ModelTest::nonDestructiveBasicTest() {

-    QVERIFY(model->buddy(QModelIndex()) == QModelIndex());

-    model->canFetchMore(QModelIndex());

-    QVERIFY(model->columnCount(QModelIndex()) >= 0);

-    QVERIFY(model->data(QModelIndex()) == QVariant());

+void ModelTest::nonDestructiveBasicTest()

+{

+    QVERIFY( model->buddy ( QModelIndex() ) == QModelIndex() );

+    model->canFetchMore ( QModelIndex() );

+    QVERIFY( model->columnCount ( QModelIndex() ) >= 0 );

+    QVERIFY( 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()) == QModelIndex());

-    QVERIFY(model->rowCount() >= 0);

+    QVERIFY( model->parent ( QModelIndex() ) == QModelIndex() );

+    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();

 }

 

@@ -141,28 +156,29 @@ void ModelTest::nonDestructiveBasicTest() {
 

     Models that are dynamically populated are not as fully tested here.

  */

-void ModelTest::rowCount() {

-    //     qDebug() << "rc";

+void ModelTest::rowCount()

+{

+//     qDebug() << "rc";

     // check top row

 

-    QModelIndex topIndex = model->index(0, 0, QModelIndex());

-    if (!model->hasChildren(topIndex) && model->rowCount(topIndex) > 0) {

-        qDebug() << "it's gonna blow: " << topIndex;

-    }

+  QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );

+  if (!model->hasChildren ( topIndex ) && model->rowCount(topIndex) > 0) {

+    qDebug() << "it's gonna blow: " << topIndex;

+  }

 

-    int rows = model->rowCount(topIndex);

-    QVERIFY(rows >= 0);

-    if (rows > 0) {

-        QVERIFY(model->hasChildren(topIndex));

+    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 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(),

@@ -172,15 +188,16 @@ void ModelTest::rowCount() {
 /*!

     Tests model's implementation of QAbstractItemModel::columnCount() and hasChildren()

  */

-void ModelTest::columnCount() {

+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

@@ -189,22 +206,23 @@ void ModelTest::columnCount() {
 /*!

     Tests model's implementation of QAbstractItemModel::hasIndex()

  */

-void ModelTest::hasIndex() {

-    //     qDebug() << "hi";

+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

@@ -213,31 +231,32 @@ void ModelTest::hasIndex() {
 /*!

     Tests model's implementation of QAbstractItemModel::index()

  */

-void ModelTest::index() {

-    //     qDebug() << "i";

+void ModelTest::index()

+{

+//     qDebug() << "i";

     // Make sure that invalid values returns an invalid index

-    /*  QVERIFY( model->index ( -2, -2 ) == QModelIndex() );

-      QVERIFY( model->index ( -2, 0 ) == QModelIndex() );

-      QVERIFY( model->index ( 0, -2 ) == QModelIndex() );*/

-    QVERIFY(!model->index(-2, -2).isValid());

-    QVERIFY(!model->index(-2, 0).isValid());

-    QVERIFY(!model->index(0, -2).isValid());

+/*  QVERIFY( model->index ( -2, -2 ) == QModelIndex() );

+  QVERIFY( model->index ( -2, 0 ) == QModelIndex() );

+  QVERIFY( model->index ( 0, -2 ) == QModelIndex() );*/

+  QVERIFY( !model->index ( -2, -2 ).isValid() );

+  QVERIFY( !model->index ( -2, 0 ).isValid() );

+  QVERIFY( !model->index ( 0, -2 ).isValid() );

 

     int rows = model->rowCount();

     int columns = model->columnCount();

 

-    if (rows == 0)

+    if ( rows == 0 )

         return;

 

     // Catch off by one errors

-    // QVERIFY( model->index ( rows, columns ) == QModelIndex() );

-    QVERIFY(!model->index(rows, columns).isValid());

-    QVERIFY(model->index(0, 0).isValid());

+    //QVERIFY( model->index ( rows, columns ) == QModelIndex() );

+    QVERIFY( !model->index ( rows, columns ).isValid() );

+    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);

-    QVERIFY(a == b);

+    QModelIndex a = model->index ( 0, 0 );

+    QModelIndex b = model->index ( 0, 0 );

+    QVERIFY( a == b );

 

     // index() is tested more extensively in checkChildren(),

     // but this catches the big mistakes

@@ -246,13 +265,14 @@ void ModelTest::index() {
 /*!

     Tests model's implementation of QAbstractItemModel::parent()

  */

-void ModelTest::parent() {

-    //     qDebug() << "p";

+void ModelTest::parent()

+{

+//     qDebug() << "p";

     // Make sure the model wont crash and will return an invalid QModelIndex

     // when asked for the parent of an invalid index.

-    QVERIFY(model->parent(QModelIndex()) == QModelIndex());

+    QVERIFY( model->parent ( QModelIndex() ) == QModelIndex() );

 

-    if (model->rowCount() == 0)

+    if ( model->rowCount() == 0 )

         return;

 

     // Column 0                | Column 1    |

@@ -262,29 +282,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());

-    QVERIFY(model->parent(topIndex) == QModelIndex());

+    QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );

+    QVERIFY( model->parent ( topIndex ) == QModelIndex() );

 

     // Common error test #2, make sure that a second level index has a parent

     // that is the first level index.

-    if (model->rowCount(topIndex) > 0) {

-        QModelIndex childIndex = model->index(0, 0, topIndex);

-        QVERIFY(model->parent(childIndex) == topIndex);

+    if ( model->rowCount ( topIndex ) > 0 ) {

+        QModelIndex childIndex = model->index ( 0, 0, topIndex );

+        QVERIFY( 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() );

 }

 

 /*!

@@ -301,88 +321,90 @@ 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

+    //qDebug() << "parent:" << model->data(parent).toString() << "rows:" << rows

     //         << "columns:" << columns << "parent column:" << parent.column();

 

-    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());

+            QVERIFY( index.isValid() );

 

             // index() should always return the same index when called twice in a row

-            QModelIndex modifiedIndex = model->index(r, c, parent);

-            QVERIFY(index == modifiedIndex);

+            QModelIndex modifiedIndex = model->index ( r, c, parent );

+            QVERIFY( 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);

-            QVERIFY(a == b);

+            QModelIndex a = model->index ( r, c, parent );

+            QModelIndex b = model->index ( r, c, parent );

+            QVERIFY( a == b );

 

             // Some basic checking on the index that is returned

-            QVERIFY(index.model() == model);

-            QCOMPARE(index.row(), r);

-            QCOMPARE(index.column(), c);

+            QVERIFY( index.model() == model );

+            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() );

+//            QVERIFY( model->data ( index, Qt::DisplayRole ).isValid() );

 

             // If the next test fails here is some somewhat useful debug you play with.

 

             if (model->parent(index) != parent) {

-                qDebug() << r << c << currentDepth << model->data(index).toString() << model->data(parent).toString();

+                qDebug() << r << c << currentDepth << model->data(index).toString()

+                         << model->data(parent).toString();

                 qDebug() << index << parent << model->parent(index);

-                //                 And a view that you can even use to show the model.

-                //                 QTreeView view;

-                //                 view.setModel(model);

-                //                 view.show();

+//                 And a view that you can even use to show the model.

+//                 QTreeView view;

+//                 view.setModel(model);

+//                 view.show();

             }

 

             // Check that we can get back our real parent.

-            QCOMPARE(model->parent(index), parent);

+            QCOMPARE( model->parent ( index ), parent );

 

             // recursively go down the children

-            if (model->hasChildren(index) && currentDepth < 10) {

-                // qDebug() << r << c << "has children" << model->rowCount(index);

-                checkChildren(index, ++currentDepth);

-            } /* else { if (currentDepth >= 10) qDebug() << "checked 10 deep"; };*/

+            if ( model->hasChildren ( index ) && currentDepth < 10 ) {

+                //qDebug() << r << c << "has children" << model->rowCount(index);

+                checkChildren ( index, ++currentDepth );

+            }/* else { if (currentDepth >= 10) qDebug() << "checked 10 deep"; };*/

 

             // make sure that after testing the children that the index doesn't change.

-            QModelIndex newerIndex = model->index(r, c, parent);

-            QVERIFY(index == newerIndex);

+            QModelIndex newerIndex = model->index ( r, c, parent );

+            QVERIFY( index == newerIndex );

         }

     }

 }

@@ -390,68 +412,71 @@ void ModelTest::checkChildren(const QModelIndex& parent, int currentDepth) {
 /*!

     Tests model's implementation of QAbstractItemModel::data()

  */

-void ModelTest::data() {

+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(QMetaType::QString));

+    QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole );

+    if ( variant.isValid() ) {

+        QVERIFY( variant.canConvert(QMetaType::QString) );

     }

-    variant = model->data(model->index(0, 0), Qt::StatusTipRole);

-    if (variant.isValid()) {

-        QVERIFY(variant.canConvert(QMetaType::QString));

+    variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );

+    if ( variant.isValid() ) {

+        QVERIFY( variant.canConvert(QMetaType::QString) );

     }

-    variant = model->data(model->index(0, 0), Qt::WhatsThisRole);

-    if (variant.isValid()) {

-        QVERIFY(variant.canConvert(QMetaType::QString));

+    variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );

+    if ( variant.isValid() ) {

+        QVERIFY( variant.canConvert(QMetaType::QString) );

     }

 

     // General Purpose roles that should return a QSize

-    variant = model->data(model->index(0, 0), Qt::SizeHintRole);

-    if (variant.isValid()) {

-        QVERIFY(variant.canConvert(QMetaType::QSize));

+    variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );

+    if ( variant.isValid() ) {

+        QVERIFY( variant.canConvert(QMetaType::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(QMetaType::QFont));

+    QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole );

+    if ( fontVariant.isValid() ) {

+        QVERIFY( fontVariant.canConvert(QMetaType::QFont) );

     }

 

     // Check that the alignment is one we know about

-    QVariant textAlignmentVariant = model->data(model->index(0, 0), Qt::TextAlignmentRole);

-    if (textAlignmentVariant.isValid()) {

+    QVariant textAlignmentVariant = model->data ( model->index ( 0, 0 ), Qt::TextAlignmentRole );

+    if ( textAlignmentVariant.isValid() ) {

         int alignment = textAlignmentVariant.toInt();

-        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(QMetaType::QColor));

+    QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole );

+    if ( colorVariant.isValid() ) {

+        QVERIFY( colorVariant.canConvert(QMetaType::QColor) );

     }

 

-    colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);

-    if (colorVariant.isValid()) {

-        QVERIFY(colorVariant.canConvert(QMetaType::QColor));

+    colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );

+    if ( colorVariant.isValid() ) {

+        QVERIFY( colorVariant.canConvert(QMetaType::QColor) );

     }

 

     // Check that the "check state" is one we know about.

-    QVariant checkStateVariant = model->data(model->index(0, 0), Qt::CheckStateRole);

-    if (checkStateVariant.isValid()) {

+    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 );

     }

 }

 

@@ -460,20 +485,19 @@ void ModelTest::data() {
 

     \sa rowsInserted()

  */

-void ModelTest::rowsAboutToBeInserted(const QModelIndex& parent, int start, int end) {

-    //     Q_UNUSED(end);

-    //    qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent

-    //    ).toString()

-    //    << "current count of parent=" << model->rowCount ( parent ); // << "display of last=" << model->data(

-    //    model->index(start-1, 0, parent) );

-    //     qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );

+void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, int end )

+{

+//     Q_UNUSED(end);

+//    qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).toString()

+//    << "current count of parent=" << model->rowCount ( parent ); // << "display of last=" << model->data( model->index(start-1, 0, parent) );

+//     qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );

     Changing c;

     c.parent = parent;

-    c.oldSize = model->rowCount(parent);

-    c.last = model->data(model->index(start - 1, 0, parent));

-    c.next = model->data(model->index(start, 0, parent));

-    qDebug() << start << " - " << parent << " - " << model->data(model->index(start, 0, parent), Qt::UserRole);

-    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 ) );

+qDebug() << start << " - " << parent << " - " << model->data ( model->index ( start, 0, parent ), Qt::UserRole );

+    insert.push ( c );

 }

 

 /*!

@@ -481,44 +505,46 @@ void ModelTest::rowsAboutToBeInserted(const QModelIndex& parent, int start, int
 

     \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();

-    QVERIFY(c.parent == parent);

-    //    qDebug() << "rowsInserted"  << "start=" << start << "end=" << end << "oldsize=" << c.oldSize

-    //    << "parent=" << model->data ( parent ).toString() << "current rowcount of parent=" << model->rowCount ( parent

-    //    );

+    QVERIFY( c.parent == parent );

+//    qDebug() << "rowsInserted"  << "start=" << start << "end=" << end << "oldsize=" << c.oldSize

+//    << "parent=" << model->data ( parent ).toString() << "current rowcount of parent=" << model->rowCount ( parent );

 

-    //    for (int ii=start; ii <= end; ii++)

-    //    {

-    //      qDebug() << "itemWasInserted:" << ii << model->data ( model->index ( ii, 0, parent ));

-    //    }

-    //    qDebug();

+//    for (int ii=start; ii <= end; ii++)

+//    {

+//      qDebug() << "itemWasInserted:" << ii << model->data ( model->index ( ii, 0, parent ));

+//    }

+//    qDebug();

 

-    QVERIFY(c.oldSize + (end - start + 1) == model->rowCount(parent));

-    QVERIFY(c.last == model->data(model->index(start - 1, 0, c.parent)));

+    QVERIFY( c.oldSize + ( end - start + 1 ) == model->rowCount ( parent ) );

+    QVERIFY( c.last == model->data ( model->index ( start - 1, 0, c.parent ) ) );

 

     if (c.next != model->data(model->index(end + 1, 0, c.parent))) {

         qDebug() << start << end;

-        for (int i = 0; i < model->rowCount(); ++i)

+        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));

     }

 

-    if (c.next != model->data(model->index(end + 1, 0, c.parent))) {

-        qDebug("break");

-    }

-    QVERIFY(c.next == model->data(model->index(end + 1, 0, c.parent)));

+if (c.next != model->data ( model->index ( end + 1, 0, c.parent ) )) {

+  qDebug("break");

+}

+    QVERIFY( c.next == model->data ( model->index ( end + 1, 0, c.parent ) ) );

 }

 

-void ModelTest::layoutAboutToBeChanged() {

-    for (int i = 0; i < qBound(0, model->rowCount(), 100); ++i)

-        changing.append(QPersistentModelIndex(model->index(i, 0)));

+void ModelTest::layoutAboutToBeChanged()

+{

+    for ( int i = 0; i < qBound ( 0, model->rowCount(), 100 ); ++i )

+        changing.append ( QPersistentModelIndex ( model->index ( i, 0 ) ) );

 }

 

-void ModelTest::layoutChanged() {

-    for (int i = 0; i < changing.count(); ++i) {

+void ModelTest::layoutChanged()

+{

+    for ( int i = 0; i < changing.count(); ++i ) {

         QPersistentModelIndex p = changing[i];

-        QVERIFY(p == model->index(p.row(), p.column(), p.parent()));

+        QVERIFY( p == model->index ( p.row(), p.column(), p.parent() ) );

     }

     changing.clear();

 }

@@ -528,14 +554,15 @@ void ModelTest::layoutChanged() {
 

     \sa rowsRemoved()

  */

-void ModelTest::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end) {

-    qDebug() << "ratbr" << parent << start << end;

+void ModelTest::rowsAboutToBeRemoved ( const QModelIndex &parent, int start, int end )

+{

+qDebug() << "ratbr" << parent << start << end;

     Changing c;

     c.parent = parent;

-    c.oldSize = model->rowCount(parent);

-    c.last = model->data(model->index(start - 1, 0, parent));

-    c.next = model->data(model->index(end + 1, 0, parent));

-    remove.push(c);

+    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 );

 }

 

 /*!

@@ -543,11 +570,14 @@ void ModelTest::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int e
 

     \sa rowsAboutToBeRemoved()

  */

-void ModelTest::rowsRemoved(const QModelIndex& parent, int start, int end) {

-    qDebug() << "rr" << parent << start << end;

+void ModelTest::rowsRemoved ( const QModelIndex & parent, int start, int end )

+{

+  qDebug() << "rr" << parent << start << end;

     Changing c = remove.pop();

-    QVERIFY(c.parent == parent);

-    QVERIFY(c.oldSize - (end - start + 1) == model->rowCount(parent));

-    QVERIFY(c.last == model->data(model->index(start - 1, 0, c.parent)));

-    QVERIFY(c.next == model->data(model->index(start, 0, c.parent)));

+    QVERIFY( c.parent == parent );

+    QVERIFY( c.oldSize - ( end - start + 1 ) == model->rowCount ( parent ) );

+    QVERIFY( c.last == model->data ( model->index ( start - 1, 0, c.parent ) ) );

+    QVERIFY( c.next == model->data ( model->index ( start, 0, c.parent ) ) );

 }

+

+