1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <QStandardItemModel>

    45 #include <QStringListModel>

    46 

    47 #include <qabstractitemmodel.h>

    48 #include <qapplication.h>

    49 #include <qheaderview.h>

    50 #include <private/qheaderview_p.h>

    51 #include <qitemdelegate.h>

    52 #include <qtreewidget.h>

    53 #include <qdebug.h>

    54 

    55 typedef QList<int> IntList;

    56 Q_DECLARE_METATYPE(IntList)

    57 

    58 typedef QList<bool> BoolList;

    59 Q_DECLARE_METATYPE(BoolList)

    60 

    61 //TESTED_CLASS=

    62 //TESTED_FILES=

    63 

    64 // Will try to wait for the condition while allowing event processing

    65 // for a maximum of 2 seconds.

    66 #define WAIT_FOR_CONDITION(expr, expected) \

    67     do { \

    68         const int step = 100; \

    69         for (int i = 0; i < 2000 && expr != expected; i+=step) { \

    70             QTest::qWait(step); \

    71         } \

    72     } while(0)

    73 

    74 class protected_QHeaderView : public QHeaderView

    75 {

    76     Q_OBJECT

    77 public:

    78     protected_QHeaderView(Qt::Orientation orientation) : QHeaderView(orientation) {

    79         resizeSections();

    80     };

    81 

    82     void testEvent();

    83     void testhorizontalOffset();

    84     void testverticalOffset();

    85     friend class tst_QHeaderView;

    86 };

    87 

    88 class tst_QHeaderView : public QObject

    89 {

    90     Q_OBJECT

    91 

    92 public:

    93     tst_QHeaderView();

    94     virtual ~tst_QHeaderView();

    95 

    96 public slots:

    97     void initTestCase();

    98     void cleanupTestCase();

    99     void init();

   100     void cleanup();

   101 

   102 private slots:

   103     void getSetCheck();

   104     void visualIndex();

   105 

   106     void visualIndexAt_data();

   107     void visualIndexAt();

   108 

   109     void noModel();

   110     void emptyModel();

   111     void removeRows();

   112     void removeCols();

   113 

   114     void clickable();

   115     void movable();

   116     void hidden();

   117     void stretch();

   118 

   119     void sectionSize_data();

   120     void sectionSize();

   121 

   122     void length();

   123     void offset();

   124     void sectionSizeHint();

   125     void logicalIndex();

   126     void logicalIndexAt();

   127     void swapSections();

   128 

   129     void moveSection_data();

   130     void moveSection();

   131 

   132     void resizeMode();

   133 

   134     void resizeSection_data();

   135     void resizeSection();

   136 

   137     void resizeAndMoveSection_data();

   138     void resizeAndMoveSection();

   139     void resizeHiddenSection_data();

   140     void resizeHiddenSection();

   141     void resizeAndInsertSection_data();

   142     void resizeAndInsertSection();

   143     void resizeWithResizeModes_data();

   144     void resizeWithResizeModes();

   145     void moveAndInsertSection_data();

   146     void moveAndInsertSection();

   147     void highlightSections();

   148     void showSortIndicator();

   149     void sortIndicatorTracking();

   150     void removeAndInsertRow();

   151     void unhideSection();

   152     void event();

   153     void headerDataChanged();

   154     void currentChanged();

   155     void horizontalOffset();

   156     void verticalOffset();

   157     void stretchSectionCount();

   158     void hiddenSectionCount();

   159     void focusPolicy();

   160     void moveSectionAndReset();

   161     void moveSectionAndRemove();

   162     void saveRestore();

   163 

   164     void defaultAlignment_data();

   165     void defaultAlignment();

   166 

   167     void globalResizeMode_data();

   168     void globalResizeMode();

   169 

   170     void sectionPressedSignal_data();

   171     void sectionPressedSignal();

   172     void sectionClickedSignal_data() { sectionPressedSignal_data(); }

   173     void sectionClickedSignal();

   174 

   175     void defaultSectionSize_data();

   176     void defaultSectionSize();

   177 

   178     void oneSectionSize();

   179 

   180     void hideAndInsert_data();

   181     void hideAndInsert();

   182 

   183     void removeSection();

   184     void preserveHiddenSectionWidth();

   185     void invisibleStretchLastSection();

   186 

   187     void emptySectionSpan();

   188     void task236450_hidden_data();

   189     void task236450_hidden();

   190     void task248050_hideRow();

   191 

   192 protected:

   193     QHeaderView *view;

   194     QStandardItemModel *model;

   195 };

   196 

   197 class QtTestModel: public QAbstractTableModel

   198 {

   199 

   200 Q_OBJECT

   201 

   202 public:

   203     QtTestModel(QObject *parent = 0): QAbstractTableModel(parent),

   204        cols(0), rows(0), wrongIndex(false) {}

   205     int rowCount(const QModelIndex&) const { return rows; }

   206     int columnCount(const QModelIndex&) const { return cols; }

   207     bool isEditable(const QModelIndex &) const { return true; }

   208 

   209     QVariant data(const QModelIndex &idx, int) const

   210     {

   211         if (idx.row() < 0 || idx.column() < 0 || idx.column() >= cols || idx.row() >= rows) {

   212             wrongIndex = true;

   213             qWarning("Invalid modelIndex [%d,%d,%p]", idx.row(), idx.column(), idx.internalPointer());

   214         }

   215         return QString("[%1,%2,%3]").arg(idx.row()).arg(idx.column()).arg(0);//idx.data());

   216     }

   217 

   218     void insertOneColumn(int col)

   219     {

   220         beginInsertColumns(QModelIndex(), col, col);

   221         --cols;

   222         endInsertColumns();

   223     }

   224 

   225     void removeLastRow()

   226     {

   227         beginRemoveRows(QModelIndex(), rows - 1, rows - 1);

   228         --rows;

   229         endRemoveRows();

   230     }

   231 

   232     void removeAllRows()

   233     {

   234         beginRemoveRows(QModelIndex(), 0, rows - 1);

   235         rows = 0;

   236         endRemoveRows();

   237     }

   238 

   239     void removeOneColumn(int col)

   240     {

   241         beginRemoveColumns(QModelIndex(), col, col);

   242         --cols;

   243         endRemoveColumns();

   244     }

   245 

   246     void removeLastColumn()

   247     {

   248         beginRemoveColumns(QModelIndex(), cols - 1, cols - 1);

   249         --cols;

   250         endRemoveColumns();

   251     }

   252 

   253     void removeAllColumns()

   254     {

   255         beginRemoveColumns(QModelIndex(), 0, cols - 1);

   256         cols = 0;

   257         endRemoveColumns();

   258     }

   259 

   260     void cleanup()

   261     {

   262         cols = 3;

   263         rows = 3;

   264         emit layoutChanged();

   265     }

   266 

   267     int cols, rows;

   268     mutable bool wrongIndex;

   269 };

   270 

   271 // Testing get/set functions

   272 void tst_QHeaderView::getSetCheck()

   273 {

   274     protected_QHeaderView obj1(Qt::Horizontal);

   275     // bool QHeaderView::highlightSections()

   276     // void QHeaderView::setHighlightSections(bool)

   277     obj1.setHighlightSections(false);

   278     QCOMPARE(false, obj1.highlightSections());

   279     obj1.setHighlightSections(true);

   280     QCOMPARE(true, obj1.highlightSections());

   281 

   282     // bool QHeaderView::stretchLastSection()

   283     // void QHeaderView::setStretchLastSection(bool)

   284     obj1.setStretchLastSection(false);

   285     QCOMPARE(false, obj1.stretchLastSection());

   286     obj1.setStretchLastSection(true);

   287     QCOMPARE(true, obj1.stretchLastSection());

   288 

   289     // int QHeaderView::defaultSectionSize()

   290     // void QHeaderView::setDefaultSectionSize(int)

   291     obj1.setDefaultSectionSize(0);

   292     QCOMPARE(0, obj1.defaultSectionSize());

   293     obj1.setDefaultSectionSize(INT_MIN);

   294     QCOMPARE(INT_MIN, obj1.defaultSectionSize());

   295     obj1.setDefaultSectionSize(INT_MAX);

   296     QCOMPARE(INT_MAX, obj1.defaultSectionSize());

   297     // ### the test above does not make sense for values below 0

   298 

   299     // int QHeaderView::minimumSectionSize()

   300     // void QHeaderView::setMinimumSectionSize(int)

   301     obj1.setMinimumSectionSize(0);

   302     QCOMPARE(0, obj1.minimumSectionSize());

   303     obj1.setMinimumSectionSize(INT_MIN);

   304     QCOMPARE(INT_MIN, obj1.minimumSectionSize());

   305     obj1.setMinimumSectionSize(INT_MAX);

   306     QCOMPARE(INT_MAX, obj1.minimumSectionSize());

   307     // ### the test above does not make sense for values below 0

   308 

   309     // int QHeaderView::offset()

   310     // void QHeaderView::setOffset(int)

   311     obj1.setOffset(0);

   312     QCOMPARE(0, obj1.offset());

   313     obj1.setOffset(INT_MIN);

   314     QCOMPARE(INT_MIN, obj1.offset());

   315     obj1.setOffset(INT_MAX);

   316     QCOMPARE(INT_MAX, obj1.offset());

   317 

   318 }

   319 

   320 tst_QHeaderView::tst_QHeaderView()

   321 {

   322     qRegisterMetaType<int>("Qt::SortOrder");

   323 }

   324 

   325 tst_QHeaderView::~tst_QHeaderView()

   326 {

   327 }

   328 

   329 void tst_QHeaderView::initTestCase()

   330 {

   331 #ifdef Q_OS_WINCE //disable magic for WindowsCE

   332     qApp->setAutoMaximizeThreshold(-1);

   333 #endif

   334 }

   335 

   336 void tst_QHeaderView::cleanupTestCase()

   337 {

   338 }

   339 

   340 void tst_QHeaderView::init()

   341 {

   342     view = new QHeaderView(Qt::Vertical);

   343     // Some initial value tests before a model is added

   344     QCOMPARE(view->length(), 0);

   345     QVERIFY(view->sizeHint() == QSize(0,0));

   346     QCOMPARE(view->sectionSizeHint(0), -1);

   347 

   348     /*

   349     model = new QStandardItemModel(1, 1);

   350     view->setModel(model);

   351     //qDebug() << view->count();

   352     view->sizeHint();

   353     */

   354 

   355     int rows = 4;

   356     int columns = 4;

   357     model = new QStandardItemModel(rows, columns);

   358     /*

   359     for (int row = 0; row < rows; ++row) {

   360         for (int column = 0; column < columns; ++column) {

   361             QModelIndex index = model->index(row, column, QModelIndex());

   362             model->setData(index, QVariant((row+1) * (column+1)));

   363         }

   364     }

   365     */

   366 

   367     QSignalSpy spy(view, SIGNAL(sectionCountChanged(int, int)));

   368     view->setModel(model);

   369     QCOMPARE(spy.count(), 1);

   370     view->show();

   371 }

   372 

   373 void tst_QHeaderView::cleanup()

   374 {

   375     delete view;

   376     view = 0;

   377     delete model;

   378     model = 0;

   379 }

   380 

   381 void tst_QHeaderView::noModel()

   382 {

   383     QHeaderView emptyView(Qt::Vertical);

   384     QCOMPARE(emptyView.count(), 0);

   385 }

   386 

   387 void tst_QHeaderView::emptyModel()

   388 {

   389     QtTestModel testmodel;

   390     view->setModel(&testmodel);

   391     QVERIFY(!testmodel.wrongIndex);

   392     QCOMPARE(view->count(), testmodel.rows);

   393     view->setModel(model);

   394 }

   395 

   396 void tst_QHeaderView::removeRows()

   397 {

   398     QtTestModel model;

   399     model.rows = model.cols = 10;

   400 

   401     QHeaderView vertical(Qt::Vertical);

   402     QHeaderView horizontal(Qt::Horizontal);

   403 

   404     vertical.setModel(&model);

   405     horizontal.setModel(&model);

   406     vertical.show();

   407     horizontal.show();

   408     QCOMPARE(vertical.count(), model.rows);

   409     QCOMPARE(horizontal.count(), model.cols);

   410 

   411     model.removeLastRow();

   412     QVERIFY(!model.wrongIndex);

   413     QCOMPARE(vertical.count(), model.rows);

   414     QCOMPARE(horizontal.count(), model.cols);

   415 

   416     model.removeAllRows();

   417     QVERIFY(!model.wrongIndex);

   418     QCOMPARE(vertical.count(), model.rows);

   419     QCOMPARE(horizontal.count(), model.cols);

   420 }

   421 

   422 

   423 void tst_QHeaderView::removeCols()

   424 {

   425     QtTestModel model;

   426     model.rows = model.cols = 10;

   427 

   428     QHeaderView vertical(Qt::Vertical);

   429     QHeaderView horizontal(Qt::Horizontal);

   430     vertical.setModel(&model);

   431     horizontal.setModel(&model);

   432     vertical.show();

   433     horizontal.show();

   434     QCOMPARE(vertical.count(), model.rows);

   435     QCOMPARE(horizontal.count(), model.cols);

   436 

   437     model.removeLastColumn();

   438     QVERIFY(!model.wrongIndex);

   439     QCOMPARE(vertical.count(), model.rows);

   440     QCOMPARE(horizontal.count(), model.cols);

   441 

   442     model.removeAllColumns();

   443     QVERIFY(!model.wrongIndex);

   444     QCOMPARE(vertical.count(), model.rows);

   445     QCOMPARE(horizontal.count(), model.cols);

   446 }

   447 

   448 void tst_QHeaderView::movable()

   449 {

   450     QCOMPARE(view->isMovable(), false);

   451     view->setMovable(false);

   452     QCOMPARE(view->isMovable(), false);

   453     view->setMovable(true);

   454     QCOMPARE(view->isMovable(), true);

   455 }

   456 

   457 void tst_QHeaderView::clickable()

   458 {

   459     QCOMPARE(view->isClickable(), false);

   460     view->setClickable(false);

   461     QCOMPARE(view->isClickable(), false);

   462     view->setClickable(true);

   463     QCOMPARE(view->isClickable(), true);

   464 }

   465 

   466 void tst_QHeaderView::hidden()

   467 {

   468     //hideSection() & showSection call setSectionHidden

   469     // Test bad arguments

   470     QCOMPARE(view->isSectionHidden(-1), false);

   471     QCOMPARE(view->isSectionHidden(view->count()), false);

   472     QCOMPARE(view->isSectionHidden(999999), false);

   473 

   474     view->setSectionHidden(-1, true);

   475     view->setSectionHidden(view->count(), true);

   476     view->setSectionHidden(999999, true);

   477     view->setSectionHidden(-1, false);

   478     view->setSectionHidden(view->count(), false);

   479     view->setSectionHidden(999999, false);

   480 

   481     // Hidden sections shouldn't have visual properties (except position)

   482     int pos = view->defaultSectionSize();

   483     view->setSectionHidden(1, true);

   484     QCOMPARE(view->sectionSize(1), 0);

   485     QCOMPARE(view->sectionPosition(1), pos);

   486     view->resizeSection(1, 100);

   487     QCOMPARE(view->sectionViewportPosition(1), pos);

   488     QCOMPARE(view->sectionSize(1), 0);

   489     view->setSectionHidden(1, false);

   490     QCOMPARE(view->isSectionHidden(0), false);

   491     QCOMPARE(view->sectionSize(0), view->defaultSectionSize());

   492 }

   493 

   494 void tst_QHeaderView::stretch()

   495 {

   496     // Show before resize and setStrechLastSection

   497 #if defined(Q_OS_WINCE)

   498     QSize viewSize(200,300);

   499 #else

   500     QSize viewSize(500, 500);

   501 #endif

   502     view->resize(viewSize);

   503     view->setStretchLastSection(true);

   504     QCOMPARE(view->stretchLastSection(), true);

   505     view->show();

   506     QCOMPARE(view->width(), viewSize.width());

   507     QCOMPARE(view->visualIndexAt(view->viewport()->height() - 5), 3);

   508 

   509     view->setSectionHidden(3, true);

   510     QCOMPARE(view->visualIndexAt(view->viewport()->height() - 5), 2);

   511 

   512     view->setStretchLastSection(false);

   513     QCOMPARE(view->stretchLastSection(), false);

   514 }

   515 

   516 void tst_QHeaderView::oneSectionSize()

   517 {

   518     //this ensures that if there is only one section, it gets a correct width (more than 0)

   519     QHeaderView view (Qt::Vertical);

   520     QtTestModel model;

   521     model.cols = 1;

   522     model.rows = 1;

   523 

   524     view.setResizeMode(QHeaderView::Interactive);

   525     view.setModel(&model);

   526 

   527     view.show();

   528 

   529     QVERIFY(view.sectionSize(0) > 0);

   530 }

   531 

   532 

   533 void tst_QHeaderView::sectionSize_data()

   534 {

   535     QTest::addColumn<QList<int> >("boundsCheck");

   536     QTest::addColumn<QList<int> >("defaultSizes");

   537     QTest::addColumn<int>("initialDefaultSize");

   538     QTest::addColumn<int>("lastVisibleSectionSize");

   539     QTest::addColumn<int>("persistentSectionSize");

   540 

   541     QTest::newRow("data set one")

   542         << (QList<int>() << -1 << 0 << 4 << 9999)

   543         << (QList<int>() << 10 << 30 << 30)

   544         << 30

   545         << 300

   546         << 20;

   547 }

   548 

   549 void tst_QHeaderView::sectionSize()

   550 {

   551     QFETCH(QList<int>, boundsCheck);

   552     QFETCH(QList<int>, defaultSizes);

   553     QFETCH(int, initialDefaultSize);

   554     QFETCH(int, lastVisibleSectionSize);

   555     QFETCH(int, persistentSectionSize);

   556 

   557 #ifdef Q_OS_WINCE

   558     // We test on a device with doubled pixels. Therefore we need to specify

   559     // different boundaries.

   560     initialDefaultSize = qMax(view->minimumSectionSize(), 30);

   561 #endif

   562 

   563     // bounds check

   564     foreach (int val, boundsCheck)

   565         view->sectionSize(val);

   566 

   567     // default size

   568     QCOMPARE(view->defaultSectionSize(), initialDefaultSize);

   569     foreach (int def, defaultSizes) {

   570         view->setDefaultSectionSize(def);

   571         QCOMPARE(view->defaultSectionSize(), def);

   572     }

   573 

   574     view->setDefaultSectionSize(initialDefaultSize);

   575     for (int s = 0; s < view->count(); ++s)

   576         QCOMPARE(view->sectionSize(s), initialDefaultSize);

   577     view->doItemsLayout();

   578 

   579     // stretch last section

   580     view->setStretchLastSection(true);

   581     int lastSection = view->count() - 1;

   582 

   583     //test that when hiding the last column,

   584     //resizing the new last visible columns still works

   585     view->hideSection(lastSection);

   586     view->resizeSection(lastSection - 1, lastVisibleSectionSize);

   587     QCOMPARE(view->sectionSize(lastSection - 1), lastVisibleSectionSize);

   588     view->showSection(lastSection);

   589 

   590     // turn off stretching

   591     view->setStretchLastSection(false);

   592     QCOMPARE(view->sectionSize(lastSection), initialDefaultSize);

   593 

   594     // test persistence

   595     int sectionCount = view->count();

   596     for (int i = 0; i < sectionCount; ++i)

   597         view->resizeSection(i, persistentSectionSize);

   598     QtTestModel model;

   599     model.cols = sectionCount * 2;

   600     model.rows = sectionCount * 2;

   601     view->setModel(&model);

   602     for (int j = 0; j < sectionCount; ++j)

   603         QCOMPARE(view->sectionSize(j), persistentSectionSize);

   604     for (int k = sectionCount; k < view->count(); ++k)

   605         QCOMPARE(view->sectionSize(k), initialDefaultSize);

   606 }

   607 

   608 void tst_QHeaderView::visualIndex()

   609 {

   610     // Test bad arguments

   611     QCOMPARE(view->visualIndex(999999), -1);

   612     QCOMPARE(view->visualIndex(-1), -1);

   613     QCOMPARE(view->visualIndex(1), 1);

   614     view->setSectionHidden(1, true);

   615     QCOMPARE(view->visualIndex(1), 1);

   616     QCOMPARE(view->visualIndex(2), 2);

   617 

   618     view->setSectionHidden(1, false);

   619     QCOMPARE(view->visualIndex(1), 1);

   620     QCOMPARE(view->visualIndex(2), 2);

   621 }

   622 

   623 void tst_QHeaderView::visualIndexAt_data()

   624 {

   625     QTest::addColumn<QList<int> >("hidden");

   626     QTest::addColumn<QList<int> >("from");

   627     QTest::addColumn<QList<int> >("to");

   628     QTest::addColumn<QList<int> >("coordinate");

   629     QTest::addColumn<QList<int> >("visual");

   630 

   631     QList<int> coordinateList;

   632 #ifndef Q_OS_WINCE

   633     coordinateList << -1 << 0 << 31 << 91 << 99999;

   634 #else

   635     // We test on a device with doubled pixels. Therefore we need to specify

   636     // different boundaries.

   637     coordinateList << -1 << 0 << 33 << 97 << 99999;

   638 #endif

   639 

   640     QTest::newRow("no hidden, no moved sections")

   641         << QList<int>()

   642         << QList<int>()

   643         << QList<int>()

   644         << coordinateList

   645         << (QList<int>() << -1 << 0 << 1 << 3 << -1);

   646 

   647     QTest::newRow("no hidden, moved sections")

   648         << QList<int>()

   649         << (QList<int>() << 0)

   650         << (QList<int>() << 1)

   651         << coordinateList

   652         << (QList<int>() << -1 << 0 << 1 << 3 << -1);

   653 

   654     QTest::newRow("hidden, no moved sections")

   655         << (QList<int>() << 0)

   656         << QList<int>()

   657         << QList<int>()

   658         << coordinateList

   659         << (QList<int>() << -1 << 1 << 2 << 3 << -1);

   660 }

   661 

   662 void tst_QHeaderView::visualIndexAt()

   663 {

   664     QFETCH(QList<int>, hidden);

   665     QFETCH(QList<int>, from);

   666     QFETCH(QList<int>, to);

   667     QFETCH(QList<int>, coordinate);

   668     QFETCH(QList<int>, visual);

   669 

   670     view->setStretchLastSection(true);

   671     view->show();

   672 

   673     for (int i = 0; i < hidden.count(); ++i)

   674         view->setSectionHidden(hidden.at(i), true);

   675 

   676     for (int j = 0; j < from.count(); ++j)

   677         view->moveSection(from.at(j), to.at(j));

   678 

   679     for (int k = 0; k < coordinate.count(); ++k)

   680         QCOMPARE(view->visualIndexAt(coordinate.at(k)), visual.at(k));

   681 }

   682 

   683 void tst_QHeaderView::length()

   684 {

   685 #if defined(Q_OS_WINCE)

   686     QFont font(QLatin1String("Tahoma"), 7);

   687     view->setFont(font);

   688 #elif defined(Q_OS_SYMBIAN)

   689     QFont font(QLatin1String("Series 60 Sans"), 6);

   690     view->setFont(font);

   691 #endif

   692     view->setStretchLastSection(true);

   693     view->show();

   694 

   695     //minimumSectionSize should be the size of the last section of the widget is not tall enough

   696     int length = view->minimumSectionSize();

   697     for (int i=0; i < view->count()-1; i++) {

   698         length += view->sectionSize(i);

   699     }

   700 

   701     length = qMax(length, view->viewport()->height());

   702     QCOMPARE(length, view->length());

   703 

   704     view->setStretchLastSection(false);

   705     view->show();

   706 

   707     QVERIFY(length != view->length());

   708 

   709     // layoutChanged might mean rows have been removed

   710     QtTestModel model;

   711     model.cols = 10;

   712     model.rows = 10;

   713     view->setModel(&model);

   714     int oldLength = view->length();

   715     model.cleanup();

   716     QCOMPARE(model.rows, view->count());

   717     QVERIFY(oldLength != view->length());

   718 }

   719 

   720 void tst_QHeaderView::offset()

   721 {

   722     QCOMPARE(view->offset(), 0);

   723     view->setOffset(10);

   724     QCOMPARE(view->offset(), 10);

   725     view->setOffset(0);

   726     QCOMPARE(view->offset(), 0);

   727 

   728     // Test odd arguments

   729     view->setOffset(-1);

   730 }

   731 

   732 void tst_QHeaderView::sectionSizeHint()

   733 {

   734     // Test bad arguments

   735     view->sectionSizeHint(-1);

   736     view->sectionSizeHint(99999);

   737 

   738     // TODO how to test the return value?

   739 }

   740 

   741 void tst_QHeaderView::logicalIndex()

   742 {

   743     // Test bad arguments

   744     QCOMPARE(view->logicalIndex(-1), -1);

   745     QCOMPARE(view->logicalIndex(99999), -1);

   746 }

   747 

   748 void tst_QHeaderView::logicalIndexAt()

   749 {

   750     // Test bad arguments

   751     view->logicalIndexAt(-1);

   752     view->logicalIndexAt(99999);

   753     QCOMPARE(view->logicalIndexAt(0), 0);

   754     QCOMPARE(view->logicalIndexAt(1), 0);

   755 

   756     view->show();

   757     view->setStretchLastSection(true);

   758     // First item

   759     QCOMPARE(view->logicalIndexAt(0), 0);

   760     QCOMPARE(view->logicalIndexAt(view->sectionSize(0)-1), 0);

   761     QCOMPARE(view->logicalIndexAt(view->sectionSize(0)+1), 1);

   762     // Last item

   763     int last = view->length() - 1;//view->viewport()->height() - 10;

   764     QCOMPARE(view->logicalIndexAt(last), 3);

   765     // Not in widget

   766     int outofbounds = view->length() + 1;//view->viewport()->height() + 1;

   767     QCOMPARE(view->logicalIndexAt(outofbounds), -1);

   768 

   769     view->moveSection(0,1);

   770     // First item

   771     QCOMPARE(view->logicalIndexAt(0), 1);

   772     QCOMPARE(view->logicalIndexAt(view->sectionSize(0)-1), 1);

   773     QCOMPARE(view->logicalIndexAt(view->sectionSize(0)+1), 0);

   774     // Last item

   775     QCOMPARE(view->logicalIndexAt(last), 3);

   776     view->moveSection(1,0);

   777 

   778 }

   779 

   780 void tst_QHeaderView::swapSections()

   781 {

   782     view->swapSections(-1, 1);

   783     view->swapSections(99999, 1);

   784     view->swapSections(1, -1);

   785     view->swapSections(1, 99999);

   786 

   787     QVector<int> logical = (QVector<int>() << 0 << 1 << 2 << 3);

   788 

   789     QSignalSpy spy1(view, SIGNAL(sectionMoved(int, int, int)));

   790 

   791     QCOMPARE(view->sectionsMoved(), false);

   792     view->swapSections(1, 1);

   793     QCOMPARE(view->sectionsMoved(), false);

   794     view->swapSections(1, 2);

   795     QCOMPARE(view->sectionsMoved(), true);

   796     view->swapSections(2, 1);

   797     QCOMPARE(view->sectionsMoved(), true);

   798     for (int i = 0; i < view->count(); ++i)

   799         QCOMPARE(view->logicalIndex(i), logical.at(i));

   800     QCOMPARE(spy1.count(), 4);

   801 

   802     logical = (QVector<int>()  << 3 << 1 << 2 << 0);

   803     view->swapSections(3, 0);

   804     QCOMPARE(view->sectionsMoved(), true);

   805     for (int j = 0; j < view->count(); ++j)

   806         QCOMPARE(view->logicalIndex(j), logical.at(j));

   807     QCOMPARE(spy1.count(), 6);

   808 }

   809 

   810 void tst_QHeaderView::moveSection_data()

   811 {

   812     QTest::addColumn<QList<int> >("hidden");

   813     QTest::addColumn<QList<int> >("from");

   814     QTest::addColumn<QList<int> >("to");

   815     QTest::addColumn<QList<bool> >("moved");

   816     QTest::addColumn<QList<int> >("logical");

   817     QTest::addColumn<int>("count");

   818 

   819     QTest::newRow("bad args, no hidden")

   820         << QList<int>()

   821         << (QList<int>() << -1 << 1 << 99999 << 1)

   822         << (QList<int>() << 1 << -1 << 1 << 99999)

   823         << (QList<bool>() << false << false << false << false)

   824         << (QList<int>() << 0 << 1 << 2 << 3)

   825         << 0;

   826 

   827     QTest::newRow("good args, no hidden")

   828         << QList<int>()

   829         << (QList<int>() << 1 << 1 << 2 << 1)

   830         << (QList<int>() << 1 << 2 << 1 << 2)

   831         << (QList<bool>() << false << true << true << true)

   832         << (QList<int>() << 0 << 2 << 1 << 3)

   833         << 3;

   834 

   835     QTest::newRow("hidden sections")

   836         << (QList<int>() << 0 << 3)

   837         << (QList<int>() << 1 << 1 << 2 << 1)

   838         << (QList<int>() << 1 << 2 << 1 << 2)

   839         << (QList<bool>() << false << true << true << true)

   840         << (QList<int>() << 0 << 2 << 1 << 3)

   841         << 3;

   842 }

   843 

   844 void tst_QHeaderView::moveSection()

   845 {

   846     QFETCH(QList<int>, hidden);

   847     QFETCH(QList<int>, from);

   848     QFETCH(QList<int>, to);

   849     QFETCH(QList<bool>, moved);

   850     QFETCH(QList<int>, logical);

   851     QFETCH(int, count);

   852 

   853     QVERIFY(from.count() == to.count());

   854     QVERIFY(from.count() == moved.count());

   855     QVERIFY(view->count() == logical.count());

   856 

   857     QSignalSpy spy1(view, SIGNAL(sectionMoved(int, int, int)));

   858     QCOMPARE(view->sectionsMoved(), false);

   859 

   860     for (int h = 0; h < hidden.count(); ++h)

   861         view->setSectionHidden(hidden.at(h), true);

   862 

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

   864         view->moveSection(from.at(i), to.at(i));

   865         QCOMPARE(view->sectionsMoved(), moved.at(i));

   866     }

   867 

   868     for (int j = 0; j < view->count(); ++j)

   869         QCOMPARE(view->logicalIndex(j), logical.at(j));

   870 

   871     QCOMPARE(spy1.count(), count);

   872 }

   873 

   874 void tst_QHeaderView::resizeAndMoveSection_data()

   875 {

   876     QTest::addColumn<IntList>("logicalIndexes");

   877     QTest::addColumn<IntList>("sizes");

   878     QTest::addColumn<int>("logicalFrom");

   879     QTest::addColumn<int>("logicalTo");

   880 

   881     QTest::newRow("resizeAndMove-1")

   882         << (IntList() << 0 << 1)

   883         << (IntList() << 20 << 40)

   884         << 0 << 1;

   885 

   886     QTest::newRow("resizeAndMove-2")

   887         << (IntList() << 0 << 1 << 2 << 3)

   888         << (IntList() << 20 << 60 << 10 << 80)

   889         << 0 << 2;

   890 

   891     QTest::newRow("resizeAndMove-3")

   892         << (IntList() << 0 << 1 << 2 << 3)

   893         << (IntList() << 100 << 60 << 40 << 10)

   894         << 0 << 3;

   895 

   896     QTest::newRow("resizeAndMove-4")

   897         << (IntList() << 0 << 1 << 2 << 3)

   898         << (IntList() << 10 << 40 << 80 << 30)

   899         << 1 << 2;

   900 

   901     QTest::newRow("resizeAndMove-5")

   902         << (IntList() << 2 << 3)

   903         << (IntList() << 100 << 200)

   904         << 3 << 2;

   905 }

   906 

   907 void tst_QHeaderView::resizeAndMoveSection()

   908 {

   909     QFETCH(IntList, logicalIndexes);

   910     QFETCH(IntList, sizes);

   911     QFETCH(int, logicalFrom);

   912     QFETCH(int, logicalTo);

   913 

   914     // Save old visual indexes and sizes

   915     IntList oldVisualIndexes;

   916     IntList oldSizes;

   917     foreach (int logical, logicalIndexes) {

   918         oldVisualIndexes.append(view->visualIndex(logical));

   919         oldSizes.append(view->sectionSize(logical));

   920     }

   921 

   922     // Resize sections

   923     for (int i = 0; i < logicalIndexes.size(); ++i) {

   924         int logical = logicalIndexes.at(i);

   925         view->resizeSection(logical, sizes.at(i));

   926     }

   927 

   928     // Move sections

   929     int visualFrom = view->visualIndex(logicalFrom);

   930     int visualTo = view->visualIndex(logicalTo);

   931     view->moveSection(visualFrom, visualTo);

   932     QCOMPARE(view->visualIndex(logicalFrom), visualTo);

   933 

   934     // Check that sizes are still correct

   935     for (int i = 0; i < logicalIndexes.size(); ++i) {

   936         int logical = logicalIndexes.at(i);

   937         QCOMPARE(view->sectionSize(logical), sizes.at(i));

   938     }

   939 

   940     // Move sections back

   941     view->moveSection(visualTo, visualFrom);

   942 

   943     // Check that sizes are still correct

   944     for (int i = 0; i < logicalIndexes.size(); ++i) {

   945         int logical = logicalIndexes.at(i);

   946         QCOMPARE(view->sectionSize(logical), sizes.at(i));

   947     }

   948 

   949     // Put everything back as it was

   950     for (int i = 0; i < logicalIndexes.size(); ++i) {

   951         int logical = logicalIndexes.at(i);

   952         view->resizeSection(logical, oldSizes.at(i));

   953         QCOMPARE(view->visualIndex(logical), oldVisualIndexes.at(i));

   954     }

   955 }

   956 

   957 void tst_QHeaderView::resizeHiddenSection_data()

   958 {

   959     QTest::addColumn<int>("section");

   960     QTest::addColumn<int>("initialSize");

   961     QTest::addColumn<int>("finalSize");

   962 

   963     QTest::newRow("section 0 resize 50 to 20")

   964         << 0 << 50 << 20;

   965 

   966     QTest::newRow("section 1 resize 50 to 20")

   967         << 1 << 50 << 20;

   968 

   969     QTest::newRow("section 2 resize 50 to 20")

   970         << 2 << 50 << 20;

   971 

   972     QTest::newRow("section 3 resize 50 to 20")

   973         << 3 << 50 << 20;

   974 }

   975 

   976 void tst_QHeaderView::resizeHiddenSection()

   977 {

   978     QFETCH(int, section);

   979     QFETCH(int, initialSize);

   980     QFETCH(int, finalSize);

   981 

   982     view->resizeSection(section, initialSize);

   983     view->setSectionHidden(section, true);

   984     QCOMPARE(view->sectionSize(section), 0);

   985 

   986     view->resizeSection(section, finalSize);

   987     QCOMPARE(view->sectionSize(section), 0);

   988 

   989     view->setSectionHidden(section, false);

   990     QCOMPARE(view->sectionSize(section), finalSize);

   991 }

   992 

   993 void tst_QHeaderView::resizeAndInsertSection_data()

   994 {

   995     QTest::addColumn<int>("section");

   996     QTest::addColumn<int>("size");

   997     QTest::addColumn<int>("insert");

   998     QTest::addColumn<int>("compare");

   999     QTest::addColumn<int>("expected");

  1000 

  1001     QTest::newRow("section 0 size 50 insert 0")

  1002         << 0 << 50 << 0 << 1 << 50;

  1003 

  1004     QTest::newRow("section 1 size 50 insert 1")

  1005         << 0 << 50 << 1 << 0 << 50;

  1006 

  1007     QTest::newRow("section 1 size 50 insert 0")

  1008         << 1 << 50 << 0 << 2 << 50;

  1009 

  1010 }

  1011 

  1012 void tst_QHeaderView::resizeAndInsertSection()

  1013 {

  1014     QFETCH(int, section);

  1015     QFETCH(int, size);

  1016     QFETCH(int, insert);

  1017     QFETCH(int, compare);

  1018     QFETCH(int, expected);

  1019 

  1020     view->setStretchLastSection(false);

  1021 

  1022     view->resizeSection(section, size);

  1023     QCOMPARE(view->sectionSize(section), size);

  1024 

  1025     model->insertRow(insert);

  1026 

  1027     QCOMPARE(view->sectionSize(compare), expected);

  1028 }

  1029 

  1030 void tst_QHeaderView::resizeWithResizeModes_data()

  1031 {

  1032     QTest::addColumn<int>("size");

  1033     QTest::addColumn<QList<int> >("sections");

  1034     QTest::addColumn<QList<int> >("modes");

  1035     QTest::addColumn<QList<int> >("expected");

  1036 

  1037     QTest::newRow("stretch first section")

  1038         << 600

  1039         << (QList<int>() << 100 << 100 << 100 << 100)

  1040         << (QList<int>() << ((int)QHeaderView::Stretch)

  1041                          << ((int)QHeaderView::Interactive)

  1042                          << ((int)QHeaderView::Interactive)

  1043                          << ((int)QHeaderView::Interactive))

  1044         << (QList<int>() << 300 << 100 << 100 << 100);

  1045 }

  1046 

  1047 void  tst_QHeaderView::resizeWithResizeModes()

  1048 {

  1049     QFETCH(int, size);

  1050     QFETCH(QList<int>, sections);

  1051     QFETCH(QList<int>, modes);

  1052     QFETCH(QList<int>, expected);

  1053 

  1054     view->setStretchLastSection(false);

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

  1056         view->resizeSection(i, sections.at(i));

  1057         view->setResizeMode(i, (QHeaderView::ResizeMode)modes.at(i));

  1058     }

  1059     view->show();

  1060     view->resize(size, size);

  1061     for (int j = 0; j < expected.count(); ++j)

  1062         QCOMPARE(view->sectionSize(j), expected.at(j));

  1063 }

  1064 

  1065 void tst_QHeaderView::moveAndInsertSection_data()

  1066 {

  1067     QTest::addColumn<int>("from");

  1068     QTest::addColumn<int>("to");

  1069     QTest::addColumn<int>("insert");

  1070     QTest::addColumn<QList<int> >("mapping");

  1071 

  1072     QTest::newRow("move from 1 to 3, insert 0")

  1073         << 1 << 3 << 0 <<(QList<int>() << 0 << 1 << 3 << 4 << 2);

  1074 

  1075 }

  1076 

  1077 void tst_QHeaderView::moveAndInsertSection()

  1078 {

  1079     QFETCH(int, from);

  1080     QFETCH(int, to);

  1081     QFETCH(int, insert);

  1082     QFETCH(QList<int>, mapping);

  1083 

  1084     view->setStretchLastSection(false);

  1085 

  1086     view->moveSection(from, to);

  1087 

  1088     model->insertRow(insert);

  1089 

  1090     for (int i = 0; i < mapping.count(); ++i)

  1091         QCOMPARE(view->logicalIndex(i), mapping.at(i));

  1092 }

  1093 

  1094 void tst_QHeaderView::resizeMode()

  1095 {

  1096     // Q_ASSERT's when resizeMode is called with an invalid index

  1097     int last = view->count() - 1;

  1098     view->setResizeMode(QHeaderView::Interactive);

  1099     QCOMPARE(view->resizeMode(last), QHeaderView::Interactive);

  1100     QCOMPARE(view->resizeMode(1), QHeaderView::Interactive);

  1101     view->setResizeMode(QHeaderView::Stretch);

  1102     QCOMPARE(view->resizeMode(last), QHeaderView::Stretch);

  1103     QCOMPARE(view->resizeMode(1), QHeaderView::Stretch);

  1104     view->setResizeMode(QHeaderView::Custom);

  1105     QCOMPARE(view->resizeMode(last), QHeaderView::Custom);

  1106     QCOMPARE(view->resizeMode(1), QHeaderView::Custom);

  1107 

  1108     // test when sections have been moved

  1109     view->setStretchLastSection(false);

  1110     for (int i=0; i < (view->count() - 1); ++i)

  1111         view->setResizeMode(i, QHeaderView::Interactive);

  1112     int logicalIndex = view->count() / 2;

  1113     view->setResizeMode(logicalIndex, QHeaderView::Stretch);

  1114     view->moveSection(view->visualIndex(logicalIndex), 0);

  1115     for (int i=0; i < (view->count() - 1); ++i) {

  1116         if (i == logicalIndex)

  1117             QCOMPARE(view->resizeMode(i), QHeaderView::Stretch);

  1118         else

  1119             QCOMPARE(view->resizeMode(i), QHeaderView::Interactive);

  1120     }

  1121 }

  1122 

  1123 void tst_QHeaderView::resizeSection_data()

  1124 {

  1125     QTest::addColumn<int>("initial");

  1126     QTest::addColumn<QList<int> >("logical");

  1127     QTest::addColumn<QList<int> >("size");

  1128     QTest::addColumn<QList<int> >("mode");

  1129     QTest::addColumn<int>("resized");

  1130     QTest::addColumn<QList<int> >("expected");

  1131 

  1132     QTest::newRow("bad args")

  1133         << 100

  1134         << (QList<int>() << -1 << -1 << 99999 << 99999 << 4)