summaryrefslogtreecommitdiffstats
path: root/tests/auto/qitemview
diff options
context:
space:
mode:
authoraxis <qt-info@nokia.com>2009-04-24 11:34:15 (GMT)
committeraxis <qt-info@nokia.com>2009-04-24 11:34:15 (GMT)
commit8f427b2b914d5b575a4a7c0ed65d2fb8f45acc76 (patch)
treea17e1a767a89542ab59907462206d7dcf2e504b2 /tests/auto/qitemview
downloadQt-8f427b2b914d5b575a4a7c0ed65d2fb8f45acc76.zip
Qt-8f427b2b914d5b575a4a7c0ed65d2fb8f45acc76.tar.gz
Qt-8f427b2b914d5b575a4a7c0ed65d2fb8f45acc76.tar.bz2
Long live Qt for S60!
Diffstat (limited to 'tests/auto/qitemview')
-rw-r--r--tests/auto/qitemview/.gitignore1
-rw-r--r--tests/auto/qitemview/qitemview.pro4
-rw-r--r--tests/auto/qitemview/tst_qitemview.cpp923
-rw-r--r--tests/auto/qitemview/viewstotest.cpp165
4 files changed, 1093 insertions, 0 deletions
diff --git a/tests/auto/qitemview/.gitignore b/tests/auto/qitemview/.gitignore
new file mode 100644
index 0000000..c129cad
--- /dev/null
+++ b/tests/auto/qitemview/.gitignore
@@ -0,0 +1 @@
+tst_qitemview
diff --git a/tests/auto/qitemview/qitemview.pro b/tests/auto/qitemview/qitemview.pro
new file mode 100644
index 0000000..de2c328
--- /dev/null
+++ b/tests/auto/qitemview/qitemview.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+SOURCES += tst_qitemview.cpp
+
+
diff --git a/tests/auto/qitemview/tst_qitemview.cpp b/tests/auto/qitemview/tst_qitemview.cpp
new file mode 100644
index 0000000..41d7df5
--- /dev/null
+++ b/tests/auto/qitemview/tst_qitemview.cpp
@@ -0,0 +1,923 @@
+/****************************************************************************
+**
+** 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 <QtCore/QtCore>
+#include <viewstotest.cpp>
+#include <stdlib.h>
+
+#if defined(Q_OS_WIN)
+#include <time.h>
+#if defined(Q_OS_WINCE)
+#include <aygshell.h>
+#endif
+#define random rand
+#define srandom srand
+
+#if defined(Q_OS_WINCE)
+bool qt_wince_is_platform(const QString &platformString) {
+ TCHAR tszPlatform[64];
+ if (SystemParametersInfo(SPI_GETPLATFORMTYPE,
+ sizeof(tszPlatform)/sizeof(*tszPlatform),tszPlatform,0))
+ if (0 == _tcsicmp(reinterpret_cast<const wchar_t *> (platformString.utf16()), tszPlatform))
+ return true;
+ return false;
+}
+
+bool qt_wince_is_pocket_pc() {
+ return qt_wince_is_platform(QString::fromLatin1("PocketPC"));
+}
+
+bool qt_wince_is_smartphone() {
+ return qt_wince_is_platform(QString::fromLatin1("Smartphone"));
+}
+bool qt_wince_is_mobile() {
+ return (qt_wince_is_smartphone() || qt_wince_is_pocket_pc());
+}
+#endif
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=gui/itemviews/qtreeview.h gui/itemviews/qtreeview.cpp
+
+/*!
+ See viewstotest.cpp for instructions on how to have your view tested with these tests.
+
+ Each test such as visualRect have a _data() function which populate the QTest data with
+ tests specified by viewstotest.cpp and any extra data needed for that perticular test.
+
+ setupWithNoTestData() fills QTest data with only the tests it is used by most tests.
+
+ There are some basic qDebug statements sprikled about that might be helpfull for
+ fixing your issues.
+ */
+class tst_QItemView : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_QItemView() {};
+ virtual ~tst_QItemView() {};
+
+public slots:
+ void init();
+ void cleanup();
+
+private slots:
+ void nonDestructiveBasicTest_data();
+ void nonDestructiveBasicTest();
+
+ void spider_data();
+ void spider();
+
+ void resize_data();
+ void resize();
+
+ void visualRect_data();
+ void visualRect();
+
+ void indexAt_data();
+ void indexAt();
+
+ void scrollTo_data();
+ void scrollTo();
+
+ void moveCursor_data();
+ void moveCursor();
+
+private:
+ void setupWithNoTestData();
+ void populate();
+ void walkScreen(QAbstractItemView *view);
+
+ QAbstractItemView *view;
+ QAbstractItemModel *treeModel;
+ ViewsToTest *testViews;
+};
+
+/*!
+ * Views should not make invalid requests, sense a model might not check all the bad cases.
+ */
+class CheckerModel : public QStandardItemModel
+{
+ Q_OBJECT
+
+public:
+ CheckerModel() : QStandardItemModel() {};
+
+ QVariant data(const QModelIndex &index, int role = Qt::DisplayRole ) const {
+ Q_ASSERT(index.isValid());
+ return QStandardItemModel::data(index, role);
+ };
+
+ Qt::ItemFlags flags(const QModelIndex & index) const {
+ Q_ASSERT(index.isValid());
+ if (index.row() == 2 || index.row() == rowCount() - 3
+ || index.column() == 2 || index.column() == columnCount() - 3) {
+ Qt::ItemFlags f = QStandardItemModel::flags(index);
+ f &= ~Qt::ItemIsEnabled;
+ return f;
+ }
+ return QStandardItemModel::flags(index);
+ };
+
+ QModelIndex parent ( const QModelIndex & child ) const {
+ Q_ASSERT(child.isValid());
+ return QStandardItemModel::parent(child);
+ };
+
+ QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const {
+ Q_ASSERT(section >= 0);
+ if (orientation == Qt::Horizontal) { Q_ASSERT(section <= columnCount());};
+ if (orientation == Qt::Vertical) { Q_ASSERT(section <= rowCount());};
+ return QStandardItemModel::headerData(section, orientation, role);
+ }
+
+ QModelIndex index( int row, int column, const QModelIndex & parent = QModelIndex() ) const {
+ Q_ASSERT(row >= 0 && row <= rowCount(parent));
+ Q_ASSERT(column >= 0 && column <= columnCount(parent));
+ return QStandardItemModel::index(row, column, parent);
+ };
+
+ bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) {
+ Q_ASSERT(index.isValid());
+ return QStandardItemModel::setData(index, value, role);
+ }
+
+ void sort( int column, Qt::SortOrder order = Qt::AscendingOrder ) {
+ Q_ASSERT(column >= 0 && column <= columnCount());
+ QStandardItemModel::sort(column, order);
+ };
+
+ QModelIndexList match ( const QModelIndex & start, int role, const QVariant & value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags( Qt::MatchStartsWith | Qt::MatchWrap ) ) const {
+ Q_ASSERT(hits > 0);
+ Q_ASSERT(value.isValid());
+ return QAbstractItemModel::match(start, role, value, hits, flags);
+ };
+
+ bool setHeaderData ( int section, Qt::Orientation orientation, const QVariant & value, int role = Qt::EditRole ) {
+ Q_ASSERT(section >= 0);
+ return QAbstractItemModel::setHeaderData(section, orientation, value, role);
+ };
+};
+
+void tst_QItemView::init()
+{
+#ifdef Q_OS_IRIX
+ return;
+#endif
+
+ testViews = new ViewsToTest();
+ populate();
+}
+
+void tst_QItemView::cleanup()
+{
+ delete testViews;
+ delete view;
+ delete treeModel;
+ view = 0;
+ testViews = 0;
+ treeModel = 0;
+}
+
+void tst_QItemView::setupWithNoTestData()
+{
+#ifdef Q_OS_IRIX
+ //QSKIP("This test takes too long to execute on IRIX", SkipAll);
+ return;
+#endif
+
+ ViewsToTest testViews;
+ QTest::addColumn<QString>("viewType");
+ QTest::addColumn<bool>("displays");
+#if QT_VERSION >= 0x040200
+ QTest::addColumn<int>("vscroll");
+ QTest::addColumn<int>("hscroll");
+#endif
+ for (int i = 0; i < testViews.tests.size(); ++i) {
+ QString view = testViews.tests.at(i).viewType;
+ QString test = view + " ScrollPerPixel";
+ bool displayIndexes = (testViews.tests.at(i).display == ViewsToTest::DisplayRoot);
+ QTest::newRow(test.toLatin1().data()) << view << displayIndexes
+#if QT_VERSION >= 0x040200
+ << (int)QAbstractItemView::ScrollPerPixel
+ << (int)QAbstractItemView::ScrollPerPixel
+#endif
+ ;
+ }
+ for (int i = 0; i < testViews.tests.size(); ++i) {
+ QString view = testViews.tests.at(i).viewType;
+ QString test = view + " ScrollPerItem";
+ bool displayIndexes = (testViews.tests.at(i).display == ViewsToTest::DisplayRoot);
+ QTest::newRow(test.toLatin1().data()) << view << displayIndexes
+#if QT_VERSION >= 0x040200
+ << (int)QAbstractItemView::ScrollPerItem
+ << (int)QAbstractItemView::ScrollPerItem
+#endif
+ ;
+ }
+}
+
+void tst_QItemView::populate()
+{
+ treeModel = new CheckerModel;
+ QModelIndex parent;
+#if defined(QT_ARCH_ARM) || defined(Q_OS_SYMBIAN)
+ const int baseInsert = 4;
+#else
+ const int baseInsert = 26;
+#endif
+ for (int i = 0; i < 40; ++i) {
+ parent = treeModel->index(0, 0, parent);
+ treeModel->insertRows(0, baseInsert + i, parent);
+ treeModel->insertColumns(0, baseInsert + i, parent);
+ // Fill in some values to make it easier to debug
+ for (int x = 0; x < treeModel->rowCount(); ++x) {
+ for (int y = 0; y < treeModel->columnCount(); ++y) {
+ QModelIndex index = treeModel->index(x, y, parent);
+ treeModel->setData(index, QString("%1_%2_%3").arg(x).arg(y).arg(i));
+ treeModel->setData(index, QVariant(QColor(Qt::blue)), Qt::TextColorRole);
+ }
+ }
+ }
+}
+
+void tst_QItemView::nonDestructiveBasicTest_data()
+{
+ setupWithNoTestData();
+}
+
+/*!
+ nonDestructiveBasicTest trys to call a number of the basic functions (not all)
+ to make sure the view doesn't segfault, testing the functions that makes sense.
+ */
+void tst_QItemView::nonDestructiveBasicTest()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+
+#ifdef Q_OS_WINCE
+ QTest::qWait(400);
+#endif
+
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+#if QT_VERSION >= 0x040200
+ QFETCH(int, vscroll);
+ QFETCH(int, hscroll);
+ view->setVerticalScrollMode((QAbstractItemView::ScrollMode)vscroll);
+ view->setHorizontalScrollMode((QAbstractItemView::ScrollMode)hscroll);
+#endif
+
+ // setSelectionModel() will assert
+ //view->setSelectionModel(0);
+ // setItemDelegate() will assert
+ //view->setItemDelegate(0);
+
+ // 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();
+ // edit() causes warning by default
+ //view->edit(QModelIndex());
+ view->clearSelection();
+ view->setCurrentIndex(QModelIndex());
+}
+
+void tst_QItemView::spider_data()
+{
+ setupWithNoTestData();
+}
+
+void touch(QWidget *widget, Qt::KeyboardModifier modifier, Qt::Key keyPress){
+ int width = widget->width();
+ int height = widget->height();
+ for (int i = 0; i < 5; ++i) {
+ QTest::mouseClick(widget, Qt::LeftButton, modifier, QPoint(random() % width, random() % height));
+ QTest::mouseDClick(widget, Qt::LeftButton, modifier, QPoint(random() % width, random() % height));
+ QPoint press(random() % width, random() % height);
+ QPoint releasePoint(random() % width, random() % height);
+ QTest::mousePress(widget, Qt::LeftButton, modifier, press);
+ QTest::mouseMove(widget, releasePoint);
+ if (random() % 1 == 0)
+ QTest::mouseRelease(widget, Qt::LeftButton, 0, releasePoint);
+ else
+ QTest::mouseRelease(widget, Qt::LeftButton, modifier, releasePoint);
+ QTest::keyClick(widget, keyPress);
+ }
+}
+
+/*!
+ This is a basic stress testing application that tries a few basics such as clicking around
+ the screen, and key presses.
+
+ The main goal is to catch any easy segfaults, not to test every case.
+ */
+void tst_QItemView::spider()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+#if QT_VERSION >= 0x040200
+ QFETCH(int, vscroll);
+ QFETCH(int, hscroll);
+ view->setVerticalScrollMode((QAbstractItemView::ScrollMode)vscroll);
+ view->setHorizontalScrollMode((QAbstractItemView::ScrollMode)hscroll);
+#endif
+ view->setModel(treeModel);
+ view->show();
+#if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
+ srandom(0);
+#else
+ srandom(time(0));
+#endif
+ touch(view->viewport(), Qt::NoModifier, Qt::Key_Left);
+ touch(view->viewport(), Qt::ShiftModifier, Qt::Key_Enter);
+ touch(view->viewport(), Qt::ControlModifier, Qt::Key_Backspace);
+ touch(view->viewport(), Qt::AltModifier, Qt::Key_Up);
+}
+
+void tst_QItemView::resize_data()
+{
+ setupWithNoTestData();
+}
+
+/*!
+ The main goal is to catch any infinite loops from layouting
+ */
+void tst_QItemView::resize()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+ return;
+ // This test needs to be re-thought out, it takes too long and
+ // doesn't really catch theproblem.
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+#if QT_VERSION >= 0x040200
+ QFETCH(int, vscroll);
+ QFETCH(int, hscroll);
+ view->setVerticalScrollMode((QAbstractItemView::ScrollMode)vscroll);
+ view->setHorizontalScrollMode((QAbstractItemView::ScrollMode)hscroll);
+#endif
+ view->setModel(treeModel);
+ view->show();
+
+ for (int w = 100; w < 400; w+=10) {
+ for (int h = 100; h < 400; h+=10) {
+ view->resize(w, h);
+ QTest::qWait(1);
+ qApp->processEvents();
+ }
+ }
+}
+
+void tst_QItemView::visualRect_data()
+{
+ setupWithNoTestData();
+}
+
+void tst_QItemView::visualRect()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+#if QT_VERSION >= 0x040200
+ QFETCH(int, vscroll);
+ QFETCH(int, hscroll);
+ view->setVerticalScrollMode((QAbstractItemView::ScrollMode)vscroll);
+ view->setHorizontalScrollMode((QAbstractItemView::ScrollMode)hscroll);
+#endif
+ QCOMPARE(view->visualRect(QModelIndex()), QRect());
+
+ // Add model
+ view->setModel(treeModel);
+ QCOMPARE(view->visualRect(QModelIndex()), QRect());
+
+ QModelIndex topIndex = treeModel->index(0,0);
+
+ QFETCH(bool, displays);
+ if (!displays){
+ QVERIFY(view->visualRect(topIndex) == QRect());
+ return;
+ }
+
+ QVERIFY(view->visualRect(topIndex) != QRect());
+ view->show();
+ QVERIFY(view->visualRect(topIndex) != QRect());
+
+ QVERIFY(topIndex == view->indexAt(view->visualRect(topIndex).center()));
+ QVERIFY(topIndex == view->indexAt(view->visualRect(topIndex).bottomLeft()));
+ QVERIFY(topIndex == view->indexAt(view->visualRect(topIndex).bottomRight()));
+ QVERIFY(topIndex == view->indexAt(view->visualRect(topIndex).topLeft()));
+ QVERIFY(topIndex == view->indexAt(view->visualRect(topIndex).topRight()));
+
+ testViews->hideIndexes(view);
+ QModelIndex hiddenIndex = treeModel->index(1, 0);
+ QVERIFY(view->visualRect(hiddenIndex) == QRect());
+}
+
+void tst_QItemView::walkScreen(QAbstractItemView *view)
+{
+ QModelIndex hiddenIndex = view->model() ? view->model()->index(1, 0) : QModelIndex();
+ int width = view->width();
+ int height = view->height();
+ for (int w = 0; w < width; ++w)
+ {
+ for (int h = 0; h < height; ++h)
+ {
+ QPoint point(w, h);
+ QModelIndex index = view->indexAt(point);
+
+ // If we have no model then we should *never* get a valid index
+ if (!view->model() || !view->isVisible())
+ QVERIFY(!index.isValid());
+ // index should not be the hidden one
+ if (hiddenIndex.isValid())
+ QVERIFY(hiddenIndex != index);
+ // If we are valid then check the visualRect for that index
+ if (index.isValid()){
+ QRect visualRect = view->visualRect(index);
+ if (!visualRect.contains(point))
+ qDebug() << point << visualRect;
+ QVERIFY(visualRect.contains(point));
+ }
+ }
+ }
+}
+
+void walkIndex(QModelIndex index, QAbstractItemView *view)
+{
+ QRect visualRect = view->visualRect(index);
+ //if (index.column() == 0)
+ //qDebug() << index << visualRect;
+ int width = visualRect.width();
+ int height = visualRect.height();
+
+ for (int w = 0; w < width; ++w)
+ {
+ for (int h = 0; h < height; ++h)
+ {
+ QPoint point(visualRect.x()+w, visualRect.y()+h);
+ if (view->indexAt(point) != index) {
+ qDebug() << "index" << index << "visualRect" << visualRect << point << view->indexAt(point);
+ }
+ QVERIFY(view->indexAt(point) == index);
+ }
+ }
+
+}
+
+/*!
+ A model that returns an index of parent X should also return X when asking
+ for the parent of the index.
+
+ This recursive function does pretty extensive testing on the whole model in an
+ effort to catch edge cases.
+
+ This function assumes that rowCount(), columnCount() and index() work. If they have
+ a bug it will point it out, but the above tests should have already found the basic bugs
+ because it is easier to figure out the problem in those tests then this one.
+ */
+void checkChildren(QAbstractItemView *currentView, const QModelIndex &parent = QModelIndex(), int currentDepth=0)
+{
+ QAbstractItemModel *currentModel = currentView->model();
+
+ int rows = currentModel->rowCount(parent);
+ int columns = currentModel->columnCount(parent);
+
+ for (int r = 0; r < rows; ++r) {
+ for (int c = 0; c < columns; ++c) {
+ QModelIndex index = currentModel->index(r, c, parent);
+ walkIndex(index, currentView);
+ if (QTest::currentTestFailed())
+ return;
+
+ // recursivly go down
+ if (currentModel->hasChildren(index) && currentDepth < 2) {
+ checkChildren(currentView, index, ++currentDepth);
+ // Because this is recursive we will return at the first failure rather then
+ // reporting it over and over
+ if (QTest::currentTestFailed())
+ return;
+ }
+ }
+ }
+}
+
+
+void tst_QItemView::indexAt_data()
+{
+ setupWithNoTestData();
+}
+
+void tst_QItemView::indexAt()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+#if QT_VERSION >= 0x040200
+ QFETCH(int, vscroll);
+ QFETCH(int, hscroll);
+ view->setVerticalScrollMode((QAbstractItemView::ScrollMode)vscroll);
+ view->setHorizontalScrollMode((QAbstractItemView::ScrollMode)hscroll);
+#endif
+ view->show();
+ view->setModel(treeModel);
+#if 0
+ checkChildren(view);
+
+ QModelIndex index = view->model()->index(0, 0);
+ while (view->model()->hasChildren(index))
+ index = view->model()->index(0, 0, index);
+ QCOMPARE(view->model()->hasChildren(index), false);
+ QVERIFY(index.isValid());
+ view->setRootIndex(index);
+ //qDebug() << view->indexAt(QPoint(view->width()/2, view->height()/2)) << view->rootIndex();
+ QPoint p(1, view->height()/2);
+ QModelIndex idx = view->indexAt(p);
+ QCOMPARE(idx, QModelIndex());
+#endif
+}
+
+void tst_QItemView::scrollTo_data()
+{
+ setupWithNoTestData();
+}
+
+void tst_QItemView::scrollTo()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+#if QT_VERSION >= 0x040200
+ QFETCH(int, vscroll);
+ QFETCH(int, hscroll);
+ view->setVerticalScrollMode((QAbstractItemView::ScrollMode)vscroll);
+ view->setHorizontalScrollMode((QAbstractItemView::ScrollMode)hscroll);
+#endif
+ view->setModel(treeModel);
+ view->show();
+
+ QModelIndex parent;
+ for (int row = 0; row < treeModel->rowCount(parent); ++row) {
+ for (int column = 0; column < treeModel->columnCount(parent); ++column) {
+ QModelIndex idx = treeModel->index(row, column, parent);
+ view->scrollTo(idx);
+ QRect rect = view->visualRect(idx);
+ view->scrollTo(idx);
+ QCOMPARE(rect, view->visualRect(idx));
+ }
+ }
+
+ QModelIndex idx = treeModel->index(0, 0, parent);
+ view->scrollTo(idx);
+ QRect rect = view->visualRect(idx);
+ view->scrollToBottom();
+ view->scrollTo(idx);
+ QCOMPARE(rect, view->visualRect(idx));
+}
+
+void tst_QItemView::moveCursor_data()
+{
+ setupWithNoTestData();
+}
+
+class Event {
+public:
+ Event(){}
+ Event(Qt::Key k, QModelIndex s, QModelIndex e, QString n) : key(k), start(s), end(e), name(n){}
+ Qt::Key key;
+ QModelIndex start;
+ QModelIndex end;
+ QString name;
+};
+
+
+void tst_QItemView::moveCursor()
+{
+#ifdef Q_OS_IRIX
+ QSKIP("This test takes too long to execute on IRIX", SkipAll);
+#endif
+ QFETCH(QString, viewType);
+ view = testViews->createView(viewType);
+ if (view->objectName() == "QHeaderView")
+ return;
+
+ view->setModel(treeModel);
+ testViews->hideIndexes(view);
+ view->resize(100, 100);
+
+ QModelIndex invalidIndex = QModelIndex();
+ QModelIndex firstRow = treeModel->index(0, 0);
+ QModelIndex hiddenRowT = treeModel->index(1, 0);
+ QModelIndex disabledRowT = treeModel->index(2, 0);
+ QModelIndex secondRow = treeModel->index(3, 0);
+
+ QModelIndex secondToLastRow = treeModel->index(treeModel->rowCount() - 4, 0);
+ QModelIndex disabledRowB = treeModel->index(treeModel->rowCount() - 3, 0);
+ QModelIndex hiddenRowB = treeModel->index(treeModel->rowCount() - 2, 0);
+ QModelIndex lastRow = treeModel->index(treeModel->rowCount() - 1, 0);
+
+ QStack<Event> events;
+
+ events.push(Event(Qt::Key_Up, invalidIndex, firstRow, "inv, first"));
+ events.push(Event(Qt::Key_Up, hiddenRowT, firstRow, "hid, first"));
+ events.push(Event(Qt::Key_Up, disabledRowT, firstRow, "dis, first"));
+ events.push(Event(Qt::Key_Up, firstRow, firstRow, "first, first"));
+ events.push(Event(Qt::Key_Up, secondRow, firstRow, "sec, first"));
+ events.push(Event(Qt::Key_Up, hiddenRowB, firstRow, "hidB, first"));
+ events.push(Event(Qt::Key_Up, disabledRowB, secondToLastRow, "disB, secLast"));
+ events.push(Event(Qt::Key_Up, lastRow, secondToLastRow, "last, secLast"));
+
+ events.push(Event(Qt::Key_Down, invalidIndex, firstRow, "inv, first"));
+ events.push(Event(Qt::Key_Down, hiddenRowT, firstRow, "hid, first"));
+ events.push(Event(Qt::Key_Down, disabledRowT, secondRow, "dis, sec"));
+ events.push(Event(Qt::Key_Down, firstRow, secondRow, "first, sec"));
+ events.push(Event(Qt::Key_Down, secondToLastRow, lastRow, "secLast, last" ));
+ events.push(Event(Qt::Key_Down, disabledRowB, lastRow, "disB, last"));
+ events.push(Event(Qt::Key_Down, hiddenRowB, firstRow, "hidB, first"));
+ events.push(Event(Qt::Key_Down, lastRow, lastRow, "last, last"));
+
+ events.push(Event(Qt::Key_Home, invalidIndex, firstRow, "inv, first"));
+ events.push(Event(Qt::Key_End, invalidIndex, firstRow, "inv, first"));
+
+ if (view->objectName() == "QTableView") {
+ // In a table we move to the first/last column
+ events.push(Event(Qt::Key_Home, hiddenRowT, firstRow, "hid, first"));
+ events.push(Event(Qt::Key_Home, disabledRowT, disabledRowT, "dis, dis"));
+ events.push(Event(Qt::Key_Home, firstRow, firstRow, "first, first"));
+ events.push(Event(Qt::Key_Home, secondRow, secondRow, "sec, sec"));
+ events.push(Event(Qt::Key_Home, disabledRowB, disabledRowB, "disB, disB"));
+ events.push(Event(Qt::Key_Home, hiddenRowB, firstRow, "hidB, first"));
+ events.push(Event(Qt::Key_Home, secondToLastRow, secondToLastRow, "secLast, secLast"));
+ events.push(Event(Qt::Key_Home, lastRow, lastRow, "last, last"));
+
+ int col = treeModel->columnCount() - 1;
+ events.push(Event(Qt::Key_End, hiddenRowT, firstRow, "hidT, hidT"));
+ events.push(Event(Qt::Key_End, disabledRowT, disabledRowT, "disT, disT"));
+ events.push(Event(Qt::Key_End, firstRow, firstRow.sibling(firstRow.row(), col), "first, first_C"));
+ events.push(Event(Qt::Key_End, secondRow, secondRow.sibling(secondRow.row(), col), "sec, sec_C"));
+ events.push(Event(Qt::Key_End, disabledRowB, disabledRowB, "disB, disB"));
+ events.push(Event(Qt::Key_End, hiddenRowB, firstRow, "hidB, hidB"));
+ events.push(Event(Qt::Key_End, secondToLastRow, secondToLastRow.sibling(secondToLastRow.row(), col), "secLast, secLast_C"));
+ events.push(Event(Qt::Key_End, lastRow, lastRow.sibling(lastRow.row(), col), "last, last_C"));
+ } else {
+ events.push(Event(Qt::Key_Home, hiddenRowT, firstRow, "hid, first"));
+ events.push(Event(Qt::Key_Home, disabledRowT, firstRow, "dis, first"));
+ events.push(Event(Qt::Key_Home, firstRow, firstRow, "first, first"));
+ events.push(Event(Qt::Key_Home, secondRow, firstRow, "sec, first"));
+ events.push(Event(Qt::Key_Home, disabledRowB, firstRow, "disB, first"));
+ events.push(Event(Qt::Key_Home, hiddenRowB, firstRow, "hidB, first"));
+ events.push(Event(Qt::Key_Home, secondToLastRow, firstRow, "sec, first"));
+ events.push(Event(Qt::Key_Home, lastRow, firstRow, "last, first"));
+
+ events.push(Event(Qt::Key_End, hiddenRowT, firstRow, "hid, last"));
+ events.push(Event(Qt::Key_End, disabledRowT, lastRow, "dis, last"));
+ events.push(Event(Qt::Key_End, firstRow, lastRow, "first, last"));
+ events.push(Event(Qt::Key_End, secondRow, lastRow, "sec, last"));
+ events.push(Event(Qt::Key_End, disabledRowB, lastRow, "disB, last"));
+ events.push(Event(Qt::Key_End, hiddenRowB, firstRow, "hidB, last"));
+ events.push(Event(Qt::Key_End, secondToLastRow, lastRow, "sec, last"));
+ events.push(Event(Qt::Key_End, lastRow, lastRow, "last, last"));
+ }
+
+ events.push(Event(Qt::Key_PageDown, invalidIndex, firstRow, "inv, first"));
+ events.push(Event(Qt::Key_PageDown, firstRow, QModelIndex(), "first, x"));
+ events.push(Event(Qt::Key_PageDown, secondRow, QModelIndex(), "sec, x"));
+ events.push(Event(Qt::Key_PageDown, hiddenRowT, QModelIndex(), "hid, x"));
+ events.push(Event(Qt::Key_PageDown, disabledRowT, QModelIndex(), "dis, x"));
+ events.push(Event(Qt::Key_PageDown, disabledRowB, lastRow, "disB, last"));
+ events.push(Event(Qt::Key_PageDown, hiddenRowB, lastRow, "hidB, last"));
+ events.push(Event(Qt::Key_PageDown, secondToLastRow, lastRow, "secLast, last"));
+ events.push(Event(Qt::Key_PageDown, lastRow, lastRow, "last, last"));
+
+ events.push(Event(Qt::Key_PageUp, invalidIndex, firstRow, "inv, first"));
+ events.push(Event(Qt::Key_PageUp, firstRow, firstRow, "first, first"));
+ events.push(Event(Qt::Key_PageUp, secondRow, firstRow, "sec, first"));
+ events.push(Event(Qt::Key_PageUp, secondToLastRow, QModelIndex(), "secLast, x"));
+ events.push(Event(Qt::Key_PageUp, lastRow, QModelIndex(), "last, x"));
+
+ if (view->objectName() == "QTableView") {
+ events.push(Event(Qt::Key_Left, firstRow, firstRow, "first_0, first"));
+ events.push(Event(Qt::Key_Left, firstRow.sibling(0, 1), firstRow, "first_1, first"));
+ events.push(Event(Qt::Key_Left, firstRow.sibling(0, 2), firstRow, "first_2, first"));
+ events.push(Event(Qt::Key_Left, firstRow.sibling(0, 3), firstRow, "first_3, first"));
+ events.push(Event(Qt::Key_Left, secondRow, secondRow, "sec, sec"));
+
+ events.push(Event(Qt::Key_Right, firstRow, firstRow.sibling(0, 3), "first, first_3"));
+ events.push(Event(Qt::Key_Right, firstRow.sibling(0, 1), firstRow, "first_1, first"));
+ events.push(Event(Qt::Key_Right, firstRow.sibling(0, 2), firstRow.sibling(0, 3), "first_2, first_3"));
+ events.push(Event(Qt::Key_Right, firstRow.sibling(0, treeModel->columnCount()-1), firstRow.sibling(0, treeModel->columnCount()-1), "first_3, sec"));
+ }
+
+#if 0 // ### disable this part for now
+
+ // ### hide the first/last row,column and re-run all of these tests
+ // ### Not 100% sure, but I think the next to are tableview specific only and everyone else just does up/down
+ // QAbstractItemView::MoveNext, AbstractItemView::MovePrevious
+
+ while (!events.isEmpty()) {
+ Event event = events.pop();
+ view->setCurrentIndex(event.start);
+ QCOMPARE(view->currentIndex(), event.start);
+
+ if (event.key == Qt::Key_PageUp && event.end == QModelIndex()) {
+ QModelIndex x = view->indexAt(QPoint(1,1));
+ if (x.row() == 0)
+ event.end = x;
+ else
+ event.end = x.sibling(x.row() - 1, x.column());
+ }
+ if (event.key == Qt::Key_PageDown && event.end == QModelIndex()) {
+ QModelIndex x = view->indexAt(QPoint(1, view->viewport()->height() - 10));
+ if (x.row() == view->model()->rowCount() - 1)
+ event.end = x;
+ else
+ event.end = x.sibling(x.row() + 1, x.column());
+ }
+
+ QTest::keyPress(view, event.key);
+ QTest::keyRelease(view, event.key);
+ QModelIndex current = view->currentIndex();
+ if (event.key == Qt::Key_PageUp) {
+ int diff = event.end.row() - current.row();
+ QVERIFY(diff <= 2);
+ continue;
+ }
+ if (event.key == Qt::Key_PageDown) {
+ int diff = current.row() - event.end.row();
+ QVERIFY(diff <= 2);
+ continue;
+ }
+
+ if (current != event.end) {
+ QString k;
+ if (event.key == Qt::Key_Up) k = "up";
+ if (event.key == Qt::Key_Right) k = "right";
+ if (event.key == Qt::Key_Left) k = "left";
+ if (event.key == Qt::Key_PageUp) k = "page up";
+ if (event.key == Qt::Key_PageDown) k = "page down";
+ if (event.key == Qt::Key_Down) k = "down";
+ if (event.key == Qt::Key_Home) k = "home";
+ if (event.key == Qt::Key_End) k = "end";
+ qDebug() << k << event.name << event.start << event.end << current;
+ }
+ QCOMPARE(current, event.end);
+ }
+#endif
+}
+
+QTEST_MAIN(tst_QItemView)
+#include "tst_qitemview.moc"
diff --git a/tests/auto/qitemview/viewstotest.cpp b/tests/auto/qitemview/viewstotest.cpp
new file mode 100644
index 0000000..09b0f4f
--- /dev/null
+++ b/tests/auto/qitemview/viewstotest.cpp
@@ -0,0 +1,165 @@
+/****************************************************************************
+**
+** 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 <QtCore/QtCore>
+#include <QtGui/QtGui>
+
+/*
+ To add a view to be tested add the header file to the includes
+ and impliment what is needed in the functions below.
+
+ You can add more then one view, several Qt views are included as examples.
+
+ In tst_qitemview.cpp a new ViewsToTest object is created for each test.
+
+ When you have errors fix the first ones first. Later tests depend upon them working
+*/
+
+class ViewsToTest
+{
+public:
+ ViewsToTest();
+
+ QAbstractItemView *createView(const QString &viewType);
+ void hideIndexes(QAbstractItemView *view);
+
+ enum Display { DisplayNone, DisplayRoot };
+
+ struct test {
+ test(QString m, Display d) : viewType(m), display(d){};
+ QString viewType;
+ Display display;
+ };
+
+ QList<test> tests;
+};
+
+
+/*!
+ Add new tests, they can be the same view, but in a different state.
+ */
+ViewsToTest::ViewsToTest()
+{
+ tests.append(test("QTreeView_ScrollPerItem", DisplayRoot));
+ tests.append(test("QTreeView_ScrollPerPixel", DisplayRoot));
+ tests.append(test("QListView_ScrollPerItem", DisplayRoot));
+ tests.append(test("QListView_ScrollPerPixel", DisplayRoot));
+ tests.append(test("QHeaderViewHorizontal", DisplayNone));
+ tests.append(test("QHeaderViewVertical", DisplayNone));
+ tests.append(test("QTableView_ScrollPerItem", DisplayRoot));
+ tests.append(test("QTableView_ScrollPerPixel", DisplayRoot));
+ tests.append(test("QTableViewNoGrid", DisplayRoot));
+}
+
+/*!
+ Return a new viewType.
+ */
+QAbstractItemView *ViewsToTest::createView(const QString &viewType)
+{
+ QAbstractItemView *view = 0;
+ if (viewType == "QListView_ScrollPerItem") {
+ view = new QListView();
+ view->setObjectName("QListView");
+ view->setHorizontalScrollMode(QAbstractItemView::ScrollPerItem);
+ view->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
+ } else if (viewType == "QListView_ScrollPerPixel") {
+ view = new QListView();
+ view->setObjectName("QListView");
+ view->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
+ view->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+ } else if (viewType == "QHeaderViewHorizontal") {
+ view = new QHeaderView(Qt::Horizontal);
+ view->setObjectName("QHeaderView");
+ } else if (viewType == "QHeaderViewVertical") {
+ view = new QHeaderView(Qt::Vertical);
+ view->setObjectName("QHeaderView");
+ } else if (viewType == "QTableView_ScrollPerItem") {
+ view = new QTableView();
+ view->setObjectName("QTableView");
+ view->setHorizontalScrollMode(QAbstractItemView::ScrollPerItem);
+ view->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
+ } else if (viewType == "QTableView_ScrollPerPixel") {
+ view = new QTableView();
+ view->setObjectName("QTableView");
+ view->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
+ view->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+ } else if (viewType == "QTableViewNoGrid") {
+ QTableView *table = new QTableView();
+ table->setObjectName("QTableView");
+ table->setShowGrid(false);
+ view = table;
+ } else if (viewType == "QTreeView_ScrollPerItem") {
+ view = new QTreeView();
+ view->setObjectName("QTreeView");
+ view->setHorizontalScrollMode(QAbstractItemView::ScrollPerItem);
+ view->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
+ view->setSelectionBehavior(QAbstractItemView::SelectItems);
+ } else if (viewType == "QTreeView_ScrollPerPixel") {
+ view = new QTreeView();
+ view->setObjectName("QTreeView");
+ view->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
+ view->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+ view->setSelectionBehavior(QAbstractItemView::SelectItems);
+ }
+ Q_ASSERT(view);
+ return view;
+}
+
+void ViewsToTest::hideIndexes(QAbstractItemView *view)
+{
+ if (QTableView *tableView = qobject_cast<QTableView *>(view)) {
+ tableView->setColumnHidden(1, true);
+ tableView->setRowHidden(1, true);
+ tableView->setRowHidden(tableView->model()->rowCount()-2, true);
+ }
+ if (QTreeView *treeView = qobject_cast<QTreeView *>(view)) {
+ treeView->setColumnHidden(1, true);
+ treeView->setRowHidden(1, QModelIndex(), true);
+ treeView->setRowHidden(treeView->model()->rowCount()-2, QModelIndex(), true);
+ }
+ if (QListView *listView = qobject_cast<QListView *>(view)) {
+ listView->setRowHidden(1, true);
+ listView->setRowHidden(listView->model()->rowCount()-2, true);
+ }
+}
+