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 

    45 #include <QtGui/QtGui>

    46 

    47 //TESTED_CLASS=

    48 //TESTED_FILES=

    49 

    50 class tst_QItemSelectionModel : public QObject

    51 {

    52     Q_OBJECT

    53 

    54 public:

    55     tst_QItemSelectionModel();

    56     virtual ~tst_QItemSelectionModel();

    57 

    58 

    59 public slots:

    60     void initTestCase();

    61     void cleanupTestCase();

    62     void init();

    63 private slots:

    64     void clear_data();

    65     void clear();

    66     void clearAndSelect();

    67     void toggleSelection();

    68     void select_data();

    69     void select();

    70     void persistentselections_data();

    71     void persistentselections();

    72     void resetModel();

    73     void removeRows_data();

    74     void removeRows();

    75     void removeColumns_data();

    76     void removeColumns();

    77     void modelLayoutChanged_data();

    78     void modelLayoutChanged();

    79     void selectedRows_data();

    80     void selectedRows();

    81     void selectedColumns_data();

    82     void selectedColumns();

    83     void setCurrentIndex();

    84     void splitOnInsert();

    85     void task196285_rowIntersectsSelection();

    86     void unselectable();

    87     void task220420_selectedIndexes();

    88     void task240734_layoutChanged();

    89     void merge_data();

    90     void merge();

    91     void task119433_isRowSelected();

    92     void task252069_rowIntersectsSelection();

    93     void task232634_childrenDeselectionSignal();

    94     void task260134_layoutChangedWithAllSelected();

    95 

    96 private:

    97     QAbstractItemModel *model;

    98     QItemSelectionModel *selection;

    99 };

   100 

   101 QDataStream &operator<<(QDataStream &, const QModelIndex &);

   102 QDataStream &operator>>(QDataStream &, QModelIndex &);

   103 QDataStream &operator<<(QDataStream &, const QModelIndexList &);

   104 QDataStream &operator>>(QDataStream &, QModelIndexList &);

   105 

   106 typedef QList<int> IntList;

   107 typedef QPair<int, int> IntPair;

   108 typedef QList<IntPair> PairList;

   109 

   110 

   111 Q_DECLARE_METATYPE(PairList)

   112 Q_DECLARE_METATYPE(QModelIndex)

   113 Q_DECLARE_METATYPE(QModelIndexList)

   114 Q_DECLARE_METATYPE(IntList)

   115 Q_DECLARE_METATYPE(QItemSelection)

   116 

   117 class QStreamHelper: public QAbstractItemModel

   118 {

   119 public:

   120     QStreamHelper() {}

   121     static QModelIndex create(int row = -1, int column = -1, void *data = 0)

   122     {

   123         QStreamHelper helper;

   124         return helper.QAbstractItemModel::createIndex(row, column, data);

   125     }

   126 

   127     QModelIndex index(int, int, const QModelIndex&) const

   128         { return QModelIndex(); }

   129     QModelIndex parent(const QModelIndex&) const

   130         { return QModelIndex(); }

   131     int rowCount(const QModelIndex & = QModelIndex()) const

   132         { return 0; }

   133     int columnCount(const QModelIndex & = QModelIndex()) const

   134         { return 0; }

   135     QVariant data(const QModelIndex &, int = Qt::DisplayRole) const

   136         { return QVariant(); }

   137     bool hasChildren(const QModelIndex &) const

   138         { return false; }

   139 };

   140 

   141 QDataStream &operator<<(QDataStream &s, const QModelIndex &input)

   142 {

   143     s << input.row()

   144       << input.column()

   145       << reinterpret_cast<qlonglong>(input.internalPointer());

   146     return s;

   147 }

   148 

   149 QDataStream &operator>>(QDataStream &s, QModelIndex &output)

   150 {

   151     int r, c;

   152     qlonglong ptr;

   153     s >> r;

   154     s >> c;

   155     s >> ptr;

   156     output = QStreamHelper::create(r, c, reinterpret_cast<void *>(ptr));

   157     return s;

   158 }

   159 

   160 QDataStream &operator<<(QDataStream &s, const QModelIndexList &input)

   161 {

   162     s << input.count();

   163     for (int i=0; i<input.count(); ++i)

   164         s << input.at(i);

   165     return s;

   166 }

   167 

   168 QDataStream &operator>>(QDataStream &s, QModelIndexList &output)

   169 {

   170     QModelIndex tmpIndex;

   171     int count;

   172     s >> count;

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

   174         s >> tmpIndex;

   175         output << tmpIndex;

   176     }

   177     return s;

   178 }

   179 

   180 tst_QItemSelectionModel::tst_QItemSelectionModel() : model(0), selection(0)

   181 {

   182 }

   183 

   184 tst_QItemSelectionModel::~tst_QItemSelectionModel()

   185 {

   186 }

   187 

   188 /*

   189   This test usually uses a model with a 5x5 table

   190   -------------------------------------------

   191   |  0,0  |  0,1    |  0,2  |  0,3    |  0,4  |

   192   -------------------------------------------

   193   |  1,0  |  1,1    |  1,2  |  1,3    |  1,4  |

   194   -------------------------------------------

   195   |  2,0  |  2,1    |  2,2  |  2,3    |  2,4  |

   196   -------------------------------------------

   197   |  3,0  |  3,1    |  3,2  |  3,3    |  3,4  |

   198   -------------------------------------------

   199   |  4,0  |  4,1    |  4,2  |  4,3    |  4,4  |

   200   -------------------------------------------

   201 

   202   ...that for each row has a children in a new 5x5 table ad infinitum.

   203 

   204 */

   205 void tst_QItemSelectionModel::initTestCase()

   206 {

   207     qRegisterMetaType<QItemSelection>("QItemSelection");

   208 

   209     model = new QStandardItemModel(5, 5);

   210     QModelIndex parent = model->index(0, 0, QModelIndex());

   211     model->insertRows(0, 5, parent);

   212     model->insertColumns(0, 5, parent);

   213     selection  = new QItemSelectionModel(model);

   214 }

   215 

   216 void tst_QItemSelectionModel::cleanupTestCase()

   217 {

   218     delete selection;

   219     delete model;

   220 }

   221 

   222 void tst_QItemSelectionModel::init()

   223 {

   224     selection->clear();

   225     while (model->rowCount(QModelIndex()) > 5)

   226         model->removeRow(0, QModelIndex());

   227     while (model->rowCount(QModelIndex()) < 5)

   228         model->insertRow(0, QModelIndex());

   229 }

   230 

   231 void tst_QItemSelectionModel::clear_data()

   232 {

   233     QTest::addColumn<QModelIndexList>("indexList");

   234     QTest::addColumn<IntList>("commandList");

   235     {

   236         QModelIndexList index;

   237         IntList command;

   238         index << model->index(0, 0, QModelIndex());

   239         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   240         index << model->index(1, 0, QModelIndex());

   241         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   242         QTest::newRow("(0, 0) and (1, 0): Select|Rows")

   243             << index

   244             << command;

   245     }

   246     {

   247         QModelIndexList index;

   248         IntList command;

   249         index << model->index(0, 0, QModelIndex());

   250         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   251         index << model->index(0, 1, QModelIndex());

   252         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   253         QTest::newRow("(0, 0) and (1, 0): Select|Columns")

   254             << index

   255             << command;

   256     }

   257     {

   258         QModelIndexList index;

   259         IntList command;

   260         index << model->index(0, 0, QModelIndex());

   261         command << QItemSelectionModel::Select;

   262         index << model->index(1, 1, QModelIndex());

   263         command << QItemSelectionModel::Select;

   264         index << model->index(2, 2, QModelIndex());

   265         command << QItemSelectionModel::SelectCurrent;

   266         QTest::newRow("(0, 0), (1, 1) and (2, 2): Select, Select, SelectCurrent")

   267             << index

   268             << command;

   269     }

   270     {

   271         QModelIndexList index;

   272         IntList command;

   273         index << model->index(0, 0, QModelIndex());

   274         command << QItemSelectionModel::Select;

   275         index << model->index(1, 1, QModelIndex());

   276         command << QItemSelectionModel::Select;

   277         index << model->index(1, 1, QModelIndex());

   278         command << QItemSelectionModel::Toggle;

   279         QTest::newRow("(0, 0), (1, 1) and (1, 1): Select, Select, Toggle")

   280             << index

   281             << command;

   282     }

   283     {

   284         QModelIndexList index;

   285         IntList command;

   286         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   287         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   288         QTest::newRow("child (0, 0) of (0, 0): Select|Rows")

   289             << index

   290             << command;

   291     }

   292 }

   293 

   294 void tst_QItemSelectionModel::clear()

   295 {

   296     QFETCH(QModelIndexList, indexList);

   297     QFETCH(IntList, commandList);

   298 

   299     // do selections

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

   301         selection->select(indexList.at(i), (QItemSelectionModel::SelectionFlags)commandList.at(i));

   302     }

   303     // test that we have selected items

   304     QVERIFY(!selection->selectedIndexes().isEmpty());

   305     selection->clear();

   306     // test that they were all cleared

   307     QVERIFY(selection->selectedIndexes().isEmpty());

   308 }

   309 

   310 void tst_QItemSelectionModel::clearAndSelect()

   311 {

   312     // populate selectionmodel

   313     selection->select(model->index(1, 1, QModelIndex()), QItemSelectionModel::Select);

   314     QCOMPARE(selection->selectedIndexes().count(), 1);

   315 	QVERIFY(selection->hasSelection());

   316 

   317     // ClearAndSelect with empty selection

   318     QItemSelection emptySelection;

   319     selection->select(emptySelection, QItemSelectionModel::ClearAndSelect);

   320 

   321     // verify the selectionmodel is empty

   322     QVERIFY(selection->selectedIndexes().isEmpty());

   323 	QVERIFY(selection->hasSelection()==false);

   324 }

   325 

   326 void tst_QItemSelectionModel::toggleSelection()

   327 {

   328 	//test the toggle selection and checks whether selectedIndex

   329 	//and hasSelection returns the correct value

   330 

   331 	selection->clearSelection();

   332     QCOMPARE(selection->selectedIndexes().count(), 0);

   333 	QVERIFY(selection->hasSelection()==false);

   334 

   335 	QModelIndex index=model->index(1, 1, QModelIndex());

   336     // populate selectionmodel

   337     selection->select(index, QItemSelectionModel::Toggle);

   338     QCOMPARE(selection->selectedIndexes().count(), 1);

   339 	QVERIFY(selection->hasSelection()==true);

   340 

   341     selection->select(index, QItemSelectionModel::Toggle);

   342     QCOMPARE(selection->selectedIndexes().count(), 0);

   343 	QVERIFY(selection->hasSelection()==false);

   344 

   345     // populate selectionmodel with rows

   346     selection->select(index, QItemSelectionModel::Toggle | QItemSelectionModel::Rows);

   347     QCOMPARE(selection->selectedIndexes().count(), model->columnCount());

   348 	QVERIFY(selection->hasSelection()==true);

   349 

   350     selection->select(index, QItemSelectionModel::Toggle | QItemSelectionModel::Rows);

   351     QCOMPARE(selection->selectedIndexes().count(), 0);

   352 	QVERIFY(selection->hasSelection()==false);

   353 

   354 }

   355 

   356 

   357 void tst_QItemSelectionModel::select_data()

   358 {

   359     QTest::addColumn<QModelIndexList>("indexList");

   360     QTest::addColumn<bool>("useRanges");

   361     QTest::addColumn<IntList>("commandList");

   362     QTest::addColumn<QModelIndexList>("expectedList");

   363 

   364     {

   365         QModelIndexList index;

   366         QModelIndexList expected;

   367         IntList command;

   368         index << model->index(0, 0, QModelIndex());

   369         command << QItemSelectionModel::Select;

   370         expected << model->index(0, 0, QModelIndex());

   371         QTest::newRow("(0, 0): Select")

   372             << index

   373             << false

   374             << command

   375             << expected;

   376     }

   377     {

   378         QModelIndexList index;

   379         QModelIndexList expected;

   380         IntList command;

   381         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   382         command << QItemSelectionModel::Select;

   383         expected << model->index(0, 0, model->index(0, 0, QModelIndex()));

   384         QTest::newRow("child (0, 0) of (0, 0): Select")

   385             << index

   386             << false

   387             << command

   388             << expected;

   389     }

   390     {

   391         QModelIndexList index;

   392         QModelIndexList expected;

   393         IntList command;

   394         index << model->index(0, 0, QModelIndex());

   395         command << QItemSelectionModel::Deselect;

   396         QTest::newRow("(0, 0): Deselect")

   397             << index

   398             << false

   399             << command

   400             << expected;

   401     }

   402     {

   403         QModelIndexList index;

   404         QModelIndexList expected;

   405         IntList command;

   406         index << model->index(0, 0, QModelIndex());

   407         command << QItemSelectionModel::Toggle;

   408         expected << model->index(0, 0, QModelIndex());

   409         QTest::newRow("(0, 0): Toggle")

   410             << index

   411             << false

   412             << command

   413             << expected;

   414     }

   415     {

   416         QModelIndexList index;

   417         QModelIndexList expected;

   418         IntList command;

   419         index << model->index(0, 0, QModelIndex());

   420         command << QItemSelectionModel::Select;

   421         index << model->index(0, 0, QModelIndex());

   422         command << QItemSelectionModel::Toggle;

   423         QTest::newRow("(0, 0) and (0, 0): Select and Toggle")

   424             << index

   425             << false

   426             << command

   427             << expected;

   428     }

   429     {

   430         QModelIndexList index;

   431         QModelIndexList expected;

   432         IntList command;

   433         index << model->index(0, 0, QModelIndex());

   434         command << QItemSelectionModel::Select;

   435         index << model->index(0, 0, QModelIndex());

   436         command << QItemSelectionModel::Deselect;

   437         QTest::newRow("(0, 0) and (0, 0): Select and Deselect")

   438             << index

   439             << false

   440             << command

   441             << expected;

   442     }

   443     {

   444         QModelIndexList index;

   445         QModelIndexList expected;

   446         IntList command;

   447         index << model->index(0, 0, QModelIndex());

   448         command << QItemSelectionModel::Select;

   449         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   450         command << QItemSelectionModel::ClearAndSelect;

   451         expected << model->index(0, 0, model->index(0, 0, QModelIndex()));

   452         QTest::newRow("(0, 0) and child (0, 0) of (0, 0): Select and ClearAndSelect")

   453             << index

   454             << false

   455             << command

   456             << expected;

   457     }

   458     {

   459         QModelIndexList index;

   460         QModelIndexList expected;

   461         IntList command;

   462         index << model->index(0, 0, QModelIndex());

   463         index << model->index(4, 0, QModelIndex());

   464         command << QItemSelectionModel::Select;

   465         index << model->index(0, 1, QModelIndex());

   466         index << model->index(4, 1, QModelIndex());

   467         command << QItemSelectionModel::Select;

   468         index << model->index(0, 0, QModelIndex());

   469         index << model->index(4, 1, QModelIndex());

   470         command << QItemSelectionModel::Deselect;

   471         QTest::newRow("(0, 0 to 4, 0) and (0, 1 to 4, 1) and (0, 0 to 4, 1): Select and Select and Deselect")

   472             << index

   473             << true

   474             << command

   475             << expected;

   476     }

   477     {

   478         QModelIndexList index;

   479         QModelIndexList expected;

   480         IntList command;

   481         index << model->index(0, 0, QModelIndex());

   482         command << QItemSelectionModel::Select;

   483         index << model->index(4, 4, QModelIndex());

   484         command << QItemSelectionModel::Select;

   485         expected << model->index(0, 0, QModelIndex()) << model->index(4, 4, QModelIndex());

   486         QTest::newRow("(0, 0) and (4, 4): Select")

   487             << index

   488             << false

   489             << command

   490             << expected;

   491     }

   492     {

   493         QModelIndexList index;

   494         QModelIndexList expected;

   495         IntList command;

   496         index << model->index(0, 0, QModelIndex());

   497         command << QItemSelectionModel::Select;

   498         index << model->index(4, 4, QModelIndex());

   499         command << QItemSelectionModel::ClearAndSelect;

   500         expected << model->index(4, 4, QModelIndex());

   501         QTest::newRow("(0, 0) and (4, 4): Select and ClearAndSelect")

   502             << index

   503             << false

   504             << command

   505             << expected;

   506     }

   507     {

   508         QModelIndexList index;

   509         QModelIndexList expected;

   510         IntList command;

   511         index << model->index(0, 0, QModelIndex());

   512         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   513         index << model->index(4, 4, QModelIndex());

   514         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   515         expected << model->index(0, 0, QModelIndex())

   516                  << model->index(0, 1, QModelIndex())

   517                  << model->index(0, 2, QModelIndex())

   518                  << model->index(0, 3, QModelIndex())

   519                  << model->index(0, 4, QModelIndex())

   520                  << model->index(4, 0, QModelIndex())

   521                  << model->index(4, 1, QModelIndex())

   522                  << model->index(4, 2, QModelIndex())

   523                  << model->index(4, 3, QModelIndex())

   524                  << model->index(4, 4, QModelIndex());

   525         QTest::newRow("(0, 0) and (4, 4): Select|Rows")

   526             << index

   527             << false

   528             << command

   529             << expected;

   530     }

   531     {

   532         QModelIndexList index;

   533         QModelIndexList expected;

   534         IntList command;

   535         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   536         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   537         index << model->index(4, 4, model->index(0, 0, QModelIndex()));

   538         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   539         QModelIndex parent = model->index(0, 0, QModelIndex());

   540         expected << model->index(0, 0, parent)

   541                  << model->index(0, 1, parent)

   542                  << model->index(0, 2, parent)

   543                  << model->index(0, 3, parent)

   544                  << model->index(0, 4, parent)

   545                  << model->index(4, 0, parent)

   546                  << model->index(4, 1, parent)

   547                  << model->index(4, 2, parent)

   548                  << model->index(4, 3, parent)

   549                  << model->index(4, 4, parent);

   550         QTest::newRow("child (0, 0) and (4, 4) of (0, 0): Select|Rows")

   551             << index

   552             << false

   553             << command

   554             << expected;

   555     }

   556     {

   557         QModelIndexList index;

   558         QModelIndexList expected;

   559         IntList command;

   560         index << model->index(0, 0, QModelIndex());

   561         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   562         index << model->index(4, 4, QModelIndex());

   563         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   564         expected << model->index(0, 0, QModelIndex())

   565                  << model->index(1, 0, QModelIndex())

   566                  << model->index(2, 0, QModelIndex())

   567                  << model->index(3, 0, QModelIndex())

   568                  << model->index(4, 0, QModelIndex())

   569                  << model->index(0, 4, QModelIndex())

   570                  << model->index(1, 4, QModelIndex())

   571                  << model->index(2, 4, QModelIndex())

   572                  << model->index(3, 4, QModelIndex())

   573                  << model->index(4, 4, QModelIndex());

   574         QTest::newRow("(0, 0) and (4, 4): Select|Columns")

   575             << index

   576             << false

   577             << command

   578             << expected;

   579     }

   580     {

   581         QModelIndexList index;

   582         QModelIndexList expected;

   583         IntList command;

   584         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   585         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   586         index << model->index(4, 4, model->index(0, 0, QModelIndex()));

   587         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   588         expected << model->index(0, 0, model->index(0, 0, QModelIndex()))

   589                  << model->index(1, 0, model->index(0, 0, QModelIndex()))

   590                  << model->index(2, 0, model->index(0, 0, QModelIndex()))

   591                  << model->index(3, 0, model->index(0, 0, QModelIndex()))

   592                  << model->index(4, 0, model->index(0, 0, QModelIndex()))

   593                  << model->index(0, 4, model->index(0, 0, QModelIndex()))

   594                  << model->index(1, 4, model->index(0, 0, QModelIndex()))

   595                  << model->index(2, 4, model->index(0, 0, QModelIndex()))

   596                  << model->index(3, 4, model->index(0, 0, QModelIndex()))

   597                  << model->index(4, 4, model->index(0, 0, QModelIndex()));

   598         QTest::newRow("child (0, 0) and (4, 4) of (0, 0): Select|Columns")

   599             << index

   600             << false

   601             << command

   602             << expected;

   603     }

   604     {

   605         QModelIndexList index;

   606         QModelIndexList expected;

   607         IntList command;

   608         index << model->index(0, 0, QModelIndex());

   609         index << model->index(4, 0, QModelIndex());

   610         command << QItemSelectionModel::Select;

   611         expected << model->index(0, 0, QModelIndex())

   612                  << model->index(1, 0, QModelIndex())

   613                  << model->index(2, 0, QModelIndex())

   614                  << model->index(3, 0, QModelIndex())

   615                  << model->index(4, 0, QModelIndex());

   616         QTest::newRow("(0, 0 to 4, 0): Select")

   617             << index

   618             << true

   619             << command

   620             << expected;

   621     }

   622     /* ### FAILS

   623     {

   624         QModelIndexList index;

   625         QModelIndexList expected;

   626         IntList command;

   627         index << model->index(0, 0, QModelIndex());

   628         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   629         command << QItemSelectionModel::Select;

   630         QTest::newRow("(0, 0 to child 0, 0): Select")

   631             << index

   632             << true

   633             << command

   634             << expected;

   635     }

   636     */

   637     {

   638         QModelIndexList index;

   639         QModelIndexList expected;

   640         IntList command;

   641         index << model->index(0, 0, model->index(0, 0, QModelIndex()));

   642         index << model->index(0, 0, model->index(1, 0, QModelIndex()));

   643         command << QItemSelectionModel::Select;

   644         QTest::newRow("child (0, 0) of (0, 0) to child (0, 0) of (1, 0): Select")

   645             << index

   646             << true

   647             << command

   648             << expected;

   649     }

   650     {

   651         QModelIndexList index;

   652         QModelIndexList expected;

   653         IntList command;

   654         index << model->index(0, 0, QModelIndex());

   655         index << model->index(4, 4, QModelIndex());

   656         command << QItemSelectionModel::Select;

   657         expected << model->index(0, 0, QModelIndex())

   658                  << model->index(0, 1, QModelIndex())

   659                  << model->index(0, 2, QModelIndex())

   660                  << model->index(0, 3, QModelIndex())

   661                  << model->index(0, 4, QModelIndex())

   662                  << model->index(1, 0, QModelIndex())

   663                  << model->index(1, 1, QModelIndex())

   664                  << model->index(1, 2, QModelIndex())

   665                  << model->index(1, 3, QModelIndex())

   666                  << model->index(1, 4, QModelIndex())

   667                  << model->index(2, 0, QModelIndex())

   668                  << model->index(2, 1, QModelIndex())

   669                  << model->index(2, 2, QModelIndex())

   670                  << model->index(2, 3, QModelIndex())

   671                  << model->index(2, 4, QModelIndex())

   672                  << model->index(3, 0, QModelIndex())

   673                  << model->index(3, 1, QModelIndex())

   674                  << model->index(3, 2, QModelIndex())

   675                  << model->index(3, 3, QModelIndex())

   676                  << model->index(3, 4, QModelIndex())

   677                  << model->index(4, 0, QModelIndex())

   678                  << model->index(4, 1, QModelIndex())

   679                  << model->index(4, 2, QModelIndex())

   680                  << model->index(4, 3, QModelIndex())

   681                  << model->index(4, 4, QModelIndex());

   682         QTest::newRow("(0, 0 to 4, 4): Select")

   683             << index

   684             << true

   685             << command

   686             << expected;

   687     }

   688     {

   689         QModelIndexList index;

   690         QModelIndexList expected;

   691         IntList command;

   692         index << model->index(0, 0, QModelIndex());

   693         index << model->index(4, 0, QModelIndex());

   694         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   695         expected << model->index(0, 0, QModelIndex())

   696                  << model->index(0, 1, QModelIndex())

   697                  << model->index(0, 2, QModelIndex())

   698                  << model->index(0, 3, QModelIndex())

   699                  << model->index(0, 4, QModelIndex())

   700                  << model->index(1, 0, QModelIndex())

   701                  << model->index(1, 1, QModelIndex())

   702                  << model->index(1, 2, QModelIndex())

   703                  << model->index(1, 3, QModelIndex())

   704                  << model->index(1, 4, QModelIndex())

   705                  << model->index(2, 0, QModelIndex())

   706                  << model->index(2, 1, QModelIndex())

   707                  << model->index(2, 2, QModelIndex())

   708                  << model->index(2, 3, QModelIndex())

   709                  << model->index(2, 4, QModelIndex())

   710                  << model->index(3, 0, QModelIndex())

   711                  << model->index(3, 1, QModelIndex())

   712                  << model->index(3, 2, QModelIndex())

   713                  << model->index(3, 3, QModelIndex())

   714                  << model->index(3, 4, QModelIndex())

   715                  << model->index(4, 0, QModelIndex())

   716                  << model->index(4, 1, QModelIndex())

   717                  << model->index(4, 2, QModelIndex())

   718                  << model->index(4, 3, QModelIndex())

   719                  << model->index(4, 4, QModelIndex());

   720         QTest::newRow("(0, 0 to 4, 0): Select|Rows")

   721             << index

   722             << true

   723             << command

   724             << expected;

   725     }

   726     {

   727         QModelIndexList index;

   728         QModelIndexList expected;

   729         IntList command;

   730         index << model->index(0, 0, QModelIndex());

   731         index << model->index(0, 4, QModelIndex());

   732         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   733         expected << model->index(0, 0, QModelIndex())

   734                  << model->index(0, 1, QModelIndex())

   735                  << model->index(0, 2, QModelIndex())

   736                  << model->index(0, 3, QModelIndex())

   737                  << model->index(0, 4, QModelIndex())

   738                  << model->index(1, 0, QModelIndex())

   739                  << model->index(1, 1, QModelIndex())

   740                  << model->index(1, 2, QModelIndex())

   741                  << model->index(1, 3, QModelIndex())

   742                  << model->index(1, 4, QModelIndex())

   743                  << model->index(2, 0, QModelIndex())

   744                  << model->index(2, 1, QModelIndex())

   745                  << model->index(2, 2, QModelIndex())

   746                  << model->index(2, 3, QModelIndex())

   747                  << model->index(2, 4, QModelIndex())

   748                  << model->index(3, 0, QModelIndex())

   749                  << model->index(3, 1, QModelIndex())

   750                  << model->index(3, 2, QModelIndex())

   751                  << model->index(3, 3, QModelIndex())

   752                  << model->index(3, 4, QModelIndex())

   753                  << model->index(4, 0, QModelIndex())

   754                  << model->index(4, 1, QModelIndex())

   755                  << model->index(4, 2, QModelIndex())

   756                  << model->index(4, 3, QModelIndex())

   757                  << model->index(4, 4, QModelIndex());

   758         QTest::newRow("(0, 0 to 0, 4): Select|Columns")

   759             << index

   760             << true

   761             << command

   762             << expected;

   763     }

   764     {

   765         QModelIndexList index;

   766         QModelIndexList expected;

   767         IntList command;

   768         index << model->index(0, 0, QModelIndex());

   769         index << model->index(4, 4, QModelIndex());

   770         command << (QItemSelectionModel::Select | QItemSelectionModel::Rows);

   771         expected << model->index(0, 0, QModelIndex())

   772                  << model->index(0, 1, QModelIndex())

   773                  << model->index(0, 2, QModelIndex())

   774                  << model->index(0, 3, QModelIndex())

   775                  << model->index(0, 4, QModelIndex())

   776                  << model->index(1, 0, QModelIndex())

   777                  << model->index(1, 1, QModelIndex())

   778                  << model->index(1, 2, QModelIndex())

   779                  << model->index(1, 3, QModelIndex())

   780                  << model->index(1, 4, QModelIndex())

   781                  << model->index(2, 0, QModelIndex())

   782                  << model->index(2, 1, QModelIndex())

   783                  << model->index(2, 2, QModelIndex())

   784                  << model->index(2, 3, QModelIndex())

   785                  << model->index(2, 4, QModelIndex())

   786                  << model->index(3, 0, QModelIndex())

   787                  << model->index(3, 1, QModelIndex())

   788                  << model->index(3, 2, QModelIndex())

   789                  << model->index(3, 3, QModelIndex())

   790                  << model->index(3, 4, QModelIndex())

   791                  << model->index(4, 0, QModelIndex())

   792                  << model->index(4, 1, QModelIndex())

   793                  << model->index(4, 2, QModelIndex())

   794                  << model->index(4, 3, QModelIndex())

   795                  << model->index(4, 4, QModelIndex());

   796         QTest::newRow("(0, 0 to 4, 4): Select|Rows")

   797             << index

   798             << true

   799             << command

   800             << expected;

   801     }

   802     {

   803         QModelIndexList index;

   804         QModelIndexList expected;

   805         IntList command;

   806         index << model->index(0, 0, QModelIndex());

   807         index << model->index(4, 4, QModelIndex());

   808         command << (QItemSelectionModel::Select | QItemSelectionModel::Columns);

   809         expected << model->index(0, 0, QModelIndex())

   810                  << model->index(0, 1, QModelIndex())

   811                  << model->index(0, 2, QModelIndex())

   812                  << model->index(0, 3, QModelIndex())

   813                  << model->index(0, 4, QModelIndex())

   814                  << model->index(1, 0, QModelIndex())

   815                  << model->index(1, 1, QModelIndex())

   816                  << model->index(1, 2, QModelIndex())

   817                  << model->index(1, 3, QModelIndex())

   818                  << model->index(1, 4, QModelIndex())

   819                  << model->index(2, 0, QModelIndex())

   820                  << model->index(2, 1, QModelIndex())

   821                  << model->index(2, 2, QModelIndex())

   822                  << model->index(2, 3, QModelIndex())

   823                  << model->index(2, 4, QModelIndex())

   824                  << model->index(3, 0, QModelIndex())

   825                  << model->index(3, 1, QModelIndex())

   826                  << model->index(3, 2, QModelIndex())

   827                  << model->index(3, 3, QModelIndex())

   828                  << model->index(3, 4, QModelIndex())

   829                  << model->index(4, 0, QModelIndex())

   830                  << model->index(4, 1, QModelIndex())

   831                  << model->index(4, 2, QModelIndex())

   832                  << model->index(4, 3, QModelIndex())

   833                  << model->index(4, 4, QModelIndex());

   834         QTest::newRow("(0, 0 to 4, 4): Select|Columns")

   835             << index

   836             << true

   837             << command

   838             << expected;

   839     }

   840     {

   841         QModelIndexList index;

   842         QModelIndexList expected;

   843         IntList command;

   844         index << model->index(0, 2, QModelIndex());

   845         index << model->index(4, 2, QModelIndex());

   846         command << QItemSelectionModel::Select;

   847         index << model->index(2, 0, QModelIndex());

   848         index << model->index(2, 4, QModelIndex());

   849         command << QItemSelectionModel::Select;

   850         expected << model->index(0, 2, QModelIndex())

   851                  << model->index(1, 2, QModelIndex())

   852                  << model->index(2, 2, QModelIndex())

   853                  << model->index(3, 2, QModelIndex())

   854                  << model->index(4, 2, QModelIndex())

   855                  << model->index(2, 0, QModelIndex())

   856                  << model->index(2, 1, QModelIndex())

   857                  << model->index(2, 3, QModelIndex())

   858                  << model->index(2, 4, QModelIndex());

   859         QTest::newRow("(0, 2 to 4, 2) and (2, 0 to 2, 4): Select")

   860             << index

   861             << true

   862             << command

   863             << expected;

   864     }

   865     {

   866         QModelIndexList index;

   867         QModelIndexList expected;

   868         IntList command;

   869         index << model->index(0, 2, QModelIndex());

   870         index << model->index(4, 2, QModelIndex());

   871         command << QItemSelectionModel::Select;

   872         index << model->index(2, 0, QModelIndex());

   873         index << model->index(2, 4, QModelIndex());

   874         command << QItemSelectionModel::SelectCurrent;

   875         expected << model->index(2, 0, QModelIndex())

   876                  << model->index(2, 1, QModelIndex())

   877                  << model->index(2, 2, QModelIndex())

   878                  << model->index(2, 3, QModelIndex())

   879                  << model->index(2, 4, QModelIndex());

   880         QTest::newRow("(0, 2 to 4, 2) and (2, 0 to 2, 4): Select and SelectCurrent")

   881             << index

   882             << true

   883             << command

   884             << expected;

   885     }

   886     {

   887         QModelIndexList index;

   888         QModelIndexList expected;

   889         IntList command;

   890         index << model->index(0, 2, QModelIndex());

   891         index << model->index(4, 2, QModelIndex());

   892         command << QItemSelectionModel::Select;

   893         index << model->index(2, 0, QModelIndex());

   894         index << model->index(2, 4, QModelIndex());

   895         command << QItemSelectionModel::Toggle;

   896         expected << model->index(0, 2, QModelIndex())

   897                  << model->index(1, 2, QModelIndex())

   898                  << model->index(3, 2, QModelIndex())

   899                  << model->index(4, 2, QModelIndex())

   900                  << model->index(2, 0, QModelIndex())

   901                  << model->index(2, 1, QModelIndex())

   902                  << model->index(2, 3, QModelIndex())

   903                  << model->index(2, 4, QModelIndex());

   904         QTest::newRow("(0, 2 to 4, 2) and (2, 0 to 2, 4): Select and Toggle")

   905             << index

   906             << true

   907             << command

   908             << expected;

   909     }

   910     {

   911         QModelIndexList index;

   912         QModelIndexList expected;

   913         IntList command;

   914         index << model->index(0, 2, QModelIndex());

   915         index << model->index(4, 2, QModelIndex());

   916         command << QItemSelectionModel::Select;

   917         index << model->index(2, 0, QModelIndex());

   918         index << model->index(2, 4, QModelIndex());

   919         command << QItemSelectionModel::Deselect;

   920         expected << model->index(0, 2, QModelIndex())

   921                  << model->index(1, 2, QModelIndex())

   922                  << model->index(3, 2, QModelIndex())

   923                  << model->index(4, 2, QModelIndex());

   924         QTest::newRow("(0, 2 to 4, 2) and (2, 0 to 2, 4): Select and Deselect")

   925             << index

   926             << true

   927             << command

   928             << expected;

   929     }

   930 

   931     {

   932         QModelIndexList index;

   933         QModelIndexList expected;

   934         IntList command;

   935         index << model->index(0, 0, QModelIndex());

   936         index << model->index(2, 2, QModelIndex());

   937         command << QItemSelectionModel::Select;

   938 

   939         index << model->index(0, 0, QModelIndex());

   940         index << model->index(0, 0, QModelIndex());

   941         command << QItemSelectionModel::Toggle;

   942 

   943         expected << model->index(0, 1, QModelIndex())

   944                  << model->index(0, 2, QModelIndex())

   945                  << model->index(1, 0, QModelIndex())

   946                  << model->index(1, 1, QModelIndex())

   947                  << model->index(1, 2, QModelIndex())

   948                  << model->index(2, 0, QModelIndex())

   949                  << model->index(2, 1, QModelIndex())

   950                  << model->index(2, 2, QModelIndex());

   951 

   952         QTest::newRow("(0, 0 to 2, 2) and (0, 0 to 0, 0): Select and Toggle at selection boundary")

   953             << index

   954             << true

   955             << command

   956             << expected;

   957     }

   958 

   959     {

   960         QModelIndexList index;

   961         QModelIndexList expected;

   962         IntList command;

   963         index << model->index(0, 0, QModelIndex());

   964         index << model->index(2, 2, QModelIndex());

   965         command << QItemSelectionModel::Select;

   966 

   967         index << model->index(0, 1, QModelIndex());

   968         index << model->index(0, 1, QModelIndex());

   969         command << QItemSelectionModel::Toggle;

   970 

   971         expected << model->index(0, 0, QModelIndex())

   972                  << model->index(0, 2, QModelIndex())

   973                  << model->index(1, 0, QModelIndex())

   974                  << model->index(1, 1, QModelIndex())

   975                  << model->index(1, 2, QModelIndex())

   976                  << model->index(2, 0, QModelIndex())

   977                  << model->index(2, 1, QModelIndex())

   978                  << model->index(2, 2, QModelIndex());

   979 

   980         QTest::newRow("(0, 0 to 2, 2) and (0, 1 to 0, 1): Select and Toggle at selection boundary")

   981             << index

   982             << true

   983             << command

   984             << expected;

   985     }

   986 

   987     {

   988         QModelIndexList index;

   989         QModelIndexList expected;

   990         IntList command;

   991         index << model->index(0, 0, QModelIndex());

   992         index << model->index(2, 2, QModelIndex());

   993         command << QItemSelectionModel::Select;

   994 

   995         index << model->index(0, 2, QModelIndex());

   996         index << model->index(0, 2, QModelIndex());

   997         command << QItemSelectionModel::Toggle;

   998 

   999         expected << model->index(0, 0, QModelIndex())

  1000                  << model->index(0, 1, QModelIndex())

  1001                  << model->index(1, 0, QModelIndex())

  1002                  << model->index(1, 1, QModelIndex())

  1003                  << model->index(1, 2, QModelIndex())

  1004                  << model->index(2, 0, QModelIndex())

  1005                  << model->index(2, 1, QModelIndex())

  1006                  << model->index(2, 2, QModelIndex());

  1007 

  1008         QTest::newRow("(0, 0 to 2, 2) and (0, 2 to 0, 2): Select and Toggle at selection boundary")

  1009             << index

  1010             << true

  1011             << command

  1012             << expected;

  1013     }

  1014 

  1015     {

  1016         QModelIndexList index;

  1017         QModelIndexList expected;

  1018         IntList command;

  1019         index << model->index(0, 0, QModelIndex());

  1020         index << model->index(2, 2, QModelIndex());

  1021         command << QItemSelectionModel::Select;

  1022 

  1023         index << model->index(1, 0, QModelIndex());

  1024         index << model->index(1, 0, QModelIndex());

  1025         command << QItemSelectionModel::Toggle;

  1026 

  1027         expected << model->index(0, 0, QModelIndex())

  1028                  << model->index(0, 1, QModelIndex())

  1029                  << model->index(0, 2, QModelIndex())

  1030                  << model->index(1, 1, QModelIndex())

  1031                  << model->index(1, 2, QModelIndex())

  1032                  << model->index(2, 0, QModelIndex())

  1033                  << model->index(2, 1, QModelIndex())

  1034                  << model->index(2, 2, QModelIndex());

  1035 

  1036         QTest::newRow("(0, 0 to 2, 2) and (1, 0 to 1, 0): Select and Toggle at selection boundary")

  1037             << index

  1038             << true

  1039             << command

  1040             << expected;

  1041     }

  1042 

  1043     {

  1044         QModelIndexList index;

  1045         QModelIndexList expected;

  1046         IntList command;

  1047         index << model->index(0, 0, QModelIndex());

  1048         index << model->index(2, 2, QModelIndex());

  1049         command << QItemSelectionModel::Select;

  1050 

  1051         index << model->index(1, 1, QModelIndex());

  1052         index << model->index(1, 1, QModelIndex());

  1053         command << QItemSelectionModel::Toggle;

  1054 

  1055         expected << model->index(0, 0, QModelIndex())

  1056                  << model->index(0, 1, QModelIndex())

  1057                  << model->index(0, 2, QModelIndex())

  1058                  << model->index(1, 0, QModelIndex())

  1059                  << model->index(1, 2, QModelIndex())

  1060                  << model->index(2, 0, QModelIndex())

  1061                  << model->index(2, 1, QModelIndex())

  1062                  << model->index(2, 2, QModelIndex());

  1063 

  1064         QTest::newRow("(0, 0 to 2, 2) and (1, 1 to 1, 1): Select and Toggle at selection boundary")

  1065             << index

  1066             << true

  1067             << command

  1068             << expected;

  1069     }

  1070     {

  1071         QModelIndexList index;

  1072         QModelIndexList expected;

  1073         IntList command;

  1074         index << model->index(0, 0, QModelIndex());

  1075         index << model->index(2, 2, QModelIndex());

  1076         command << QItemSelectionModel::Select;

  1077 

  1078         index << model->index(1, 2, QModelIndex());

  1079         index << model->index(1, 2, QModelIndex());

  1080         command << QItemSelectionModel::Toggle;

  1081 

  1082         expected << model->index(0, 0, QModelIndex())

  1083                  << model->index(0, 1, QModelIndex())

  1084                  << model->index(0, 2, QModelIndex())

  1085                  << model->index(1, 0, QModelIndex())

  1086                  << model->index(1, 1, QModelIndex())

  1087                  << model->index(2, 0, QModelIndex())

  1088                  << model->index(2, 1, QModelIndex())

  1089                  << model->index(2, 2, QModelIndex());

  1090 

  1091         QTest::newRow("(0, 0 to 2, 2) and (1, 2 to 1, 2): Select and Toggle at selection boundary")

  1092             << index

  1093             << true

  1094             << command

  1095             << expected;

  1096     }

  1097     {

  1098         QModelIndexList index;

  1099         QModelIndexList expected;

  1100         IntList command;

  1101         index << model->index(0, 0, QModelIndex());

  1102         index << model->index(2, 2, QModelIndex());

  1103         command << QItemSelectionModel::Select;

  1104 

  1105         index << model->index(2, 0, QModelIndex());

  1106         index << model->index(2, 0, QModelIndex());

  1107         command << QItemSelectionModel::Toggle;

  1108 

  1109         expected << model->index(0, 0, QModelIndex())

  1110                  << model->index(0, 1, QModelIndex())

  1111                  << model->index(0, 2, QModelIndex())

  1112                  << model->index(1, 0, QModelIndex())

  1113                  << model->index(1, 1, QModelIndex())

  1114                  << model->index(1, 2, QModelIndex())

  1115                  << model->index(2, 1, QModelIndex())

  1116                  << model->index(2, 2, QModelIndex());

  1117 

  1118         QTest::newRow("(0, 0 to 2, 2) and (2, 0 to 2, 0): Select and Toggle at selection boundary")

  1119             << index

  1120             << true

  1121             << command

  1122             << expected;

  1123     }

  1124     {

  1125         QModelIndexList index;

  1126         QModelIndexList expected;

  1127         IntList command;

  1128         index << model->index(0, 0, QModelIndex());

  1129         index << model->index(2, 2, QModelIndex());

  1130         command << QItemSelectionModel::Select;

  1131 

  1132         index << model->index(2, 1, QModelIndex());

  1133         index << model->index(2, 1, QModelIndex());

  1134         command << QItemSelectionModel::Toggle;