Long live Qt for S60!

3 files changed, 1199 insertions, 0 deletions

diff --git a/tests/auto/qabstractitemview/.gitignore b/tests/auto/qabstractitemview/.gitignore
new file mode 100644
index 0000000..2f9f90e
--- /dev/null
+++ b/tests/auto/qabstractitemview/.gitignore
@@ -0,0 +1 @@
+tst_qabstractitemview
diff --git a/tests/auto/qabstractitemview/qabstractitemview.pro b/tests/auto/qabstractitemview/qabstractitemview.pro
new file mode 100644
index 0000000..0d0d51c
--- /dev/null
+++ b/tests/auto/qabstractitemview/qabstractitemview.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+SOURCES         += tst_qabstractitemview.cpp
+
+
diff --git a/tests/auto/qabstractitemview/tst_qabstractitemview.cpp b/tests/auto/qabstractitemview/tst_qabstractitemview.cpp
new file mode 100644
index 0000000..2d55ca1
--- /dev/null
+++ b/tests/auto/qabstractitemview/tst_qabstractitemview.cpp
@@ -0,0 +1,1194 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qabstractitemview.h>
+#include <qstandarditemmodel.h>
+#include <qapplication.h>
+#include <qlistview.h>
+#include <qtableview.h>
+#include <qtreeview.h>
+#include <qtreewidget.h>
+#include <qheaderview.h>
+#include <qspinbox.h>
+#include <qitemdelegate.h>
+#include <qpushbutton.h>
+#include "../../shared/util.h"
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+// Will try to wait for the condition while allowing event processing
+// for a maximum of 5 seconds.
+#define TRY_COMPARE(expr, expected) \
+    do { \
+        const int step = 50; \
+        for (int q = 0; q < 5000 && ((expr) != (expected)); q+=step) { \
+            QTest::qWait(step); \
+        } \
+        QCOMPARE(expr, expected); \
+    } while(0)
+
+class TestView : public QAbstractItemView
+{
+    Q_OBJECT
+public:
+    inline void tst_dataChanged(const QModelIndex &tl, const QModelIndex &br)
+        { dataChanged(tl, br); }
+    inline void tst_setHorizontalStepsPerItem(int steps)
+        { setHorizontalStepsPerItem(steps); }
+    inline int tst_horizontalStepsPerItem() const
+        { return horizontalStepsPerItem(); }
+    inline void tst_setVerticalStepsPerItem(int steps)
+        { setVerticalStepsPerItem(steps); }
+    inline int tst_verticalStepsPerItem() const
+        { return verticalStepsPerItem(); }
+
+    inline void tst_rowsInserted(const QModelIndex &parent, int start, int end)
+        { rowsInserted(parent, start, end); }
+    inline void tst_rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
+        { rowsAboutToBeRemoved(parent, start, end); }
+    inline void tst_selectionChanged(const QItemSelection &selected,
+                                     const QItemSelection &deselected)
+        { selectionChanged(selected, deselected); }
+    inline void tst_currentChanged(const QModelIndex &current, const QModelIndex &previous)
+        { currentChanged(current, previous); }
+    inline void tst_updateEditorData()
+        { updateEditorData(); }
+    inline void tst_updateEditorGeometries()
+        { updateEditorGeometries(); }
+    inline void tst_updateGeometries()
+        { updateGeometries(); }
+    inline void tst_verticalScrollbarAction(int action)
+        { verticalScrollbarAction(action); }
+    inline void tst_horizontalScrollbarAction(int action)
+        { horizontalScrollbarAction(action); }
+    inline void tst_verticalScrollbarValueChanged(int value)
+        { verticalScrollbarValueChanged(value); }
+    inline void tst_horizontalScrollbarValueChanged(int value)
+        { horizontalScrollbarValueChanged(value); }
+    inline void tst_closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint)
+        { closeEditor(editor, hint); }
+    inline void tst_commitData(QWidget *editor)
+        { commitData(editor); }
+    inline void tst_editorDestroyed(QObject *editor)
+        { editorDestroyed(editor); }
+    enum tst_CursorAction {
+        MoveUp = QAbstractItemView::MoveUp,
+        MoveDown = QAbstractItemView::MoveDown,
+        MoveLeft = QAbstractItemView::MoveLeft,
+        MoveRight = QAbstractItemView::MoveRight,
+        MoveHome = QAbstractItemView::MoveHome,
+        MoveEnd = QAbstractItemView::MoveEnd,
+        MovePageUp = QAbstractItemView::MovePageUp,
+        MovePageDown = QAbstractItemView::MovePageDown,
+        MoveNext = QAbstractItemView::MoveNext,
+        MovePrevious = QAbstractItemView::MovePrevious
+    };
+    inline QModelIndex tst_moveCursor(tst_CursorAction cursorAction,
+                                      Qt::KeyboardModifiers modifiers)
+        { return moveCursor(QAbstractItemView::CursorAction(cursorAction), modifiers); }
+    inline int tst_horizontalOffset() const
+        { return horizontalOffset(); }
+    inline int tst_verticalOffset() const
+        { return verticalOffset(); }
+    inline bool tst_isIndexHidden(const QModelIndex &index) const
+        { return isIndexHidden(index); }
+    inline void tst_setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
+        { setSelection(rect, command); }
+    inline QRegion tst_visualRegionForSelection(const QItemSelection &selection) const
+        { return visualRegionForSelection(selection); }
+    inline QModelIndexList tst_selectedIndexes() const
+        { return selectedIndexes(); }
+    inline bool tst_edit(const QModelIndex &index, EditTrigger trigger, QEvent *event)
+        { return edit(index, trigger, event); }
+    inline QItemSelectionModel::SelectionFlags tst_selectionCommand(const QModelIndex &index,
+                                                                    const QEvent *event = 0) const
+        { return selectionCommand(index, event); }
+#ifndef QT_NO_DRAGANDDROP
+    inline void tst_startDrag(Qt::DropActions supportedActions)
+        { startDrag(supportedActions); }
+#endif
+    inline QStyleOptionViewItem tst_viewOptions() const
+        { return viewOptions(); }
+    enum tst_State {
+        NoState = QAbstractItemView::NoState,
+        DraggingState = QAbstractItemView::DraggingState,
+        DragSelectingState = QAbstractItemView::DragSelectingState,
+        EditingState = QAbstractItemView::EditingState,
+        ExpandingState = QAbstractItemView::ExpandingState,
+        CollapsingState = QAbstractItemView::CollapsingState
+    };
+    inline tst_State tst_state() const
+        { return (tst_State)state(); }
+    inline void tst_setState(tst_State state)
+        { setState(QAbstractItemView::State(state)); }
+    inline void tst_startAutoScroll()
+        { startAutoScroll(); }
+    inline void tst_stopAutoScroll()
+        { stopAutoScroll(); }
+    inline void tst_doAutoScroll()
+        { doAutoScroll(); }
+};
+
+class tst_QAbstractItemView : public QObject
+{
+    Q_OBJECT
+
+public:
+
+    tst_QAbstractItemView();
+    virtual ~tst_QAbstractItemView();
+    void basic_tests(TestView *view);
+
+private slots:
+    void getSetCheck();
+    void emptyModels_data();
+    void emptyModels();
+    void setModel_data();
+    void setModel();
+    void noModel();
+    void dragSelect();
+    void rowDelegate();
+    void columnDelegate();
+    void selectAll();
+    void ctrlA();
+    void persistentEditorFocus();
+    void setItemDelegate();
+    void setItemDelegate_data();
+	// The dragAndDrop() test doesn't work, and is thus disabled on Mac and Windows
+	// for the following reasons:
+	//   Mac: use of GetCurrentEventButtonState() in QDragManager::drag()
+	//   Win: unknown reason
+#if !defined(Q_OS_MAC) && !defined(Q_OS_WIN)
+#if 0
+    void dragAndDrop();
+    void dragAndDropOnChild();
+#endif
+#endif
+    void noFallbackToRoot();
+    void setCurrentIndex_data();
+    void setCurrentIndex();
+    
+    void task221955_selectedEditor();
+};
+
+class MyAbstractItemDelegate : public QAbstractItemDelegate
+{
+public:
+    MyAbstractItemDelegate() : QAbstractItemDelegate() {};
+    void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const {}
+    QSize sizeHint(const QStyleOptionViewItem &, const QModelIndex &) const { return QSize(); }
+    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &,
+                          const QModelIndex &) const { return new QWidget(parent); }
+};
+
+// Testing get/set functions
+void tst_QAbstractItemView::getSetCheck()
+{
+    QListView view;
+    TestView *obj1 = reinterpret_cast<TestView*>(&view);
+    // QAbstractItemDelegate * QAbstractItemView::itemDelegate()
+    // void QAbstractItemView::setItemDelegate(QAbstractItemDelegate *)
+    MyAbstractItemDelegate *var1 = new MyAbstractItemDelegate;
+    obj1->setItemDelegate(var1);
+    QCOMPARE((QAbstractItemDelegate*)var1, obj1->itemDelegate());
+#if QT_VERSION >= 0x040200
+    // Itemviews in Qt < 4.2 have asserts for this. Qt >= 4.2 should handle this gracefully
+    obj1->setItemDelegate((QAbstractItemDelegate *)0);
+    QCOMPARE((QAbstractItemDelegate *)0, obj1->itemDelegate());
+#endif
+    delete var1;
+
+    // EditTriggers QAbstractItemView::editTriggers()
+    // void QAbstractItemView::setEditTriggers(EditTriggers)
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers), obj1->editTriggers());
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged), obj1->editTriggers());
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked), obj1->editTriggers());
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked), obj1->editTriggers());
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed), obj1->editTriggers());
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::AnyKeyPressed));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::AnyKeyPressed), obj1->editTriggers());
+    obj1->setEditTriggers(QAbstractItemView::EditTriggers(QAbstractItemView::AllEditTriggers));
+    QCOMPARE(QAbstractItemView::EditTriggers(QAbstractItemView::AllEditTriggers), obj1->editTriggers());
+
+    // bool QAbstractItemView::tabKeyNavigation()
+    // void QAbstractItemView::setTabKeyNavigation(bool)
+    obj1->setTabKeyNavigation(false);
+    QCOMPARE(false, obj1->tabKeyNavigation());
+    obj1->setTabKeyNavigation(true);
+    QCOMPARE(true, obj1->tabKeyNavigation());
+
+    // bool QAbstractItemView::dragEnabled()
+    // void QAbstractItemView::setDragEnabled(bool)
+#ifndef QT_NO_DRAGANDDROP
+    obj1->setDragEnabled(false);
+    QCOMPARE(false, obj1->dragEnabled());
+    obj1->setDragEnabled(true);
+    QCOMPARE(true, obj1->dragEnabled());
+#endif
+    // bool QAbstractItemView::alternatingRowColors()
+    // void QAbstractItemView::setAlternatingRowColors(bool)
+    obj1->setAlternatingRowColors(false);
+    QCOMPARE(false, obj1->alternatingRowColors());
+    obj1->setAlternatingRowColors(true);
+    QCOMPARE(true, obj1->alternatingRowColors());
+
+#if QT_VERSION < 0x040200
+    // int QAbstractItemView::horizontalStepsPerItem()
+    // void QAbstractItemView::setHorizontalStepsPerItem(int)
+    obj1->tst_setHorizontalStepsPerItem(0);
+    QCOMPARE(0, obj1->tst_horizontalStepsPerItem());
+    obj1->tst_setHorizontalStepsPerItem(INT_MIN);
+    QCOMPARE(INT_MIN, obj1->tst_horizontalStepsPerItem());
+    obj1->tst_setHorizontalStepsPerItem(INT_MAX);
+    QCOMPARE(INT_MAX, obj1->tst_horizontalStepsPerItem());
+
+    // int QAbstractItemView::verticalStepsPerItem()
+    // void QAbstractItemView::setVerticalStepsPerItem(int)
+    obj1->tst_setVerticalStepsPerItem(0);
+    QCOMPARE(0, obj1->tst_verticalStepsPerItem());
+    obj1->tst_setVerticalStepsPerItem(INT_MIN);
+    QCOMPARE(INT_MIN, obj1->tst_verticalStepsPerItem());
+    obj1->tst_setVerticalStepsPerItem(INT_MAX);
+    QCOMPARE(INT_MAX, obj1->tst_verticalStepsPerItem());
+#endif
+
+    // State QAbstractItemView::state()
+    // void QAbstractItemView::setState(State)
+    obj1->tst_setState(TestView::tst_State(TestView::NoState));
+    QCOMPARE(TestView::tst_State(TestView::NoState), obj1->tst_state());
+    obj1->tst_setState(TestView::tst_State(TestView::DraggingState));
+    QCOMPARE(TestView::tst_State(TestView::DraggingState), obj1->tst_state());
+    obj1->tst_setState(TestView::tst_State(TestView::DragSelectingState));
+    QCOMPARE(TestView::tst_State(TestView::DragSelectingState), obj1->tst_state());
+    obj1->tst_setState(TestView::tst_State(TestView::EditingState));
+    QCOMPARE(TestView::tst_State(TestView::EditingState), obj1->tst_state());
+    obj1->tst_setState(TestView::tst_State(TestView::ExpandingState));
+    QCOMPARE(TestView::tst_State(TestView::ExpandingState), obj1->tst_state());
+    obj1->tst_setState(TestView::tst_State(TestView::CollapsingState));
+    QCOMPARE(TestView::tst_State(TestView::CollapsingState), obj1->tst_state());
+
+#if QT_VERSION >= 0x040200
+    // QWidget QAbstractScrollArea::viewport()
+    // void setViewport(QWidget*)
+    QWidget *vp = new QWidget;
+    obj1->setViewport(vp);
+    QCOMPARE(vp, obj1->viewport());
+#endif
+
+    QCOMPARE(16, obj1->autoScrollMargin());
+    obj1->setAutoScrollMargin(20);
+    QCOMPARE(20, obj1->autoScrollMargin());
+    obj1->setAutoScrollMargin(16);
+    QCOMPARE(16, obj1->autoScrollMargin());
+}
+
+tst_QAbstractItemView::tst_QAbstractItemView()
+{
+}
+
+tst_QAbstractItemView::~tst_QAbstractItemView()
+{
+}
+
+void tst_QAbstractItemView::emptyModels_data()
+{
+    QTest::addColumn<QString>("viewType");
+
+    QTest::newRow("QListView") << "QListView";
+    QTest::newRow("QTableView") << "QTableView";
+    QTest::newRow("QTreeView") << "QTreeView";
+    QTest::newRow("QHeaderView") << "QHeaderView";
+}
+
+void tst_QAbstractItemView::emptyModels()
+{
+    QFETCH(QString, viewType);
+
+    TestView *view = 0;
+    if (viewType == "QListView")
+        view = reinterpret_cast<TestView*>(new QListView());
+    else if (viewType == "QTableView")
+        view = reinterpret_cast<TestView*>(new QTableView());
+    else if (viewType == "QTreeView")
+        view = reinterpret_cast<TestView*>(new QTreeView());
+    else if (viewType == "QHeaderView")
+        view = reinterpret_cast<TestView*>(new QHeaderView(Qt::Vertical));
+    else
+        QVERIFY(0);
+    view->show();
+
+    QVERIFY(!view->model());
+    QVERIFY(!view->selectionModel());
+    //QVERIFY(view->itemDelegate() != 0);
+
+    basic_tests(view);
+    delete view;
+}
+
+void tst_QAbstractItemView::setModel_data()
+{
+    QTest::addColumn<QString>("viewType");
+
+    QTest::newRow("QListView") << "QListView";
+    QTest::newRow("QTableView") << "QTableView";
+    QTest::newRow("QTreeView") << "QTreeView";
+    QTest::newRow("QHeaderView") << "QHeaderView";
+}
+
+void tst_QAbstractItemView::setModel()
+{
+    QFETCH(QString, viewType);
+    TestView *view = 0;
+    if (viewType == "QListView")
+        view = reinterpret_cast<TestView*>(new QListView());
+    else if (viewType == "QTableView")
+        view = reinterpret_cast<TestView*>(new QTableView());
+    else if (viewType == "QTreeView")
+        view = reinterpret_cast<TestView*>(new QTreeView());
+    else if (viewType == "QHeaderView")
+        view = reinterpret_cast<TestView*>(new QHeaderView(Qt::Vertical));
+    else
+        QVERIFY(0);
+    view->show();
+
+    QStandardItemModel model(20,20);
+    view->setModel(0);
+    view->setModel(&model);
+    basic_tests(view);
+    delete view;
+}
+
+void tst_QAbstractItemView::basic_tests(TestView *view)
+{
+    // setSelectionModel
+    // Will assert as it should
+    //view->setSelectionModel(0);
+    // setItemDelegate
+    //view->setItemDelegate(0);
+    // Will asswert as it should
+
+    // setSelectionMode
+    view->setSelectionMode(QAbstractItemView::SingleSelection);
+    QCOMPARE(view->selectionMode(), QAbstractItemView::SingleSelection);
+    view->setSelectionMode(QAbstractItemView::ContiguousSelection);
+    QCOMPARE(view->selectionMode(), QAbstractItemView::ContiguousSelection);
+    view->setSelectionMode(QAbstractItemView::ExtendedSelection);
+    QCOMPARE(view->selectionMode(), QAbstractItemView::ExtendedSelection);
+    view->setSelectionMode(QAbstractItemView::MultiSelection);
+    QCOMPARE(view->selectionMode(), QAbstractItemView::MultiSelection);
+    view->setSelectionMode(QAbstractItemView::NoSelection);
+    QCOMPARE(view->selectionMode(), QAbstractItemView::NoSelection);
+
+    // setSelectionBehavior
+    view->setSelectionBehavior(QAbstractItemView::SelectItems);
+    QCOMPARE(view->selectionBehavior(), QAbstractItemView::SelectItems);
+    view->setSelectionBehavior(QAbstractItemView::SelectRows);
+    QCOMPARE(view->selectionBehavior(), QAbstractItemView::SelectRows);
+    view->setSelectionBehavior(QAbstractItemView::SelectColumns);
+    QCOMPARE(view->selectionBehavior(), QAbstractItemView::SelectColumns);
+
+    // setEditTriggers
+    view->setEditTriggers(QAbstractItemView::EditKeyPressed);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::EditKeyPressed);
+    view->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::NoEditTriggers);
+    view->setEditTriggers(QAbstractItemView::CurrentChanged);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::CurrentChanged);
+    view->setEditTriggers(QAbstractItemView::DoubleClicked);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::DoubleClicked);
+    view->setEditTriggers(QAbstractItemView::SelectedClicked);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::SelectedClicked);
+    view->setEditTriggers(QAbstractItemView::AnyKeyPressed);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::AnyKeyPressed);
+    view->setEditTriggers(QAbstractItemView::AllEditTriggers);
+    QCOMPARE(view->editTriggers(), QAbstractItemView::AllEditTriggers);
+
+    // setAutoScroll
+    view->setAutoScroll(false);
+    QCOMPARE(view->hasAutoScroll(), false);
+    view->setAutoScroll(true);
+    QCOMPARE(view->hasAutoScroll(), true);
+
+    // setTabKeyNavigation
+    view->setTabKeyNavigation(false);
+    QCOMPARE(view->tabKeyNavigation(), false);
+    view->setTabKeyNavigation(true);
+    QCOMPARE(view->tabKeyNavigation(), true);
+
+#ifndef QT_NO_DRAGANDDROP
+    // setDropIndicatorShown
+    view->setDropIndicatorShown(false);
+    QCOMPARE(view->showDropIndicator(), false);
+    view->setDropIndicatorShown(true);
+    QCOMPARE(view->showDropIndicator(), true);
+
+    // setDragEnabled
+    view->setDragEnabled(false);
+    QCOMPARE(view->dragEnabled(), false);
+    view->setDragEnabled(true);
+    QCOMPARE(view->dragEnabled(), true);
+#endif
+    
+    // setAlternatingRowColors
+    view->setAlternatingRowColors(false);
+    QCOMPARE(view->alternatingRowColors(), false);
+    view->setAlternatingRowColors(true);
+    QCOMPARE(view->alternatingRowColors(), true);
+
+    // setIconSize
+    view->setIconSize(QSize(16, 16));
+    QCOMPARE(view->iconSize(), QSize(16, 16));
+    view->setIconSize(QSize(32, 32));
+    QCOMPARE(view->iconSize(), QSize(32, 32));
+    // Should this happen?
+    view->setIconSize(QSize(-1, -1));
+    QCOMPARE(view->iconSize(), QSize(-1, -1));
+
+    QCOMPARE(view->currentIndex(), QModelIndex());
+    QCOMPARE(view->rootIndex(), QModelIndex());
+
+    view->keyboardSearch("");
+    view->keyboardSearch("foo");
+    view->keyboardSearch("1");
+
+    QCOMPARE(view->visualRect(QModelIndex()), QRect());
+
+    view->scrollTo(QModelIndex());
+
+    QCOMPARE(view->sizeHintForIndex(QModelIndex()), QSize());
+    QCOMPARE(view->indexAt(QPoint(-1, -1)), QModelIndex());
+
+    if (!view->model()){
+        QCOMPARE(view->indexAt(QPoint(10, 10)), QModelIndex());
+        QCOMPARE(view->sizeHintForRow(0), -1);
+        QCOMPARE(view->sizeHintForColumn(0), -1);
+    }else if (view->itemDelegate()){
+        view->sizeHintForRow(0);
+        view->sizeHintForColumn(0);
+    }
+    view->openPersistentEditor(QModelIndex());
+    view->closePersistentEditor(QModelIndex());
+
+    view->reset();
+    view->setRootIndex(QModelIndex());
+    view->doItemsLayout();
+    view->selectAll();
+    view->edit(QModelIndex());
+    view->clearSelection();
+    view->setCurrentIndex(QModelIndex());
+
+    // protected methods
+    view->tst_dataChanged(QModelIndex(), QModelIndex());
+    view->tst_rowsInserted(QModelIndex(), -1, -1);
+    view->tst_rowsAboutToBeRemoved(QModelIndex(), -1, -1);
+    view->tst_selectionChanged(QItemSelection(), QItemSelection());
+    if (view->model()){
+        view->tst_currentChanged(QModelIndex(), QModelIndex());
+        view->tst_currentChanged(QModelIndex(), view->model()->index(0,0));
+    }
+    view->tst_updateEditorData();
+    view->tst_updateEditorGeometries();
+    view->tst_updateGeometries();
+    view->tst_verticalScrollbarAction(QAbstractSlider::SliderSingleStepAdd);
+    view->tst_horizontalScrollbarAction(QAbstractSlider::SliderSingleStepAdd);
+    view->tst_verticalScrollbarValueChanged(10);
+    view->tst_horizontalScrollbarValueChanged(10);
+    view->tst_closeEditor(0, QAbstractItemDelegate::NoHint);
+    view->tst_commitData(0);
+    view->tst_editorDestroyed(0);
+
+    view->tst_setHorizontalStepsPerItem(2);
+    view->tst_horizontalStepsPerItem();
+    view->tst_setVerticalStepsPerItem(2);
+    view->tst_verticalStepsPerItem();
+
+    // Will assert as it should
+    // view->setIndexWidget(QModelIndex(), 0);
+
+    view->tst_moveCursor(TestView::MoveUp, Qt::NoModifier);
+    view->tst_horizontalOffset();
+    view->tst_verticalOffset();
+
+//    view->tst_isIndexHidden(QModelIndex()); // will (correctly) assert
+    if(view->model())
+        view->tst_isIndexHidden(view->model()->index(0,0));
+
+    view->tst_setSelection(QRect(0, 0, 10, 10), QItemSelectionModel::ClearAndSelect);
+    view->tst_setSelection(QRect(-1, -1, -1, -1), QItemSelectionModel::ClearAndSelect);
+    view->tst_visualRegionForSelection(QItemSelection());
+    view->tst_selectedIndexes();
+
+    view->tst_edit(QModelIndex(), QAbstractItemView::NoEditTriggers, 0);
+
+    view->tst_selectionCommand(QModelIndex(), 0);
+
+#ifndef QT_NO_DRAGANDDROP
+    if (!view->model())
+        view->tst_startDrag(Qt::CopyAction);
+
+    view->tst_viewOptions();
+
+    view->tst_setState(TestView::NoState);
+    QVERIFY(view->tst_state()==TestView::NoState);
+    view->tst_setState(TestView::DraggingState);
+    QVERIFY(view->tst_state()==TestView::DraggingState);
+    view->tst_setState(TestView::DragSelectingState);
+    QVERIFY(view->tst_state()==TestView::DragSelectingState);
+    view->tst_setState(TestView::EditingState);
+    QVERIFY(view->tst_state()==TestView::EditingState);
+    view->tst_setState(TestView::ExpandingState);
+    QVERIFY(view->tst_state()==TestView::ExpandingState);
+    view->tst_setState(TestView::CollapsingState);
+    QVERIFY(view->tst_state()==TestView::CollapsingState);
+#endif
+    
+    view->tst_startAutoScroll();
+    view->tst_stopAutoScroll();
+    view->tst_doAutoScroll();
+
+    // testing mouseFoo and key functions
+//     QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0,0));
+//     mouseMove(view, Qt::LeftButton, Qt::NoModifier, QPoint(10,10));
+//     QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(10,10));
+//     QTest::mouseClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(10,10));
+//     mouseDClick(view, Qt::LeftButton, Qt::NoModifier, QPoint(10,10));
+//     QTest::keyClick(view, Qt::Key_A);
+}
+
+void tst_QAbstractItemView::noModel()
+{
+    // From task #85415
+
+    QStandardItemModel model(20,20);
+    QTreeView view;
+
+    view.setModel(&model);
+    // Make the viewport smaller than the contents, so that we can scroll
+    view.resize(100,100);
+    view.show();
+
+    // make sure that the scrollbars are not at value 0
+    view.scrollTo(view.model()->index(10,10));
+    QApplication::processEvents();
+
+    view.setModel(0);
+    // Due to the model is removed, this will generate a valueChanged signal on both scrollbars. (value to 0)
+    QApplication::processEvents();
+    QCOMPARE(view.model(), (QAbstractItemModel*)0);
+}
+
+void tst_QAbstractItemView::dragSelect()
+{
+    // From task #86108
+
+    QStandardItemModel model(64,64);
+
+    QTableView view;
+    view.setModel(&model);
+    view.setVisible(true);
+
+    const int delay = 2;
+    for (int i = 0; i < 2; ++i) {
+        bool tracking = (i == 1);
+        view.setMouseTracking(false);
+        QTest::mouseMove(&view, QPoint(0, 0), delay);
+        view.setMouseTracking(tracking);
+        QTest::mouseMove(&view, QPoint(50, 50), delay);
+        QVERIFY(view.selectionModel()->selectedIndexes().isEmpty());
+    }
+}
+
+void tst_QAbstractItemView::rowDelegate()
+{
+    QStandardItemModel model(4,4);
+    MyAbstractItemDelegate delegate;
+
+    QTableView view;
+    view.setModel(&model);
+    view.setItemDelegateForRow(3, &delegate);
+    view.show();
+
+    QModelIndex index = model.index(3, 0);
+    view.openPersistentEditor(index);
+    QWidget *w = view.indexWidget(index);
+    QVERIFY(w);
+    QCOMPARE(w->metaObject()->className(), "QWidget");
+}
+
+void tst_QAbstractItemView::columnDelegate()
+{
+    QStandardItemModel model(4,4);
+    MyAbstractItemDelegate delegate;
+
+    QTableView view;
+    view.setModel(&model);
+    view.setItemDelegateForColumn(3, &delegate);
+    view.show();
+
+    QModelIndex index = model.index(0, 3);
+    view.openPersistentEditor(index);
+    QWidget *w = view.indexWidget(index);
+    QVERIFY(w);
+    QCOMPARE(w->metaObject()->className(), "QWidget");
+}
+
+void tst_QAbstractItemView::selectAll()
+{
+    QStandardItemModel model(4,4);
+    QTableView view;
+    view.setModel(&model);
+
+    TestView *tst_view = (TestView*)&view;
+
+    QCOMPARE(tst_view->tst_selectedIndexes().count(), 0);
+    view.selectAll();
+    QCOMPARE(tst_view->tst_selectedIndexes().count(), 4*4);
+}
+
+void tst_QAbstractItemView::ctrlA()
+{
+    QStandardItemModel model(4,4);
+    QTableView view;
+    view.setModel(&model);
+
+    TestView *tst_view = (TestView*)&view;
+
+    QCOMPARE(tst_view->tst_selectedIndexes().count(), 0);
+    QTest::keyClick(&view, Qt::Key_A, Qt::ControlModifier);
+    QCOMPARE(tst_view->tst_selectedIndexes().count(), 4*4);
+}
+
+void tst_QAbstractItemView::persistentEditorFocus()
+{
+    // one row, three columns
+    QStandardItemModel model(1, 3);
+    for(int i = 0; i < model.columnCount(); ++i)
+        model.setData(model.index(0, i), i);
+    QTableView view;
+    view.setModel(&model);
+
+    view.openPersistentEditor(model.index(0, 1));
+    view.openPersistentEditor(model.index(0, 2));
+
+    //these are spinboxes because we put numbers inside
+    QList<QSpinBox*> list = qFindChildren<QSpinBox*>(view.viewport());
+    QCOMPARE(list.count(), 2); //these should be the 2 editors
+
+    view.setCurrentIndex(model.index(0, 0));
+    QCOMPARE(view.currentIndex(), model.index(0, 0));
+    view.show();
+    QTRY_VERIFY(view.isVisible());
+
+    for (int i = 0; i < list.count(); ++i) {
+        TRY_COMPARE(list.at(i)->isVisible(), true);
+        QPoint p = QPoint(5, 5);
+        QMouseEvent mouseEvent(QEvent::MouseButtonPress, p, Qt::LeftButton,
+                               Qt::LeftButton, Qt::NoModifier);
+        qApp->sendEvent(list.at(i), &mouseEvent);
+        if (!qApp->focusWidget())
+            QSKIP("Some window managers don't handle focus that well", SkipAll);
+        QTRY_COMPARE(qApp->focusWidget(), static_cast<QWidget *>(list.at(i)));
+    }
+}
+
+
+#if !defined(Q_OS_MAC) && !defined(Q_OS_WIN)
+
+#if 0
+
+static void sendMouseMove(QWidget *widget, QPoint pos = QPoint())
+{
+    if (pos.isNull())
+        pos = widget->rect().center();
+    QMouseEvent event(QEvent::MouseMove, pos, widget->mapToGlobal(pos), Qt::NoButton, 0, 0);
+    QCursor::setPos(widget->mapToGlobal(pos));
+    qApp->processEvents();
+#if defined(Q_WS_X11)
+    qt_x11_wait_for_window_manager(widget);
+#endif
+    QApplication::sendEvent(widget, &event);
+}
+
+static void sendMousePress(
+    QWidget *widget, QPoint pos = QPoint(), Qt::MouseButton button = Qt::LeftButton)
+{
+    if (pos.isNull())
+         pos = widget->rect().center();
+    QMouseEvent event(QEvent::MouseButtonPress, pos, widget->mapToGlobal(pos), button, 0, 0);
+    QApplication::sendEvent(widget, &event);
+}
+
+static void sendMouseRelease(
+    QWidget *widget, QPoint pos = QPoint(), Qt::MouseButton button = Qt::LeftButton)
+{
+    if (pos.isNull())
+         pos = widget->rect().center();
+    QMouseEvent event(QEvent::MouseButtonRelease, pos, widget->mapToGlobal(pos), button, 0, 0);
+    QApplication::sendEvent(widget, &event);
+}
+
+class DnDTestModel : public QStandardItemModel
+{
+    Q_OBJECT
+    bool dropMimeData(const QMimeData *md, Qt::DropAction action, int r, int c, const QModelIndex &p)
+    {
+        dropAction_result = action;
+        QStandardItemModel::dropMimeData(md, action, r, c, p);
+        return true;
+    }
+    Qt::DropActions supportedDropActions() const { return Qt::CopyAction | Qt::MoveAction; }
+
+    Qt::DropAction dropAction_result;
+public:
+    DnDTestModel() : QStandardItemModel(20, 20), dropAction_result(Qt::IgnoreAction) {
+        for (int i = 0; i < rowCount(); ++i)
+            setData(index(i, 0), QString("%1").arg(i));
+    }
+    Qt::DropAction dropAction() const { return dropAction_result; }
+};
+
+class DnDTestView : public QTreeView
+{
+    Q_OBJECT
+
+    QPoint dropPoint;
+    Qt::DropAction dropAction;
+
+    void dragEnterEvent(QDragEnterEvent *event)
+    {
+        QAbstractItemView::dragEnterEvent(event);
+    }
+
+    void dropEvent(QDropEvent *event)
+    {
+        event->setDropAction(dropAction);
+        QTreeView::dropEvent(event);
+    }
+
+    void timerEvent(QTimerEvent *event)
+    {
+        killTimer(event->timerId());
+        sendMouseMove(this, dropPoint);
+        sendMouseRelease(this);
+    }
+
+    void mousePressEvent(QMouseEvent *e)
+    {
+        QTreeView::mousePressEvent(e);
+
+        startTimer(0);
+        setState(DraggingState);
+        startDrag(dropAction);
+    }
+
+public:
+    DnDTestView(Qt::DropAction dropAction, QAbstractItemModel *model)
+        : dropAction(dropAction)
+    {
+        header()->hide();
+        setModel(model);
+        setDragDropMode(QAbstractItemView::DragDrop);
+        setAcceptDrops(true);
+        setDragEnabled(true);
+    }
+
+    void dragAndDrop(QPoint drag, QPoint drop)
+    {
+        dropPoint = drop;
+        setCurrentIndex(indexAt(drag));
+        sendMousePress(viewport(), drag);
+    }
+};
+
+class DnDTestWidget : public QWidget
+{
+    Q_OBJECT
+
+    Qt::DropAction dropAction_request;
+    Qt::DropAction dropAction_result;
+    QWidget *dropTarget;
+
+    void timerEvent(QTimerEvent *event)
+    {
+        killTimer(event->timerId());
+        sendMouseMove(dropTarget);
+        sendMouseRelease(dropTarget);
+    }
+
+    void mousePressEvent(QMouseEvent *)
+    {
+        QDrag *drag = new QDrag(this);
+        QMimeData *mimeData = new QMimeData;
+        mimeData->setData("application/x-qabstractitemmodeldatalist", QByteArray(""));
+        drag->setMimeData(mimeData);
+        startTimer(0);
+        dropAction_result = drag->start(dropAction_request);
+    }
+
+public:
+    Qt::DropAction dropAction() const { return dropAction_result; }
+
+    void dragAndDrop(QWidget *dropTarget, Qt::DropAction dropAction)
+    {
+        this->dropTarget = dropTarget;
+        dropAction_request = dropAction;
+        sendMousePress(this);
+    }
+};
+
+void tst_QAbstractItemView::dragAndDrop()
+{
+    // From Task 137729
+
+#ifdef Q_WS_QWS
+    QSKIP("Embedded drag-and-drop not good enough yet...", SkipAll);
+#endif
+
+    const int attempts = 10;
+    int successes = 0;
+    for (int i = 0; i < attempts; ++i) {
+        Qt::DropAction dropAction = Qt::MoveAction;
+
+        DnDTestModel model;
+        DnDTestView view(dropAction, &model);
+        DnDTestWidget widget;
+
+        const int size = 200;
+        widget.setFixedSize(size, size);
+        view.setFixedSize(size, size);
+
+        widget.move(0, 0);
+        view.move(int(size * 1.5), int(size * 1.5));
+
+        widget.show();
+        view.show();
+#if defined(Q_WS_X11)
+        qt_x11_wait_for_window_manager(&widget);
+        qt_x11_wait_for_window_manager(&view);
+#endif
+
+        widget.dragAndDrop(&view, dropAction);
+        if (model.dropAction() == dropAction
+            && widget.dropAction() == dropAction)
+            ++successes;
+    }
+
+    if (successes < attempts) {
+        QString msg = QString("# successes (%1) < # attempts (%2)").arg(successes).arg(attempts);
+        QWARN(msg.toLatin1());
+    }
+    QVERIFY(successes > 0); // allow for some "event unstability" (i.e. unless
+                            // successes == 0, QAbstractItemView is probably ok!)
+}
+
+void tst_QAbstractItemView::dragAndDropOnChild()
+{
+#ifdef Q_WS_QWS
+    QSKIP("Embedded drag-and-drop not good enough yet...", SkipAll);
+#endif
+
+    const int attempts = 10;
+    int successes = 0;
+    for (int i = 0; i < attempts; ++i) {
+        Qt::DropAction dropAction = Qt::MoveAction;
+
+        DnDTestModel model;
+        QModelIndex parent = model.index(0, 0);
+        model.insertRow(0, parent);
+        model.insertColumn(0, parent);
+        QModelIndex child = model.index(0, 0, parent);
+        model.setData(child, "child");
+        QCOMPARE(model.rowCount(parent), 1);
+        DnDTestView view(dropAction, &model);
+        view.setExpanded(parent, true);
+        view.setDragDropMode(QAbstractItemView::InternalMove);
+
+        const int size = 200;
+        view.setFixedSize(size, size);
+        view.move(int(size * 1.5), int(size * 1.5));
+        view.show();
+#if defined(Q_WS_X11)
+        qt_x11_wait_for_window_manager(&view);
+#endif
+
+        view.dragAndDrop(view.visualRect(parent).center(),
+                         view.visualRect(child).center());
+        if (model.dropAction() == dropAction)
+            ++successes;
+    }
+
+    QVERIFY(successes == 0);
+}
+
+#endif // 0
+#endif // !Q_OS_MAC && !Q_OS_WIN
+
+class TestModel : public QStandardItemModel
+{
+public:
+    TestModel(int rows, int columns) : QStandardItemModel(rows, columns) 
+    {
+        setData_count = 0;
+    }
+
+    virtual bool setData(const QModelIndex &/*index*/, const QVariant &/*value*/, int /*role = Qt::EditRole*/) 
+    {
+        ++setData_count;
+        return true;
+    }
+
+    int setData_count;
+};
+
+typedef QList<int> IntList;
+Q_DECLARE_METATYPE(IntList)
+
+void tst_QAbstractItemView::setItemDelegate_data()
+{
+    // default is rows, a -1 will switch to columns
+    QTest::addColumn<IntList>("rowsOrColumnsWithDelegate");
+    QTest::addColumn<QPoint>("cellToEdit");
+    QTest::newRow("4 columndelegates") 
+                << (IntList() << -1 << 0 << 1 << 2 << 3) 
+                << QPoint(0, 0);
+    QTest::newRow("2 identical rowdelegates on the same row") 
+                << (IntList() << 0 << 0) 
+                << QPoint(0, 0);
+    QTest::newRow("2 identical columndelegates on the same column") 
+                << (IntList() << -1 << 2 << 2) 
+                << QPoint(2, 0);
+    QTest::newRow("2 duplicate delegates, 1 row and 1 column") 
+                << (IntList() << 0 << -1 << 2) 
+                << QPoint(2, 0);
+    QTest::newRow("4 duplicate delegates, 2 row and 2 column") 
+                << (IntList() << 0 << 0 << -1 << 2 << 2) 
+                << QPoint(2, 0);
+
+}
+
+void tst_QAbstractItemView::setItemDelegate()
+{
+    QFETCH(IntList, rowsOrColumnsWithDelegate);
+    QFETCH(QPoint, cellToEdit);
+    QTableView v;
+    QItemDelegate *delegate = new QItemDelegate(&v);
+    TestModel model(5, 5);
+    v.setModel(&model);
+
+    bool row = true;
+    foreach (int rc, rowsOrColumnsWithDelegate) {
+        if (rc == -1) {
+            row = !row;
+        } else {
+            if (row) {
+                v.setItemDelegateForRow(rc, delegate);
+            } else {
+                v.setItemDelegateForColumn(rc, delegate);            
+            }
+        }
+    }
+    v.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&v);
+    QCursor::setPos(v.geometry().center());
+    QApplication::syncX();
+#endif
+    QTest::qWait(20);
+    QApplication::setActiveWindow(&v);
+
+    QModelIndex index = model.index(cellToEdit.y(), cellToEdit.x());
+    v.edit(index);
+
+    // This will close the editor
+    TRY_COMPARE(QApplication::focusWidget() == 0, false);
+    QWidget *editor = QApplication::focusWidget();
+    QVERIFY(editor);
+    editor->hide();
+    delete editor;
+    QCOMPARE(model.setData_count, 1);
+    delete delegate;
+}
+
+void tst_QAbstractItemView::noFallbackToRoot()
+{
+    QStandardItemModel model(0, 1);
+    for (int i = 0; i < 5; ++i)
+        model.appendRow(new QStandardItem("top" + QString::number(i)));
+    QStandardItem *par1 = model.item(1);
+    for (int j = 0; j < 15; ++j)
+        par1->appendRow(new QStandardItem("sub" + QString::number(j)));
+    QStandardItem *par2 = par1->child(2);
+    for (int k = 0; k < 10; ++k)
+        par2->appendRow(new QStandardItem("bot" + QString::number(k)));
+    QStandardItem *it1 = par2->child(5);
+
+    QModelIndex parent1 = model.indexFromItem(par1);
+    QModelIndex parent2 = model.indexFromItem(par2);
+    QModelIndex item1 = model.indexFromItem(it1);
+
+    QTreeView v;
+    v.setModel(&model);
+    v.setRootIndex(parent1);
+    v.setCurrentIndex(item1);
+    QCOMPARE(v.currentIndex(), item1);
+    QVERIFY(model.removeRows(0, 10, parent2));
+    QCOMPARE(v.currentIndex(), parent2);
+    QVERIFY(model.removeRows(0, 15, parent1));
+    QCOMPARE(v.currentIndex(), QModelIndex());
+}
+
+void tst_QAbstractItemView::setCurrentIndex_data()
+{
+    QTest::addColumn<QString>("viewType");
+    QTest::addColumn<int>("itemFlags");
+    QTest::addColumn<bool>("result");
+
+    QStringList widgets;
+    widgets << "QListView" << "QTreeView" << "QHeaderView" << "QTableView";
+
+    foreach(QString widget, widgets) {
+        QTest::newRow((widget+QLatin1String(": no flags")).toLocal8Bit().constData())
+            << widget << (int)0 << false;
+        QTest::newRow((widget+QLatin1String(": checkable")).toLocal8Bit().constData())
+            << widget << (int)Qt::ItemIsUserCheckable << false;
+        QTest::newRow((widget+QLatin1String(": selectable")).toLocal8Bit().constData())
+            << widget << (int)Qt::ItemIsSelectable << false;
+        QTest::newRow((widget+QLatin1String(": enabled")).toLocal8Bit().constData())
+            << widget << (int)Qt::ItemIsEnabled << true;
+        QTest::newRow((widget+QLatin1String(": enabled|selectable")).toLocal8Bit().constData())
+            << widget << (int)(Qt::ItemIsSelectable|Qt::ItemIsEnabled) << true;
+    }
+}
+
+void tst_QAbstractItemView::setCurrentIndex()
+{
+    QFETCH(QString, viewType);
+    QFETCH(int, itemFlags);
+    QFETCH(bool, result);
+
+    TestView *view = 0;
+    if (viewType == "QListView")
+        view = reinterpret_cast<TestView*>(new QListView());
+    else if (viewType == "QTableView")
+        view = reinterpret_cast<TestView*>(new QTableView());
+    else if (viewType == "QTreeView")
+        view = reinterpret_cast<TestView*>(new QTreeView());
+    else if (viewType == "QHeaderView")
+        view = reinterpret_cast<TestView*>(new QHeaderView(Qt::Vertical));
+    else
+        QVERIFY(0);
+    view->show();
+
+    QStandardItemModel *model = new QStandardItemModel(view);
+    QStandardItem *item = new QStandardItem("first item");
+    item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+    model->appendRow(item);
+
+    item = new QStandardItem("test item");
+    item->setFlags(Qt::ItemFlags(itemFlags));
+    model->appendRow(item);
+
+    view->setModel(model);
+
+    view->setCurrentIndex(model->index(0,0));
+    QVERIFY(view->currentIndex() == model->index(0,0));
+    view->setCurrentIndex(model->index(1,0));
+    QVERIFY(view->currentIndex() == model->index(result ? 1 : 0,0));
+
+    delete view;
+}
+
+void tst_QAbstractItemView::task221955_selectedEditor()
+{
+    QPushButton *button;
+    
+    QTreeWidget tree;
+    tree.setColumnCount(2);
+
+    tree.addTopLevelItem(new QTreeWidgetItem(QStringList() << "Foo" <<"1"));
+    tree.addTopLevelItem(new QTreeWidgetItem(QStringList() << "Bar" <<"2"));
+    tree.addTopLevelItem(new QTreeWidgetItem(QStringList() << "Baz" <<"3"));
+    
+    QTreeWidgetItem *dummy = new QTreeWidgetItem();
+    tree.addTopLevelItem(dummy);
+    tree.setItemWidget(dummy, 0, button = new QPushButton("More..."));
+    button->setAutoFillBackground(true);  // as recommended in doc
+    
+    tree.show();
+    tree.setFocus();
+    tree.setCurrentIndex(tree.model()->index(1,0));
+    QTest::qWait(100);
+    QApplication::setActiveWindow(&tree);
+    
+    QVERIFY(! tree.selectionModel()->selectedIndexes().contains(tree.model()->index(3,0)));
+
+    //We set the focus to the button, the index need to be selected
+    button->setFocus();    
+    QTest::qWait(100);
+    QVERIFY(tree.selectionModel()->selectedIndexes().contains(tree.model()->index(3,0)));
+    
+    tree.setCurrentIndex(tree.model()->index(1,0));
+    QVERIFY(! tree.selectionModel()->selectedIndexes().contains(tree.model()->index(3,0)));
+    
+    //Same thing but with the flag NoSelection,   nothing can be selected.
+    tree.setFocus();
+    tree.setSelectionMode(QAbstractItemView::NoSelection);
+    tree.clearSelection();
+    QVERIFY(tree.selectionModel()->selectedIndexes().isEmpty());
+    QTest::qWait(10);
+    button->setFocus();    
+    QTest::qWait(50);
+    QVERIFY(tree.selectionModel()->selectedIndexes().isEmpty());
+    
+    
+}
+
+QTEST_MAIN(tst_QAbstractItemView)
+#include "tst_qabstractitemview.moc"