Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

3 files changed, 1517 insertions, 0 deletions

diff --git a/tests/auto/qtablewidget/.gitignore b/tests/auto/qtablewidget/.gitignore
new file mode 100644
index 0000000000..13a9c67c0a
--- /dev/null
+++ b/tests/auto/qtablewidget/.gitignore
@@ -0,0 +1 @@
+tst_qtablewidget
diff --git a/tests/auto/qtablewidget/qtablewidget.pro b/tests/auto/qtablewidget/qtablewidget.pro
new file mode 100644
index 0000000000..d66d0ac67f
--- /dev/null
+++ b/tests/auto/qtablewidget/qtablewidget.pro
@@ -0,0 +1,16 @@
+load(qttest_p4)
+SOURCES  += tst_qtablewidget.cpp
+
+# This prevents the GCCE compile failure: "elf2e32: Error 1063: Fatal Error in
+# PostLinker." The paged statement is documented in the S60 docs.
+symbian {
+    MMP_RULES -= PAGED
+
+    custom_paged_rule = "$${LITERAL_HASH}ifndef GCCE"\
+                        "PAGED" \
+                        "$${LITERAL_HASH}endif"
+    MMP_RULES += custom_paged_rule
+}
+
+symbian:MMP_RULES += "OPTION   GCCE -mlong-calls"
+
diff --git a/tests/auto/qtablewidget/tst_qtablewidget.cpp b/tests/auto/qtablewidget/tst_qtablewidget.cpp
new file mode 100644
index 0000000000..d17e06484b
--- /dev/null
+++ b/tests/auto/qtablewidget/tst_qtablewidget.cpp
@@ -0,0 +1,1500 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <qeventloop.h>
+#include <qlist.h>
+#include <qpair.h>
+#include <qheaderview.h>
+
+#include <qtablewidget.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class QObjectTableItem : public QObject, public QTableWidgetItem
+{
+    Q_OBJECT
+};
+
+class tst_QTableWidget : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QTableWidget();
+    ~tst_QTableWidget();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+private slots:
+    void getSetCheck();
+    void clear();
+    void clearContents();
+    void rowCount();
+    void columnCount();
+    void itemAssignment();
+    void item_data();
+    void item();
+    void takeItem_data();
+    void takeItem();
+    void selectedItems_data();
+    void selectedItems();
+    void removeRow_data();
+    void removeRow();
+    void removeColumn_data();
+    void removeColumn();
+    void insertRow_data();
+    void insertRow();
+    void insertColumn_data();
+    void insertColumn();
+    void itemStreaming_data();
+    void itemStreaming();
+    void itemOwnership();
+    void sortItems_data();
+    void sortItems();
+    void setItemWithSorting_data();
+    void setItemWithSorting();
+    void itemData();
+    void setItemData();
+    void cellWidget();
+    void task231094();
+    void task219380_removeLastRow();
+    void task262056_sortDuplicate();
+
+private:
+    QTableWidget *testWidget;
+};
+
+typedef QPair<int, int> IntPair;
+typedef QList<int> IntList;
+typedef QList<IntPair> IntIntList;
+
+Q_DECLARE_METATYPE(IntList)
+Q_DECLARE_METATYPE(IntIntList)
+Q_DECLARE_METATYPE(QTableWidgetSelectionRange)
+Q_DECLARE_METATYPE(QModelIndex)
+
+
+// Testing get/set functions
+void tst_QTableWidget::getSetCheck()
+{
+    QTableWidget obj1;
+    // int QTableWidget::rowCount()
+    // void QTableWidget::setRowCount(int)
+    obj1.setRowCount(0);
+    QCOMPARE(0, obj1.rowCount());
+    obj1.setRowCount(INT_MIN);
+    QCOMPARE(0, obj1.rowCount()); // Row count can never be negative
+//    obj1.setRowCount(INT_MAX);
+//    QCOMPARE(INT_MAX, obj1.rowCount());
+    obj1.setRowCount(100);
+    QCOMPARE(100, obj1.rowCount());
+    
+
+    // int QTableWidget::columnCount()
+    // void QTableWidget::setColumnCount(int)
+    obj1.setColumnCount(0);
+    QCOMPARE(0, obj1.columnCount());
+    obj1.setColumnCount(INT_MIN);
+    QCOMPARE(0, obj1.columnCount()); // Column count can never be negative
+    obj1.setColumnCount(1000);
+    QCOMPARE(1000, obj1.columnCount());
+//    obj1.setColumnCount(INT_MAX);
+//    QCOMPARE(INT_MAX, obj1.columnCount());
+
+    // QTableWidgetItem * QTableWidget::currentItem()
+    // void QTableWidget::setCurrentItem(QTableWidgetItem *)
+    QTableWidgetItem *var3 = new QTableWidgetItem("0,0");
+    obj1.setItem(0, 0, var3);
+    obj1.setItem(1, 1, new QTableWidgetItem("1,1"));
+    obj1.setItem(2, 2, new QTableWidgetItem("2,2"));
+    obj1.setItem(3, 3, new QTableWidgetItem("3,3"));
+    obj1.setCurrentItem(var3);
+    QCOMPARE(var3, obj1.currentItem());
+    obj1.setCurrentItem((QTableWidgetItem *)0);
+    QCOMPARE((QTableWidgetItem *)0, obj1.currentItem());
+    obj1.setItem(0, 0, 0);
+    QCOMPARE((QTableWidgetItem *)0, obj1.item(0, 0));
+
+    // const QTableWidgetItem * QTableWidget::itemPrototype()
+    // void QTableWidget::setItemPrototype(const QTableWidgetItem *)
+    const QTableWidgetItem *var4 = new QTableWidgetItem;
+    obj1.setItemPrototype(var4);
+    QCOMPARE(var4, obj1.itemPrototype());
+    obj1.setItemPrototype((QTableWidgetItem *)0);
+    QCOMPARE((const QTableWidgetItem *)0, obj1.itemPrototype());
+}
+
+tst_QTableWidget::tst_QTableWidget(): testWidget(0)
+{
+}
+
+tst_QTableWidget::~tst_QTableWidget()
+{
+}
+
+void tst_QTableWidget::initTestCase()
+{
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    testWidget = new QTableWidget();
+    testWidget->show();
+}
+
+void tst_QTableWidget::cleanupTestCase()
+{
+    delete testWidget;
+}
+
+void tst_QTableWidget::init()
+{
+    testWidget->clear();
+    testWidget->setRowCount(5);
+    testWidget->setColumnCount(5);
+
+    for (int row=0; row < testWidget->rowCount(); ++row)
+        testWidget->showRow(row);
+    for (int column=0; column < testWidget->columnCount(); ++column)
+        testWidget->showColumn(column);
+}
+
+void tst_QTableWidget::cleanup()
+{
+
+}
+
+void tst_QTableWidget::clearContents()
+{
+    QTableWidgetItem *item = new QTableWidgetItem("test");
+    testWidget->setHorizontalHeaderItem(0, item);
+    QVERIFY(testWidget->horizontalHeaderItem(0) == item);
+    testWidget->clearContents();
+    QVERIFY(testWidget->horizontalHeaderItem(0) == item);
+}
+
+void tst_QTableWidget::clear()
+{
+    QTableWidgetItem *item = new QTableWidgetItem("foo");
+    testWidget->setItem(0, 0, item);
+    testWidget->setItemSelected(item, true);
+
+    QVERIFY(testWidget->item(0, 0) == item);
+    QVERIFY(testWidget->isItemSelected(item));
+
+
+    QPointer<QObjectTableItem> bla = new QObjectTableItem();
+    testWidget->setItem(1, 1, bla);
+
+    testWidget->clear();
+
+    QVERIFY(bla.isNull());
+
+    QVERIFY(!testWidget->item(0,0));
+    QVERIFY(!testWidget->selectedRanges().count());
+    QVERIFY(!testWidget->selectedItems().count());
+}
+
+void tst_QTableWidget::rowCount()
+{
+    int rowCountBefore = 5;
+    int rowCountAfter = 10;
+
+    int rowCount = testWidget->rowCount();
+    QCOMPARE(rowCount, rowCountBefore);
+
+    testWidget->setRowCount(rowCountAfter);
+    rowCount = testWidget->rowCount();
+    QCOMPARE(rowCount, rowCountAfter);
+
+    QPersistentModelIndex index(testWidget->model()->index(rowCountAfter - 1, 0,
+                                                           testWidget->rootIndex()));
+    QCOMPARE(index.row(), rowCountAfter - 1);
+    QCOMPARE(index.column(), 0);
+    QVERIFY(index.isValid());
+    testWidget->setRowCount(rowCountBefore);
+    QCOMPARE(index.row(), -1);
+    QCOMPARE(index.column(), -1);
+    QVERIFY(!index.isValid());
+
+    rowCountBefore = testWidget->rowCount();
+    testWidget->setRowCount(-1);
+    QCOMPARE(testWidget->rowCount(), rowCountBefore);
+}
+
+void tst_QTableWidget::columnCount()
+{
+    int columnCountBefore = 5;
+    int columnCountAfter = 10;
+
+    int columnCount = testWidget->columnCount();
+    QCOMPARE(columnCount, columnCountBefore);
+
+    testWidget->setColumnCount(columnCountAfter);
+    columnCount = testWidget->columnCount();
+    QCOMPARE(columnCount, columnCountAfter);
+
+    QPersistentModelIndex index(testWidget->model()->index(0, columnCountAfter - 1,
+                                                           testWidget->rootIndex()));
+    QCOMPARE(index.row(), 0);
+    QCOMPARE(index.column(), columnCountAfter - 1);
+    QVERIFY(index.isValid());
+    testWidget->setColumnCount(columnCountBefore);
+    QCOMPARE(index.row(), -1);
+    QCOMPARE(index.column(), -1);
+    QVERIFY(!index.isValid());
+
+    columnCountBefore = testWidget->columnCount();
+    testWidget->setColumnCount(-1);
+    QCOMPARE(testWidget->columnCount(), columnCountBefore);
+}
+
+void tst_QTableWidget::itemAssignment()
+{
+    QTableWidgetItem itemInWidget("inWidget");
+    testWidget->setItem(0, 0, &itemInWidget);
+    itemInWidget.setFlags(itemInWidget.flags() | Qt::ItemIsTristate);
+    QTableWidgetItem itemOutsideWidget("outsideWidget");
+
+    QVERIFY(itemInWidget.tableWidget());
+    QCOMPARE(itemInWidget.text(), QString("inWidget"));
+    QVERIFY(itemInWidget.flags() & Qt::ItemIsTristate);
+
+    QVERIFY(!itemOutsideWidget.tableWidget());
+    QCOMPARE(itemOutsideWidget.text(), QString("outsideWidget"));
+    QVERIFY(!(itemOutsideWidget.flags() & Qt::ItemIsTristate));
+
+    itemOutsideWidget = itemInWidget;
+    QVERIFY(!itemOutsideWidget.tableWidget());
+    QCOMPARE(itemOutsideWidget.text(), QString("inWidget"));
+    QVERIFY(itemOutsideWidget.flags() & Qt::ItemIsTristate);
+}
+
+void tst_QTableWidget::item_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("row");
+    QTest::addColumn<int>("column");
+    QTest::addColumn<bool>("expectItem");
+
+    QTest::newRow("0x0 take [0,0]") << 0 << 0 << 0 << 0 << false;
+    QTest::newRow("0x0 take [4,4]") << 0 << 0 << 4 << 4 << false;
+    QTest::newRow("4x4 take [0,0]") << 4 << 4 << 0 << 0 << true;
+    QTest::newRow("4x4 take [4,4]") << 4 << 4 << 4 << 4 << false;
+    QTest::newRow("4x4 take [2,2]") << 4 << 4 << 2 << 2 << true;
+}
+
+void tst_QTableWidget::item()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, row);
+    QFETCH(int, column);
+    QFETCH(bool, expectItem);
+
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    for (int r = 0; r < testWidget->rowCount(); ++r)
+        for (int c = 0; c < testWidget->columnCount(); ++c)
+            testWidget->setItem(r, c, new QTableWidgetItem(QString::number(r * c + c)));
+
+    for (int r = 0; r < testWidget->rowCount(); ++r)
+        for (int c = 0; c < testWidget->columnCount(); ++c)
+            QCOMPARE(testWidget->item(r, c)->text(), QString::number(r * c + c));
+
+    QTableWidgetItem *item = testWidget->item(row, column);
+    QCOMPARE(!!item, expectItem);
+    if (expectItem)
+        QCOMPARE(item->text(), QString::number(row * column + column));
+}
+
+void tst_QTableWidget::takeItem_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("row");
+    QTest::addColumn<int>("column");
+    QTest::addColumn<bool>("expectItem");
+
+    QTest::newRow("0x0 take [0,0]") << 0 << 0 << 0 << 0 << false;
+    QTest::newRow("0x0 take [4,4]") << 0 << 0 << 4 << 4 << false;
+    QTest::newRow("4x4 take [0,0]") << 4 << 4 << 0 << 0 << true;
+    QTest::newRow("4x4 take [4,4]") << 4 << 4 << 4 << 4 << false;
+    QTest::newRow("4x4 take [2,2]") << 4 << 4 << 2 << 2 << true;
+}
+
+void tst_QTableWidget::takeItem()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, row);
+    QFETCH(int, column);
+    QFETCH(bool, expectItem);
+
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    for (int r = 0; r < testWidget->rowCount(); ++r)
+        for (int c = 0; c < testWidget->columnCount(); ++c)
+            testWidget->setItem(r, c, new QTableWidgetItem(QString::number(r * c + c)));
+
+    for (int r = 0; r < testWidget->rowCount(); ++r)
+        for (int c = 0; c < testWidget->columnCount(); ++c)
+            QCOMPARE(testWidget->item(r, c)->text(), QString::number(r * c + c));
+
+    QTableWidgetItem *item = testWidget->takeItem(row, column);
+    QCOMPARE(!!item, expectItem);
+    if (expectItem) {
+        QCOMPARE(item->text(), QString::number(row * column + column));
+        delete item;
+    }
+    QVERIFY(!testWidget->takeItem(row, column));
+}
+
+void tst_QTableWidget::selectedItems_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<IntIntList>("createItems");
+    QTest::addColumn<IntList>("hiddenRows");
+    QTest::addColumn<IntList>("hiddenColumns");
+    QTest::addColumn<QTableWidgetSelectionRange>("selectionRange");
+    QTest::addColumn<IntIntList>("expectedItems");
+
+    QTest::newRow("3x3 empty cells, no hidden rows/columns, none selected")
+        << 3 << 3
+        << IntIntList()
+        << IntList()
+        << IntList()
+        << QTableWidgetSelectionRange()
+        << IntIntList();
+
+    QTest::newRow("3x3 empty cells,no hidden rows/columnms, all selected")
+        << 3 << 3
+        << IntIntList()
+        << IntList()
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << IntIntList();
+
+    QTest::newRow("3x3 (1,1) exists, no hidden rows/columnms, all selected")
+        << 3 << 3
+        << (IntIntList() << IntPair(1,1))
+        << IntList()
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << (IntIntList() << IntPair(1,1));
+
+    QTest::newRow("3x3 (1,1) exists, row 1 hidden, all selected")
+        << 3 << 3
+        << (IntIntList() << IntPair(1,1))
+        << (IntList() << 1)
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << IntIntList();
+
+    QTest::newRow("3x3 (1,1) exists, column 1 hidden, all selected")
+        << 3 << 3
+        << (IntIntList() << IntPair(1,1))
+        << IntList()
+        << (IntList() << 1)
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << IntIntList();
+
+    QTest::newRow("3x3 all exists, no hidden rows/columns, all selected")
+        << 3 << 3
+        << (IntIntList()
+            << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+            << IntPair(1,0) << IntPair(1,1) << IntPair(1,2)
+            << IntPair(2,0) << IntPair(2,1) << IntPair(2,2))
+        << IntList()
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << (IntIntList()
+            << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+            << IntPair(1,0) << IntPair(1,1) << IntPair(1,2)
+            << IntPair(2,0) << IntPair(2,1) << IntPair(2,2));
+
+    QTest::newRow("3x3 all exists, row 1 hidden, all selected")
+        << 3 << 3
+        << (IntIntList()
+            << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+            << IntPair(1,0) << IntPair(1,1) << IntPair(1,2)
+            << IntPair(2,0) << IntPair(2,1) << IntPair(2,2))
+        << (IntList() << 1)
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << (IntIntList()
+            << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+            << IntPair(2,0) << IntPair(2,1) << IntPair(2,2));
+
+    QTest::newRow("3x3 all exists, column 1 hidden, all selected")
+        << 3 << 3
+        << (IntIntList()
+            << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+            << IntPair(1,0) << IntPair(1,1) << IntPair(1,2)
+            << IntPair(2,0) << IntPair(2,1) << IntPair(2,2))
+        << IntList()
+        << (IntList() << 1)
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << (IntIntList()
+            << IntPair(0,0) << IntPair(0,2)
+            << IntPair(1,0) << IntPair(1,2)
+            << IntPair(2,0) << IntPair(2,2));
+
+    QTest::newRow("3x3 none exists, no hidden rows/columns, all selected")
+        << 3 << 3
+        << IntIntList()
+        << IntList()
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << IntIntList();
+//         << (IntIntList()
+//             << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+//             << IntPair(1,0) << IntPair(1,1) << IntPair(1,2)
+//             << IntPair(2,0) << IntPair(2,1) << IntPair(2,2));
+
+    QTest::newRow("3x3 none exists,  row 1 hidden, all selected, filling empty cells")
+        << 3 << 3
+        << IntIntList()
+        << (IntList() << 1)
+        << IntList()
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << IntIntList();
+//         << (IntIntList()
+//             << IntPair(0,0) << IntPair(0,1) << IntPair(0,2)
+//             << IntPair(2,0) << IntPair(2,1) << IntPair(2,2));
+
+    QTest::newRow("3x3 none exists,  column 1 hidden, all selected")
+        << 3 << 3
+        << IntIntList()
+        << IntList()
+        << (IntList() << 1)
+        << QTableWidgetSelectionRange(0, 0, 2, 2)
+        << IntIntList();
+//         << (IntIntList()
+//             << IntPair(0,0) << IntPair(0,2)
+//             << IntPair(1,0) << IntPair(1,2)
+//             << IntPair(2,0) << IntPair(2,2));
+}
+
+void tst_QTableWidget::selectedItems()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(IntIntList, createItems);
+    QFETCH(IntList, hiddenRows);
+    QFETCH(IntList, hiddenColumns);
+    QFETCH(QTableWidgetSelectionRange, selectionRange);
+    QFETCH(IntIntList, expectedItems);
+
+    // set dimensions and test they are ok
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    // create and set items
+    foreach (IntPair intPair, createItems) {
+        testWidget->setItem(intPair.first, intPair.second,
+                            new QTableWidgetItem(QString("Item %1 %2")
+                                                 .arg(intPair.first).arg(intPair.second)));
+    }
+    // hide rows/columns
+    foreach (int row, hiddenRows)
+        testWidget->setRowHidden(row, true);
+    foreach (int column, hiddenColumns)
+        testWidget->setColumnHidden(column, true);
+
+    // make sure we don't have any previous selections hanging around
+    QVERIFY(!testWidget->selectedRanges().count());
+    QVERIFY(!testWidget->selectedItems().count());
+
+    // select range and check that it is set correctly
+    testWidget->setRangeSelected(selectionRange, true);
+    if (selectionRange.topRow() >= 0) {
+        QCOMPARE(testWidget->selectedRanges().count(), 1);
+        QCOMPARE(testWidget->selectedRanges().at(0).topRow(), selectionRange.topRow());
+        QCOMPARE(testWidget->selectedRanges().at(0).bottomRow(), selectionRange.bottomRow());
+        QCOMPARE(testWidget->selectedRanges().at(0).leftColumn(), selectionRange.leftColumn());
+        QCOMPARE(testWidget->selectedRanges().at(0).rightColumn(), selectionRange.rightColumn());
+    } else {
+        QCOMPARE(testWidget->selectedRanges().count(), 0);
+    }
+
+    // check that the correct number of items and the expected items are there
+    QList<QTableWidgetItem *> selectedItems = testWidget->selectedItems();
+    QCOMPARE(selectedItems.count(), expectedItems.count());
+    foreach (IntPair intPair, expectedItems)
+        QVERIFY(selectedItems.contains(testWidget->item(intPair.first, intPair.second)));
+
+    // check that setItemSelected agrees with selectedItems
+    for (int row = 0; row<testWidget->rowCount(); ++row) {
+        bool hidden = false;
+        foreach (int hiddenRow, hiddenRows){
+            if(hiddenRow == row){
+                hidden = true;
+                break;
+            }
+        }
+        if (hidden)
+            continue;
+        
+        for (int column = 0; column<testWidget->columnCount(); ++column) {
+            foreach (int hiddenColumn, hiddenColumns){
+                if(hiddenColumn == column){
+                    hidden = true;
+                    break;
+                }
+            }
+            if (hidden)
+                continue;
+            
+            QTableWidgetItem *item = testWidget->item(row, column);
+            if (item && testWidget->isItemSelected(item))
+                QVERIFY(selectedItems.contains(item));
+        }
+    }
+}
+
+void tst_QTableWidget::removeRow_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("row");
+    QTest::addColumn<int>("expectedRowCount");
+    QTest::addColumn<int>("expectedColumnCount");
+
+    QTest::newRow("Empty") << 0 << 0 << 0 << 0 << 0;
+    QTest::newRow("1x1:0") << 1 << 1 << 0 << 0 << 1;
+    QTest::newRow("3x3:0") << 3 << 3 << 0 << 2 << 3;
+    QTest::newRow("3x3:1") << 3 << 3 << 1 << 2 << 3;
+    QTest::newRow("3x3:2") << 3 << 3 << 2 << 2 << 3;
+}
+
+void tst_QTableWidget::removeRow()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, row);
+    QFETCH(int, expectedRowCount);
+    QFETCH(int, expectedColumnCount);
+
+    // set dimensions and test they are ok
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    // fill table with items
+    for (int r = 0; r < rowCount; ++r)
+        for (int c = 0; c < columnCount; ++c)
+            testWidget->setItem(r, c,
+                                new QTableWidgetItem(
+                                    QString::number(r) + ":" + QString::number(c)));
+
+    // remove and compare the results
+    testWidget->removeRow(row);
+    QCOMPARE(testWidget->rowCount(), expectedRowCount);
+    QCOMPARE(testWidget->columnCount(), expectedColumnCount);
+
+    // check if the correct items were removed
+    for (int r = 0; r < expectedRowCount; ++r)
+        for (int c = 0; c < expectedColumnCount; ++c)
+            if (r < row)
+                QCOMPARE(testWidget->item(r, c)->text(),
+                        QString::number(r) + ":" + QString::number(c));
+            else
+                QCOMPARE(testWidget->item(r, c)->text(),
+                        QString::number(r + 1) + ":" + QString::number(c));
+}
+
+void tst_QTableWidget::removeColumn_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("column");
+    QTest::addColumn<int>("expectedRowCount");
+    QTest::addColumn<int>("expectedColumnCount");
+
+    QTest::newRow("Empty") << 0 << 0 << 0 << 0 << 0;
+    QTest::newRow("1x1:0") << 1 << 1 << 0 << 1 << 0;
+    QTest::newRow("3x3:0") << 3 << 3 << 0 << 3 << 2;
+    QTest::newRow("3x3:1") << 3 << 3 << 1 << 3 << 2;
+    QTest::newRow("3x3:2") << 3 << 3 << 2 << 3 << 2;
+}
+
+void tst_QTableWidget::removeColumn()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, column);
+    QFETCH(int, expectedRowCount);
+    QFETCH(int, expectedColumnCount);
+
+    // set dimensions and test they are ok
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    // fill table with items
+    for (int r = 0; r < rowCount; ++r)
+        for (int c = 0; c < columnCount; ++c)
+            testWidget->setItem(r, c,
+                                new QTableWidgetItem(
+                                    QString::number(r) + ":" + QString::number(c)));
+
+    // remove and compare the results
+    testWidget->removeColumn(column);
+    QCOMPARE(testWidget->rowCount(), expectedRowCount);
+    QCOMPARE(testWidget->columnCount(), expectedColumnCount);
+
+
+    // check if the correct items were removed
+    for (int r = 0; r < expectedRowCount; ++r)
+        for (int c = 0; c < expectedColumnCount; ++c)
+            if (c < column)
+                QCOMPARE(testWidget->item(r, c)->text(),
+                        QString::number(r) + ":" + QString::number(c));
+            else
+                QCOMPARE(testWidget->item(r, c)->text(),
+                        QString::number(r) + ":" + QString::number(c + 1));
+}
+
+void tst_QTableWidget::insertRow_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("row");
+    QTest::addColumn<int>("expectedRowCount");
+    QTest::addColumn<int>("expectedColumnCount");
+
+    QTest::newRow("Empty")  << 0 << 0 << 0  << 1 << 0;
+    QTest::newRow("1x1:0")  << 1 << 1 << 0  << 2 << 1;
+    QTest::newRow("3x3:-1") << 3 << 3 << -1 << 3 << 3;
+    QTest::newRow("3x3:0")  << 3 << 3 << 0  << 4 << 3;
+    QTest::newRow("3x3:1")  << 3 << 3 << 1  << 4 << 3;
+    QTest::newRow("3x3:2")  << 3 << 3 << 2  << 4 << 3;
+    QTest::newRow("3x3:3")  << 3 << 3 << 3  << 4 << 3;
+    QTest::newRow("3x3:4")  << 3 << 3 << 4  << 3 << 3;
+}
+
+void tst_QTableWidget::insertRow()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, row);
+    QFETCH(int, expectedRowCount);
+    QFETCH(int, expectedColumnCount);
+
+    // set dimensions and test they are ok
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    // insert and compare the results
+    testWidget->insertRow(row);
+    QCOMPARE(testWidget->rowCount(), expectedRowCount);
+    QCOMPARE(testWidget->columnCount(), expectedColumnCount);
+}
+
+void tst_QTableWidget::insertColumn_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("column");
+    QTest::addColumn<int>("expectedRowCount");
+    QTest::addColumn<int>("expectedColumnCount");
+
+    QTest::newRow("Empty")  << 0 << 0 << 0  << 0 << 1;
+    QTest::newRow("1x1:0")  << 1 << 1 << 0  << 1 << 2;
+    QTest::newRow("3x3:-1") << 3 << 3 << -1 << 3 << 3;
+    QTest::newRow("3x3:0")  << 3 << 3 << 0  << 3 << 4;
+    QTest::newRow("3x3:1")  << 3 << 3 << 1  << 3 << 4;
+    QTest::newRow("3x3:2")  << 3 << 3 << 2  << 3 << 4;
+    QTest::newRow("3x3:3")  << 3 << 3 << 3  << 3 << 4;
+    QTest::newRow("3x3:4")  << 3 << 3 << 4  << 3 << 3;
+}
+
+void tst_QTableWidget::insertColumn()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, column);
+    QFETCH(int, expectedRowCount);
+    QFETCH(int, expectedColumnCount);
+
+    // set dimensions and test they are ok
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+    QCOMPARE(testWidget->rowCount(), rowCount);
+    QCOMPARE(testWidget->columnCount(), columnCount);
+
+    // insert and compare the results
+    testWidget->insertColumn(column);
+    QCOMPARE(testWidget->rowCount(), expectedRowCount);
+    QCOMPARE(testWidget->columnCount(), expectedColumnCount);
+}
+
+void tst_QTableWidget::itemStreaming_data()
+{
+    QTest::addColumn<QString>("text");
+    QTest::addColumn<QString>("toolTip");
+
+    QTest::newRow("Data") << "item text" << "tool tip text";
+}
+
+void tst_QTableWidget::itemStreaming()
+{
+    QFETCH(QString, text);
+    QFETCH(QString, toolTip);
+
+    QTableWidgetItem item;
+    QCOMPARE(item.text(), QString());
+    QCOMPARE(item.toolTip(), QString());
+
+    item.setText(text);
+    item.setToolTip(toolTip);
+    QCOMPARE(item.text(), text);
+    QCOMPARE(item.toolTip(), toolTip);
+
+    QByteArray buffer;
+    QDataStream out(&buffer, QIODevice::WriteOnly);
+    out << item;
+
+    QTableWidgetItem item2;
+    QCOMPARE(item2.text(), QString());
+    QCOMPARE(item2.toolTip(), QString());
+
+    QVERIFY(!buffer.isEmpty());
+
+    QDataStream in(&buffer, QIODevice::ReadOnly);
+    in >> item2;
+    QCOMPARE(item2.text(), text);
+    QCOMPARE(item2.toolTip(), toolTip);
+}
+
+void tst_QTableWidget::itemOwnership()
+{
+    QPointer<QObjectTableItem> item;
+    QPointer<QObjectTableItem> headerItem;
+
+    //delete from outside
+    item = new QObjectTableItem();
+    testWidget->setItem(0, 0, item);
+    delete item;
+    QCOMPARE(testWidget->item(0, 0), (QTableWidgetItem *)0);
+
+    //delete vertical headeritem from outside
+    headerItem = new QObjectTableItem();
+    testWidget->setVerticalHeaderItem(0, headerItem);
+    delete headerItem;
+    QCOMPARE(testWidget->verticalHeaderItem(0), (QTableWidgetItem *)0);
+
+    //delete horizontal headeritem from outside
+    headerItem = new QObjectTableItem();
+    testWidget->setHorizontalHeaderItem(0, headerItem);
+    delete headerItem;
+    QCOMPARE(testWidget->horizontalHeaderItem(0), (QTableWidgetItem *)0);
+
+    //setItem
+    item = new QObjectTableItem();
+    testWidget->setItem(0, 0, item);
+    testWidget->setItem(0, 0, new QTableWidgetItem());
+    QVERIFY(item.isNull());
+
+    //setHorizontalHeaderItem
+    headerItem = new QObjectTableItem();
+    testWidget->setHorizontalHeaderItem(0, headerItem);
+    testWidget->setHorizontalHeaderItem(0, new QTableWidgetItem());
+    QVERIFY(headerItem.isNull());
+
+    //setVerticalHeaderItem
+    headerItem = new QObjectTableItem();
+    testWidget->setVerticalHeaderItem(0, headerItem);
+    testWidget->setVerticalHeaderItem(0, new QTableWidgetItem());
+    QVERIFY(headerItem.isNull());
+
+    //takeItem
+    item = new QObjectTableItem();
+    testWidget->setItem(0, 0, item);
+    testWidget->takeItem(0, 0);
+    QVERIFY(!item.isNull());
+    delete item;
+
+    // removeRow
+    item = new QObjectTableItem();
+    headerItem = new QObjectTableItem();
+    testWidget->setItem(0, 0, item);
+    testWidget->setVerticalHeaderItem(0, headerItem);
+    testWidget->removeRow(0);
+    QVERIFY(item.isNull());
+    QVERIFY(headerItem.isNull());
+
+    // removeColumn
+    item = new QObjectTableItem();
+    headerItem = new QObjectTableItem();
+    testWidget->setItem(0, 0, item);
+    testWidget->setHorizontalHeaderItem(0, headerItem);
+    testWidget->removeColumn(0);
+    QVERIFY(item.isNull());
+    QVERIFY(headerItem.isNull());
+
+    // clear
+    item = new QObjectTableItem();
+    testWidget->setItem(0, 0, item);
+    testWidget->clear();
+    QVERIFY(item.isNull());
+}
+
+void tst_QTableWidget::sortItems_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("sortOrder");
+    QTest::addColumn<int>("sortColumn");
+    QTest::addColumn<QStringList>("initial");
+    QTest::addColumn<QStringList>("expected");
+    QTest::addColumn<IntList>("rows");
+    QTest::addColumn<IntList>("initialHidden");
+    QTest::addColumn<IntList>("expectedHidden");
+
+    QTest::newRow("ascending")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "1" << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "1" << "b" << "7" << "3" << "u"
+            << "2" << "c" << "9" << "y" << "8"
+            << "3" << "d" << "k" << "o" << "6")
+        << (IntList() << 0 << 3 << 2 << 1)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("descending")
+        << 4 << 5
+        << static_cast<int>(Qt::DescendingOrder)
+        << 0
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "1" << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "1" << "b" << "7" << "3" << "u"
+            << "0" << "a" << "o" << "8" << "k")
+        << (IntList() << 3 << 0 << 1 << 2)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("empty table")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            <<  0  <<  0  <<  0  <<  0  << 0
+            <<  0  <<  0  <<  0  <<  0  << 0
+            <<  0  <<  0  <<  0  <<  0  << 0
+            <<  0  <<  0  <<  0  <<  0  << 0)
+        << (QStringList()
+            <<  0  <<  0  <<  0  <<  0  << 0
+            <<  0  <<  0  <<  0  <<  0  << 0
+            <<  0  <<  0  <<  0  <<  0  << 0
+            <<  0  <<  0  <<  0  <<  0  << 0)
+        << IntList()
+        << IntList()
+        << IntList();
+
+
+    QTest::newRow("half-empty table")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            <<  "0"  <<   0   <<  0  <<  0  << 0
+            <<  "3"  <<  "d"  <<  0  <<  0  << 0
+            <<  "2"  <<  "c"  <<  0  <<  0  << 0
+            <<   0   <<   0   <<  0  <<  0  << 0)
+        << (QStringList()
+            <<  "0"  <<   0   <<  0  <<  0  << 0
+            <<  "2"  <<  "c"  <<  0  <<  0  << 0
+            <<  "3"  <<  "d"  <<  0  <<  0  << 0
+            <<   0   <<   0   <<  0  <<  0  << 0)
+        << (IntList() << 0 << 2 << 1)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("empty column, should not sort.")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 3
+        << (QStringList()
+            <<  "0"  <<   0   <<  0  <<  0  << 0
+            <<  "3"  <<  "d"  <<  0  <<  0  << 0
+            <<  "2"  <<  "c"  <<  0  <<  0  << 0
+            <<   0   <<   0   <<  0  <<  0  << 0)
+        << (QStringList()
+            <<  "0"  <<   0   <<  0  <<  0  << 0
+            <<  "3"  <<  "d"  <<  0  <<  0  << 0
+            <<  "2"  <<  "c"  <<  0  <<  0  << 0
+            <<   0   <<   0   <<  0  <<  0  << 0)
+        << IntList()
+        << IntList()
+        << IntList();
+
+    QTest::newRow("descending with null cell, the null cell should be placed at the bottom")
+        << 4 << 5
+        << static_cast<int>(Qt::DescendingOrder)
+        << 0
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            <<  0  << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "0" << "a" << "o" << "8" << "k"
+            <<  0  << "b" << "7" << "3" << "u")
+        << (IntList() << 2 << 0 << 1)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("ascending with null cell, the null cell should be placed at the bottom")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            <<  0  << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "2" << "c" << "9" << "y" << "8"
+            << "3" << "d" << "k" << "o" << "6"
+            <<  0  << "b" << "7" << "3" << "u")
+        << (IntList() << 0 << 2 << 1)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("ascending with null cells, the null cells should be placed at the bottom")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            << "3" << "d" << "k" << "o" << "6"
+            << "0" << "a" << "o" << "8" << "k"
+            <<  0  << "c" << "9" << "y" << "8"
+            <<  0  << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            <<  0  << "c" << "9" << "y" << "8"
+            <<  0  << "b" << "7" << "3" << "u")
+        << (IntList() << 1 << 0)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("ascending... Check a bug in PersistentIndexes")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            << "3" << "c" << "9" << "y" << "8"
+            << "2" << "b" << "7" << "3" << "u"
+            << "4" << "d" << "k" << "o" << "6"
+            << "1" << "a" << "o" << "8" << "k"
+            )
+        << (QStringList()
+            << "1" << "a" << "o" << "8" << "k"
+            << "2" << "b" << "7" << "3" << "u"
+            << "3" << "c" << "9" << "y" << "8"
+            << "4" << "d" << "k" << "o" << "6"
+            )
+        << (IntList() << 2 << 1 << 3 << 0)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("ascending with some null cells inbetween")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            <<  0  << "a" << "o" << "8" << "k"
+            << "2" << "c" << "9" << "y" << "8"
+            <<  0  << "d" << "k" << "o" << "6"
+            << "1" << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "1" << "b" << "7" << "3" << "u"
+            << "2" << "c" << "9" << "y" << "8"
+            <<  0  << "a" << "o" << "8" << "k"
+            <<  0  << "d" << "k" << "o" << "6")
+        << (IntList() << 1 << 0)
+        << IntList()
+        << IntList();
+
+    QTest::newRow("ascending hidden")
+        << 4 << 5
+        << static_cast<int>(Qt::AscendingOrder)
+        << 0
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "1" << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "1" << "b" << "7" << "3" << "u"
+            << "2" << "c" << "9" << "y" << "8"
+            << "3" << "d" << "k" << "o" << "6")
+        << (IntList() << 0 << 3 << 2 << 1)
+        << (IntList() << 0 << 2)
+        << (IntList() << 0 << 2);
+
+    QTest::newRow("descending hidden")
+        << 4 << 5
+        << static_cast<int>(Qt::DescendingOrder)
+        << 0
+        << (QStringList()
+            << "0" << "a" << "o" << "8" << "k"
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "1" << "b" << "7" << "3" << "u")
+        << (QStringList()
+            << "3" << "d" << "k" << "o" << "6"
+            << "2" << "c" << "9" << "y" << "8"
+            << "1" << "b" << "7" << "3" << "u"
+            << "0" << "a" << "o" << "8" << "k")
+        << (IntList() << 3 << 0 << 1 << 2)
+        << (IntList() << 0 << 2)
+        << (IntList() << 3 << 1);
+}
+
+void tst_QTableWidget::sortItems()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, sortOrder);
+    QFETCH(int, sortColumn);
+    QFETCH(QStringList, initial);
+    QFETCH(QStringList, expected);
+    QFETCH(IntList, rows);
+    QFETCH(IntList, initialHidden);
+    QFETCH(IntList, expectedHidden);
+
+    testWidget->setRowCount(rowCount);
+    testWidget->setColumnCount(columnCount);
+
+    QAbstractItemModel *model = testWidget->model();
+    QList<QPersistentModelIndex> persistent;
+
+    int ti = 0;
+    for (int r = 0; r < rowCount; ++r) {
+        for (int c = 0; c < columnCount; ++c) {
+        QString str = initial.at(ti++);
+            if (!str.isNull()) {
+                testWidget->setItem(r, c, new QTableWidgetItem(str));
+            }
+        }
+        if (testWidget->item(r, sortColumn))
+            persistent << model->index(r, sortColumn, QModelIndex());
+    }
+
+    for (int h = 0; h < initialHidden.count(); ++h)
+        testWidget->hideRow(initialHidden.at(h));
+
+    QCOMPARE(testWidget->verticalHeader()->hiddenSectionCount(), initialHidden.count());
+
+    testWidget->sortItems(sortColumn, static_cast<Qt::SortOrder>(sortOrder));
+
+    int te = 0;
+    for (int i = 0; i < rows.count(); ++i) {
+        for (int j = 0; j < columnCount; ++j) {
+            QString value;
+            QTableWidgetItem *itm = testWidget->item(i, j);
+            if (itm) {
+                value = itm->text();
+            }
+            QCOMPARE(value, expected.at(te++));
+        }
+        QCOMPARE(persistent.at(i).row(), rows.at(i));
+        //qDebug() << "persistent" << persistent.at(i).row()
+        //         << "expected" << rows.at(i);
+    }
+
+    for (int k = 0; k < expectedHidden.count(); ++k)
+        QVERIFY(testWidget->isRowHidden(expectedHidden.at(k)));
+}
+
+void tst_QTableWidget::setItemWithSorting_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("columnCount");
+    QTest::addColumn<int>("sortOrder");
+    QTest::addColumn<int>("sortColumn");
+    QTest::addColumn<QStringList>("initialValues");
+    QTest::addColumn<int>("row");
+    QTest::addColumn<int>("column");
+    QTest::addColumn<QString>("newValue");
+    QTest::addColumn<QStringList>("expectedValues");
+    QTest::addColumn<IntList>("expectedRows");
+    QTest::addColumn<bool>("reorderingExpected");
+
+    QTest::newRow("2x1 no change (ascending)")
+        << 2 << 1
+        << static_cast<int>(Qt::AscendingOrder) << 0
+        << (QStringList() << "0" << "1")
+        << 1 << 0 << "2"
+        << (QStringList() << "0" << "2")
+        << (IntList() << 0 << 1)
+        << false;
+    QTest::newRow("2x1 no change (descending)")
+        << 2 << 1
+        << static_cast<int>(Qt::DescendingOrder) << 0
+        << (QStringList() << "1" << "0")
+        << 0 << 0 << "2"
+        << (QStringList() << "2" << "0")
+        << (IntList() << 0 << 1)
+        << false;
+    QTest::newRow("2x1 reorder (ascending)")
+        << 2 << 1
+        << static_cast<int>(Qt::AscendingOrder) << 0
+        << (QStringList() << "0" << "1")
+        << 0 << 0 << "2"
+        << (QStringList() << "1" << "2")
+        << (IntList() << 1 << 0)
+        << true;
+    QTest::newRow("2x1 reorder (descending)")
+        << 2 << 1
+        << static_cast<int>(Qt::DescendingOrder) << 0
+        << (QStringList() << "1" << "0")
+        << 1 << 0 << "2"
+        << (QStringList() << "2" << "1")
+        << (IntList() << 1 << 0)
+        << true;
+    QTest::newRow("2x2 no change (ascending)")
+        << 2 << 2
+        << static_cast<int>(Qt::AscendingOrder) << 0
+        << (QStringList()
+            << "0" << "00"
+            << "1" << "11")
+        << 1 << 0 << "2"
+        << (QStringList()
+            << "0" << "00"
+            << "2" << "11")
+        << (IntList() << 0 << 1)
+        << false;
+    QTest::newRow("2x2 reorder (ascending)")
+        << 2 << 2
+        << static_cast<int>(Qt::AscendingOrder) << 0
+        << (QStringList()
+            << "0" << "00"
+            << "1" << "11")
+        << 0 << 0 << "2"
+        << (QStringList()
+            << "1" << "11"
+            << "2" << "00")
+        << (IntList() << 1 << 0)
+        << true;
+    QTest::newRow("2x2 reorder (ascending, sortColumn = 1)")
+        << 2 << 2
+        << static_cast<int>(Qt::AscendingOrder) << 1
+        << (QStringList()
+            << "00" << "0"
+            << "11" << "1")
+        << 0 << 1 << "2"
+        << (QStringList()
+            << "11" << "1"
+            << "00" << "2")
+        << (IntList() << 1 << 0)
+        << true;
+    QTest::newRow("2x2 no change (column != sortColumn)")
+        << 2 << 2
+        << static_cast<int>(Qt::AscendingOrder) << 1
+        << (QStringList()
+            << "00" << "0"
+            << "11" << "1")
+        << 0 << 0 << "22"
+        << (QStringList()
+            << "22" << "0"
+            << "11" << "1")
+        << (IntList() << 0 << 1)
+        << false;
+    QTest::newRow("8x4 reorder (ascending, sortColumn = 3)")
+        << 8 << 4
+        << static_cast<int>(Qt::AscendingOrder) << 3
+        << (QStringList()
+            << "q" << "v" << "u" << "0"
+            << "e" << "j" << "i" << "10"
+            << "h" << "d" << "c" << "12"
+            << "k" << "g" << "f" << "14"
+            << "w" << "y" << "x" << "2"
+            << "t" << "s" << "o" << "4"
+            << "z" << "p" << "r" << "6"
+            << "n" << "m" << "l" << "8")
+        << 2 << 3 << "5"
+        << (QStringList()
+            << "q" << "v" << "u" << "0"
+            << "e" << "j" << "i" << "10"
+            << "k" << "g" << "f" << "14"
+            << "w" << "y" << "x" << "2"
+            << "t" << "s" << "o" << "4"
+            << "h" << "d" << "c" << "5"
+            << "z" << "p" << "r" << "6"
+            << "n" << "m" << "l" << "8")
+        << (IntList() << 0 << 1 << 5 << 2 << 3 << 4 << 6 << 7)
+        << true;
+}
+
+void tst_QTableWidget::setItemWithSorting()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, columnCount);
+    QFETCH(int, sortOrder);
+    QFETCH(int, sortColumn);
+    QFETCH(QStringList, initialValues);
+    QFETCH(int, row);
+    QFETCH(int, column);
+    QFETCH(QString, newValue);
+    QFETCH(QStringList, expectedValues);
+    QFETCH(IntList, expectedRows);
+    QFETCH(bool, reorderingExpected);
+
+    for (int i = 0; i < 2; ++i) {
+        QTableWidget w(rowCount, columnCount);
+
+        QAbstractItemModel *model = w.model();
+        QList<QPersistentModelIndex> persistent;
+        
+        int ti = 0;
+        for (int r = 0; r < rowCount; ++r) {
+            for (int c = 0; c < columnCount; ++c) {
+                QString str = initialValues.at(ti++);
+                w.setItem(r, c, new QTableWidgetItem(str));
+            }
+            persistent << model->index(r, sortColumn);
+        }
+        
+        w.sortItems(sortColumn, static_cast<Qt::SortOrder>(sortOrder));
+        w.setSortingEnabled(true);
+        
+        QSignalSpy dataChangedSpy(model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)));
+        QSignalSpy layoutChangedSpy(model, SIGNAL(layoutChanged()));
+
+        if (i == 0) {
+            // set a new item
+            QTableWidgetItem *item = new QTableWidgetItem(newValue);
+            w.setItem(row, column, item);
+        } else {
+            // change the data of existing item
+            QTableWidgetItem *item = w.item(row, column);
+            item->setText(newValue);
+        }
+
+        ti = 0;
+        for (int r = 0; r < rowCount; ++r) {
+            for (int c = 0; c < columnCount; ++c) {
+                QString str = expectedValues.at(ti++);
+                QCOMPARE(w.item(r, c)->text(), str);
+            }
+        }
+        
+        for (int k = 0; k < persistent.count(); ++k) {
+            QCOMPARE(persistent.at(k).row(), expectedRows.at(k));
+            int i = (persistent.at(k).row() * columnCount) + sortColumn;
+            QCOMPARE(persistent.at(k).data().toString(), expectedValues.at(i));
+        }
+
+        if (i == 0)
+            QCOMPARE(dataChangedSpy.count(), reorderingExpected ? 0 : 1);
+        else
+            QCOMPARE(dataChangedSpy.count(), 1);
+
+        QCOMPARE(layoutChangedSpy.count(), reorderingExpected ? 1 : 0);
+    }
+}
+
+void tst_QTableWidget::itemData()
+{
+    QTableWidget widget(2, 2);
+    widget.setItem(0, 0, new QTableWidgetItem());
+    QTableWidgetItem *item = widget.item(0, 0);
+    QVERIFY(item);
+    item->setFlags(item->flags() | Qt::ItemIsEditable);
+    item->setData(Qt::DisplayRole,  QString("0"));
+    item->setData(Qt::CheckStateRole, Qt::PartiallyChecked);
+    item->setData(Qt::UserRole + 0, QString("1"));
+    item->setData(Qt::UserRole + 1, QString("2"));
+    item->setData(Qt::UserRole + 2, QString("3"));
+    item->setData(Qt::UserRole + 3, QString("4"));
+    QMap<int, QVariant> flags = widget.model()->itemData(widget.model()->index(0, 0));
+    QCOMPARE(flags.count(), 6);
+    QCOMPARE(flags[(Qt::UserRole + 0)].toString(), QString("1"));
+}
+
+void tst_QTableWidget::setItemData()
+{
+    QTableWidget table(10, 10);
+    table.setSortingEnabled(false);
+    QSignalSpy dataChangedSpy(table.model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)));
+
+    QTableWidgetItem *item = new QTableWidgetItem;
+    table.setItem(0, 0, item);
+    QCOMPARE(dataChangedSpy.count(), 1);
+    QModelIndex idx = qvariant_cast<QModelIndex>(dataChangedSpy.takeFirst().at(0));
+
+    QMap<int, QVariant> data;
+    data.insert(Qt::DisplayRole, QLatin1String("Display"));
+    data.insert(Qt::ToolTipRole, QLatin1String("ToolTip"));
+    table.model()->setItemData(idx, data);
+
+    QCOMPARE(table.model()->data(idx, Qt::DisplayRole).toString(), QLatin1String("Display"));
+    QCOMPARE(table.model()->data(idx, Qt::ToolTipRole).toString(), QLatin1String("ToolTip"));
+    QCOMPARE(dataChangedSpy.count(), 1);
+    QCOMPARE(idx, qvariant_cast<QModelIndex>(dataChangedSpy.takeFirst().at(0)));
+
+    table.model()->setItemData(idx, data);
+    QCOMPARE(dataChangedSpy.count(), 0);
+
+    data.clear();
+    data.insert(Qt::DisplayRole, QLatin1String("dizplaye"));
+    table.model()->setItemData(idx, data);
+    QCOMPARE(table.model()->data(idx, Qt::DisplayRole).toString(), QLatin1String("dizplaye"));
+    QCOMPARE(dataChangedSpy.count(), 1);
+}
+
+void tst_QTableWidget::cellWidget()
+{
+    QTableWidget table(10, 10);
+    QWidget widget;
+
+    QCOMPARE(table.cellWidget(5, 5), static_cast<QWidget*>(0));
+    table.setCellWidget(5, 5, &widget);
+    QCOMPARE(table.cellWidget(5, 5), &widget);
+    table.removeCellWidget(5, 5);
+    QCOMPARE(table.cellWidget(5, 5), static_cast<QWidget*>(0));
+}
+
+void tst_QTableWidget::task231094()
+{
+    QTableWidget tw(5, 3);
+    for (int x = 0; x < 3; x++) {
+        for (int y = 0; y < 5; y++) {
+            QTableWidgetItem *twi = new QTableWidgetItem(QLatin1String("1"));
+            if (y == 1)
+                twi->setFlags(Qt::ItemIsEnabled);
+            else
+                twi->setFlags(0);
+            tw.setItem(y, x, twi);
+        }
+    }
+
+    tw.setCurrentCell(1, 1);
+    QCOMPARE(tw.currentRow(), 1);
+    QCOMPARE(tw.currentColumn(), 1);
+	
+    //this would provoke a end-less loop
+    QTest::keyClick(&tw, '1');
+
+    //all the items are disabled: the current item shouldn't have changed
+    QCOMPARE(tw.currentRow(), 1);
+    QCOMPARE(tw.currentColumn(), 1);
+}
+
+void tst_QTableWidget::task219380_removeLastRow()
+{
+    testWidget->setColumnCount(1);
+    testWidget->setRowCount(20);
+    QTableWidgetItem item;
+    testWidget->setItem(18, 0, &item); //we put the item in the the second last row
+    testWidget->openPersistentEditor(&item);
+
+    testWidget->scrollToBottom();
+
+    testWidget->removeRow(19); //we remove the last row
+
+    //we make sure the editor is at the cell position
+    QCOMPARE(testWidget->cellWidget(18, 0)->geometry(), testWidget->visualItemRect(&item));
+}
+
+void tst_QTableWidget::task262056_sortDuplicate()
+{
+    testWidget->setColumnCount(2);
+    testWidget->setRowCount(8);
+    testWidget->setSortingEnabled(true);
+    QStringList items = (QStringList() << "AAA" << "BBB" << "CCC" << "CCC" << "DDD"\
+                         << "EEE" << "FFF" << "GGG");
+    for (int i = 0; i<8; i++ ) {
+        QTableWidgetItem *twi = new QTableWidgetItem(items.at(i));
+        testWidget->setItem(i,0,twi);
+        testWidget->setItem(i,1,new QTableWidgetItem(QString("item %1").arg(i)));
+    }
+    testWidget->sortItems(0, Qt::AscendingOrder);
+    QSignalSpy layoutChangedSpy(testWidget->model(), SIGNAL(layoutChanged()));
+    testWidget->item(3,0)->setBackgroundColor(Qt::red);
+
+    QCOMPARE(layoutChangedSpy.count(),0);
+
+}
+
+
+QTEST_MAIN(tst_QTableWidget)
+#include "tst_qtablewidget.moc"