Alessandro Bonazzi
8c43d5cf2f
Files correlati : cg0.exe cg0700a.msk cg0700b.msk cg3.exe cg4.exe Bug : Commento: Merge 1.0 libraries
1578 lines
47 KiB
C++
1578 lines
47 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2015 The Qt Company Ltd.
|
|
** Contact: http://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see http://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at http://www.qt.io/contact-us.
|
|
**
|
|
** 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 or version 3 as published by the Free
|
|
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
|
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
|
** following information to ensure the GNU Lesser General Public License
|
|
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** As a special exception, The Qt Company gives you certain additional
|
|
** rights. These rights are described in The Qt Company LGPL Exception
|
|
** version 1.1, 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.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
|
|
#include <QtTest/QtTest>
|
|
|
|
#include <q3datetimeedit.h>
|
|
#include <qapplication.h>
|
|
#include <qcombobox.h>
|
|
#include <qdialog.h>
|
|
#include <qlineedit.h>
|
|
#include <q3listbox.h>
|
|
#include <q3table.h>
|
|
#include <qlayout.h>
|
|
|
|
#include "../../shared/util.h"
|
|
|
|
#define WAITS 1
|
|
#ifdef WAITS
|
|
#endif
|
|
|
|
Q_DECLARE_METATYPE(QPoint)
|
|
|
|
//TESTED_FILES=
|
|
|
|
QT_FORWARD_DECLARE_CLASS(Q3Table)
|
|
|
|
class tst_Q3Table : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
tst_Q3Table();
|
|
|
|
public slots:
|
|
void initTestCase();
|
|
void cleanupTestCase();
|
|
void init();
|
|
void cleanup();
|
|
private slots:
|
|
void setNumRowsColsItems();
|
|
void setNumRowsColsWidgets();
|
|
|
|
void selection();
|
|
void selectComboTableItem_data();
|
|
void selectComboTableItem();
|
|
void pageUpDownNavigation_data();
|
|
void pageUpDownNavigation();
|
|
void simpleKeyboardNavigation();
|
|
void setRowStretchable();
|
|
void setColumnStretchable();
|
|
void selectRow_data();
|
|
void selectRow();
|
|
void selectColumn_data();
|
|
void selectColumn();
|
|
void removeSelection_selectionChanged();
|
|
void cellNavigation();
|
|
void cellNavigationWhileEditing();
|
|
void removeRow_data();
|
|
void removeRow();
|
|
void swapRowMemoryLeak();
|
|
void insertRows_data();
|
|
void insertRows();
|
|
void editCheck();
|
|
void setCellWidgetFocus();
|
|
void selectionWithMouse_data();
|
|
void selectionWithMouse();
|
|
void valueChanged();
|
|
void numSelections(); // Task specific, moreNumSelections() should cover all bases
|
|
void dateTimeEdit();
|
|
void onValueChanged(int, int);
|
|
void moreNumSelections_data();
|
|
void moreNumSelections();
|
|
void headerSwapIconset();
|
|
void propagateEscapeKey();
|
|
public slots:
|
|
void selectionWasChanged();
|
|
private:
|
|
void setupTableItems();
|
|
Q3Table *testWidget;
|
|
bool isValueChanged, receivedSelectionChanged;
|
|
};
|
|
|
|
Q_DECLARE_METATYPE(Q3Table::SelectionMode);
|
|
|
|
#if 0
|
|
/* XPM */
|
|
static const char *fileopen[] = {
|
|
" 16 13 5 1",
|
|
". c #040404",
|
|
"# c #808304",
|
|
"a c None",
|
|
"b c #f3f704",
|
|
"c c #f3f7f3",
|
|
"aaaaaaaaa...aaaa",
|
|
"aaaaaaaa.aaa.a.a",
|
|
"aaaaaaaaaaaaa..a",
|
|
"a...aaaaaaaa...a",
|
|
".bcb.......aaaaa",
|
|
".cbcbcbcbc.aaaaa",
|
|
".bcbcbcbcb.aaaaa",
|
|
".cbcb...........",
|
|
".bcb.#########.a",
|
|
".cb.#########.aa",
|
|
".b.#########.aaa",
|
|
"..#########.aaaa",
|
|
"...........aaaaa"
|
|
};
|
|
#endif
|
|
|
|
tst_Q3Table::tst_Q3Table()
|
|
: isValueChanged( false )
|
|
{
|
|
}
|
|
|
|
void tst_Q3Table::initTestCase()
|
|
{
|
|
}
|
|
|
|
void tst_Q3Table::cleanupTestCase()
|
|
{
|
|
}
|
|
|
|
void tst_Q3Table::init()
|
|
{
|
|
// Reset the table
|
|
testWidget = new Q3Table(4,4,0,"testWidget");
|
|
testWidget->show();
|
|
#ifdef Q_WS_X11
|
|
qt_x11_wait_for_window_manager( testWidget );
|
|
#endif
|
|
}
|
|
|
|
void tst_Q3Table::cleanup()
|
|
{
|
|
testWidget->hide();
|
|
delete testWidget;
|
|
testWidget = 0;
|
|
}
|
|
|
|
/*
|
|
Function that will popuplate the testWidget with a variety of Q3TableItems
|
|
*/
|
|
|
|
void tst_Q3Table::setupTableItems()
|
|
{
|
|
QStringList list;
|
|
list << "A" << "B";
|
|
Q3ComboTableItem *cbi = new Q3ComboTableItem(testWidget, list);
|
|
testWidget->setItem(1, 1, cbi);
|
|
Q3ComboTableItem *ecbi = new Q3ComboTableItem(testWidget, list, TRUE);
|
|
testWidget->setItem(1, 2, ecbi);
|
|
Q3CheckTableItem *chi = new Q3CheckTableItem(testWidget, "Check");
|
|
testWidget->setItem(2, 2, chi);
|
|
Q3TableItem *ne = new Q3TableItem(testWidget, Q3TableItem::Never, "Never");
|
|
testWidget->setItem(0, 0, ne);
|
|
Q3TableItem *ot = new Q3TableItem(testWidget, Q3TableItem::OnTyping, "On Typing");
|
|
testWidget->setItem(0, 1, ot);
|
|
Q3TableItem *wc = new Q3TableItem(testWidget, Q3TableItem::WhenCurrent, "When Current");
|
|
testWidget->setItem(0, 2, wc);
|
|
Q3TableItem *al = new Q3TableItem(testWidget, Q3TableItem::Always, "Always");
|
|
testWidget->setItem(0, 3, al);
|
|
}
|
|
|
|
#define CELL_TEXT(r, c) QString::number( r ) + "/" + QString::number( c )
|
|
|
|
void tst_Q3Table::setNumRowsColsItems()
|
|
{
|
|
Q3Table *t = new Q3Table( 0, "test_table" );
|
|
|
|
const int initial_num_rows = 4;
|
|
const int initial_num_cols = 4;
|
|
|
|
const int larger_num_rows = 8;
|
|
const int larger_num_cols = 8;
|
|
|
|
const int smaller_num_rows = 3;
|
|
const int smaller_num_cols = 3;
|
|
|
|
t->setNumRows( initial_num_cols );
|
|
t->setNumCols( initial_num_cols );
|
|
|
|
QCOMPARE( t->numRows(), initial_num_rows );
|
|
QCOMPARE( t->numCols(), initial_num_cols );
|
|
|
|
int r, c;
|
|
for ( r = 0; r < initial_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
t->setText( r, c, CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
for ( r = 0; r < initial_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
t->setNumRows( larger_num_rows );
|
|
|
|
for ( r = 0; r < larger_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
if ( r < initial_num_rows && c < initial_num_cols ) {
|
|
QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );
|
|
} else {
|
|
QCOMPARE( t->text( r, c ), QString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
t->setNumCols( larger_num_cols );
|
|
|
|
for ( r = 0; r < larger_num_rows; ++r ) {
|
|
for ( c = 0; c < larger_num_cols; ++c ) {
|
|
if ( r < initial_num_rows && c < initial_num_cols ) {
|
|
QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );
|
|
} else {
|
|
QCOMPARE( t->text( r, c ), QString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
t->setNumRows( smaller_num_rows );
|
|
|
|
for ( r = 0; r < smaller_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
t->setNumCols( smaller_num_cols );
|
|
|
|
for ( r = 0; r < smaller_num_rows; ++r ) {
|
|
for ( c = 0; c < smaller_num_cols; ++c ) {
|
|
QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
delete t;
|
|
}
|
|
|
|
void tst_Q3Table::setNumRowsColsWidgets()
|
|
{
|
|
Q3Table *t = new Q3Table( 0, "test_table" );
|
|
|
|
const int initial_num_rows = 4;
|
|
const int initial_num_cols = 4;
|
|
|
|
const int larger_num_rows = 8;
|
|
const int larger_num_cols = 8;
|
|
|
|
const int smaller_num_rows = 3;
|
|
const int smaller_num_cols = 3;
|
|
|
|
t->setNumRows( initial_num_cols );
|
|
t->setNumCols( initial_num_cols );
|
|
|
|
QCOMPARE( t->numRows(), initial_num_rows );
|
|
QCOMPARE( t->numCols(), initial_num_cols );
|
|
|
|
int r, c;
|
|
|
|
for ( r = 0; r < initial_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
t->setCellWidget( r, c, new QWidget( t, CELL_TEXT( r, c ) ) );
|
|
}
|
|
}
|
|
|
|
for ( r = 0; r < initial_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
t->setNumRows( larger_num_rows );
|
|
|
|
for ( r = 0; r < larger_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
if ( r < initial_num_rows && c < initial_num_cols ) {
|
|
QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );
|
|
} else {
|
|
QCOMPARE( t->cellWidget( r, c ), (QWidget*)0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
t->setNumCols( larger_num_cols );
|
|
|
|
for ( r = 0; r < larger_num_rows; ++r ) {
|
|
for ( c = 0; c < larger_num_cols; ++c ) {
|
|
if ( r < initial_num_rows && c < initial_num_cols ) {
|
|
QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );
|
|
} else {
|
|
QCOMPARE( t->cellWidget( r, c ), (QWidget*)0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
t->setNumRows( smaller_num_rows );
|
|
|
|
for ( r = 0; r < smaller_num_rows; ++r ) {
|
|
for ( c = 0; c < initial_num_cols; ++c ) {
|
|
QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
t->setNumCols( smaller_num_cols );
|
|
|
|
for ( r = 0; r < smaller_num_rows; ++r ) {
|
|
for ( c = 0; c < smaller_num_cols; ++c ) {
|
|
QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );
|
|
}
|
|
}
|
|
|
|
delete t;
|
|
}
|
|
|
|
|
|
void tst_Q3Table::selection()
|
|
{
|
|
Q3Table *t = new Q3Table( 20, 20, 0, "test_table" );
|
|
|
|
t->selectCells( 0, 0, 50, 50 );
|
|
|
|
Q3TableSelection sel( 60, 60, 100, 100 );
|
|
t->addSelection( sel );
|
|
|
|
t->show();
|
|
QCOMPARE( t->numSelections(), 2 );
|
|
delete t;
|
|
}
|
|
|
|
void tst_Q3Table::selectComboTableItem_data()
|
|
{
|
|
QTest::addColumn<bool>("editable");
|
|
|
|
QTest::newRow( "editable" ) << TRUE;
|
|
QTest::newRow( "non-editable" ) << FALSE;
|
|
|
|
}
|
|
|
|
class MyTable : public Q3Table
|
|
{
|
|
// Conveience subclass used to be able to call isEditing()
|
|
public:
|
|
MyTable(int rows,int cols,QWidget *parent = 0,const char *name = 0)
|
|
: Q3Table(rows,cols,parent,name) {}
|
|
bool isEditing() {
|
|
return Q3Table::isEditing();
|
|
}
|
|
};
|
|
|
|
void tst_Q3Table::selectComboTableItem()
|
|
{
|
|
#if 0
|
|
MyTable table(4,4,0,"subclassTestWidget");
|
|
// Test for task #25026
|
|
QFETCH( bool, editable );
|
|
|
|
QStringList strings;
|
|
strings << "One" << "Two" << "Three" << "Four";
|
|
QComboTableItem *cbi = new QComboTableItem(testWidget,strings,editable);
|
|
table.setItem(0,0,cbi);
|
|
table.hide();
|
|
table.show();
|
|
QComboBox *cb;
|
|
if ( !editable )
|
|
cb = (QComboBox*)table.viewport()->child("qt_editor_cb","QComboBox");
|
|
else
|
|
cb = (QComboBox*)table.cellWidget(0,0);
|
|
QVERIFY( cb );
|
|
QCOMPARE(table.text(0,0),QString("One"));
|
|
QTest::mouseClick(cb,QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(cb->width()-7,cb->height()-5));
|
|
QVERIFY(cb->listBox()->isVisible());
|
|
QTest::mouseClick(cb->listBox()->viewport(),QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(5,cb->listBox()->height()-5));
|
|
QCOMPARE(table.text(0,0),QString("Four"));
|
|
|
|
// Ensure the edit is accepted
|
|
QTest::mouseClick(table.viewport(),QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(table.width()-10,table.height()-10));
|
|
QVERIFY(!table.isEditing());
|
|
QCOMPARE(table.text(0,0),QString("Four"));
|
|
|
|
// Now check that Escape will revert any changes
|
|
QTest::mouseClick(cb,QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(cb->width()-7,cb->height()-5));
|
|
QVERIFY(cb->listBox()->isVisible());
|
|
QTest::mouseClick(cb->listBox()->viewport(),QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(5,5));
|
|
QCOMPARE(cb->currentText(),QString("One"));
|
|
QTest::keyClick(cb,Qt::Key_Escape);
|
|
QVERIFY(!table.isEditing());
|
|
QCOMPARE(table.text(0,0),QString("Four"));
|
|
#else
|
|
QSKIP("This test will fail at the moment since the way qtestlib iss handling mouse events is broken",SkipAll);
|
|
#endif
|
|
}
|
|
|
|
void tst_Q3Table::pageUpDownNavigation_data()
|
|
{
|
|
QTest::addColumn<Q3Table::SelectionMode>("selectionMode");
|
|
QTest::addColumn<bool>("activeSelection");
|
|
QTest::addColumn<int>("pgUpTopRow");
|
|
QTest::addColumn<int>("pgUpBottomRow");
|
|
QTest::addColumn<int>("pgUpLeftCol");
|
|
QTest::addColumn<int>("pgUpRightCol");
|
|
QTest::addColumn<int>("pgDownTopRow");
|
|
QTest::addColumn<int>("pgDownBottomRow");
|
|
QTest::addColumn<int>("pgDownLeftCol");
|
|
QTest::addColumn<int>("pgDownRightCol");
|
|
|
|
QTest::newRow("NoSelection") << Q3Table::NoSelection << FALSE << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1;
|
|
QTest::newRow("SingleSelection") << Q3Table::Single << FALSE << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1;
|
|
QTest::newRow("MultiSelection") << Q3Table::Multi << FALSE << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1;
|
|
QTest::newRow("SingleRowSelection") << Q3Table::SingleRow << TRUE << 0 << 0 << 0 << 3 << 3 << 3 << 0 << 3;
|
|
QTest::newRow("MultiRowSelection") << Q3Table::MultiRow << TRUE << 0 << 0 << 0 << 3 << 3 << 3 << 0 << 3;
|
|
}
|
|
|
|
void tst_Q3Table::pageUpDownNavigation()
|
|
{
|
|
setupTableItems();
|
|
|
|
// Test for task #25842
|
|
QFETCH(Q3Table::SelectionMode,selectionMode);
|
|
QFETCH(bool,activeSelection);
|
|
QFETCH(int,pgUpTopRow);
|
|
QFETCH(int,pgUpBottomRow);
|
|
QFETCH(int,pgUpLeftCol);
|
|
QFETCH(int,pgUpRightCol);
|
|
QFETCH(int,pgDownTopRow);
|
|
QFETCH(int,pgDownBottomRow);
|
|
QFETCH(int,pgDownLeftCol);
|
|
QFETCH(int,pgDownRightCol);
|
|
|
|
// Needed to force the table to have "no selection"
|
|
testWidget->setCurrentCell(-1,-1);
|
|
|
|
testWidget->setSelectionMode(selectionMode);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_PageUp);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
Q3TableSelection ts = testWidget->selection(testWidget->currentSelection());
|
|
QVERIFY(ts.isActive() == activeSelection);
|
|
if (activeSelection) {
|
|
QVERIFY(ts.topRow() == pgUpTopRow);
|
|
QVERIFY(ts.bottomRow() == pgUpBottomRow);
|
|
QVERIFY(ts.leftCol() == pgUpLeftCol);
|
|
QVERIFY(ts.rightCol() == pgUpRightCol);
|
|
}
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_PageDown);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
ts = testWidget->selection(testWidget->currentSelection());
|
|
QVERIFY(ts.isActive() == activeSelection);
|
|
if (activeSelection) {
|
|
QVERIFY(ts.topRow() == pgDownTopRow);
|
|
QVERIFY(ts.bottomRow() == pgDownBottomRow);
|
|
QVERIFY(ts.leftCol() == pgDownLeftCol);
|
|
QVERIFY(ts.rightCol() == pgDownRightCol);
|
|
}
|
|
}
|
|
|
|
void tst_Q3Table::simpleKeyboardNavigation()
|
|
{
|
|
QApplication::setActiveWindow(testWidget);
|
|
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(testWidget));
|
|
QWidget *w;
|
|
|
|
// Test for task #24726
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::mouseClick(testWidget->viewport(),
|
|
Qt::LeftButton, Qt::NoModifier,
|
|
QPoint(testWidget->columnPos(0) + 3, testWidget->rowPos(0) + 3));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_T);
|
|
|
|
// After the first keyevent, the table starts editing the item
|
|
w = testWidget->cellWidget(0, 0);
|
|
QVERIFY(w);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_E);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_C);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_H);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
#ifdef Q_WS_MAC // Mac lineedits grab Up and Down
|
|
QTest::keyClick(w, Qt::Key_Return);
|
|
#else
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Down);
|
|
#endif
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QCOMPARE(testWidget->text(0,0), QString("tech"));
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
QCOMPARE(testWidget->currentRow(), 1);
|
|
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
w = testWidget->cellWidget(0, 1);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_B);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_C);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
#ifdef Q_WS_MAC // Mac lineedits grab Up and Down
|
|
QTest::keyClick(w, Qt::Key_Return);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Up);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Up);
|
|
#else
|
|
QTest::keyClick(w, Qt::Key_Up);
|
|
#endif
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QCOMPARE(testWidget->text(1,0), QString("abc"));
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
w = testWidget->cellWidget(0, 0);
|
|
|
|
QTest::keyClick(w, Qt::Key_D);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_E);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::keyClick(w, Qt::Key_F);
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
#ifdef Q_WS_MAC // Mac lineedits grab Up and Down
|
|
QTest::keyClick(w, Qt::Key_Return);
|
|
#else
|
|
QTest::keyClick(w, Qt::Key_Down);
|
|
#endif
|
|
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QCOMPARE(testWidget->text(0,0), QString("def"));
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
QCOMPARE(testWidget->currentRow(), 1);
|
|
}
|
|
|
|
void tst_Q3Table::setRowStretchable()
|
|
{
|
|
#if 1
|
|
QSKIP("This test currently fails on all versions", SkipAll);
|
|
#endif
|
|
// Part of test for task 24471
|
|
// Only tests TRUE case, need FALSE case written
|
|
// Also needs to test the case where the user tries to resize it
|
|
testWidget->setRowStretchable(0,TRUE);
|
|
testWidget->show();
|
|
int height = testWidget->rowHeight(0);
|
|
testWidget->setRowHeight(0,height * 2);
|
|
QCOMPARE(height,testWidget->rowHeight(0));
|
|
}
|
|
|
|
void tst_Q3Table::setColumnStretchable()
|
|
{
|
|
#if 1
|
|
QSKIP("This test currently fails on all versions", SkipAll);
|
|
#endif
|
|
// Part of test for task 24471
|
|
// Only tests TRUE case, need FALSE case written
|
|
// Also needs to test the case where the user tries to resize it
|
|
testWidget->setColumnStretchable(0,TRUE);
|
|
testWidget->show();
|
|
int width = testWidget->columnWidth(0);
|
|
testWidget->setColumnWidth(0,width * 2);
|
|
QCOMPARE(width,testWidget->columnWidth(0));
|
|
}
|
|
|
|
void tst_Q3Table::selectRow_data()
|
|
{
|
|
QTest::addColumn<Q3Table::SelectionMode>("selectionMode");
|
|
QTest::addColumn<bool>("activeSelection");
|
|
QTest::addColumn<int>("topRow");
|
|
QTest::addColumn<int>("bottomRow");
|
|
QTest::addColumn<int>("leftCol");
|
|
QTest::addColumn<int>("rightCol");
|
|
|
|
QTest::newRow("NoSelection") << Q3Table::NoSelection << TRUE << 1 << 1 << 0 << 3;
|
|
QTest::newRow("SingleSelection") << Q3Table::Single << TRUE << 1 << 1 << 0 << 3;
|
|
QTest::newRow("MultiSelection") << Q3Table::Multi << TRUE << 1 << 1 << 0 << 3;
|
|
QTest::newRow("SingleRowSelection") << Q3Table::SingleRow << TRUE << 1 << 1 << 0 << 3;
|
|
QTest::newRow("MultiRowSelection") << Q3Table::MultiRow << TRUE << 1 << 1 << 0 << 3;
|
|
}
|
|
|
|
void tst_Q3Table::selectRow()
|
|
{
|
|
QFETCH(Q3Table::SelectionMode,selectionMode);
|
|
QFETCH(bool,activeSelection);
|
|
QFETCH(int,topRow);
|
|
QFETCH(int,bottomRow);
|
|
QFETCH(int,leftCol);
|
|
QFETCH(int,rightCol);
|
|
|
|
testWidget->clearSelection();
|
|
testWidget->setSelectionMode(selectionMode);
|
|
testWidget->selectRow(1);
|
|
|
|
int current = testWidget->currentSelection();
|
|
QVERIFY(current != -1);
|
|
Q3TableSelection ts = testWidget->selection(current);
|
|
|
|
QCOMPARE(ts.isActive(), activeSelection);
|
|
|
|
if (activeSelection) {
|
|
QCOMPARE(ts.topRow(), topRow);
|
|
QCOMPARE(ts.bottomRow(), bottomRow);
|
|
QCOMPARE(ts.leftCol(), leftCol);
|
|
QCOMPARE(ts.rightCol(), rightCol);
|
|
}
|
|
|
|
// make sure selection is cleared
|
|
testWidget->clearSelection();
|
|
current = testWidget->currentSelection();
|
|
QVERIFY(current == -1);
|
|
|
|
testWidget->selectRow(1);
|
|
QEXPECT_FAIL("SingleRowSelection", "This currently fails in all versions", Abort);
|
|
QVERIFY(testWidget->numSelections() > 0); // selectRow in SingleRowSelection doesn't select anything (see qtable.cpp)
|
|
current = testWidget->currentSelection();
|
|
QVERIFY(current != -1);
|
|
ts = testWidget->selection(current);
|
|
|
|
QCOMPARE(ts.isActive(), activeSelection);
|
|
|
|
if (activeSelection) {
|
|
QCOMPARE(ts.topRow(), topRow);
|
|
QCOMPARE(ts.bottomRow(), bottomRow);
|
|
QCOMPARE(ts.leftCol(), leftCol);
|
|
QCOMPARE(ts.rightCol(), rightCol);
|
|
}
|
|
}
|
|
|
|
void tst_Q3Table::selectColumn_data()
|
|
{
|
|
QTest::addColumn<Q3Table::SelectionMode>("selectionMode");
|
|
QTest::addColumn<bool>("activeSelection");
|
|
QTest::addColumn<int>("topRow");
|
|
QTest::addColumn<int>("bottomRow");
|
|
QTest::addColumn<int>("leftCol");
|
|
QTest::addColumn<int>("rightCol");
|
|
|
|
QTest::newRow("NoSelection") << Q3Table::NoSelection << TRUE << 0 << 3 << 1 << 1;
|
|
QTest::newRow("SingleSelection") << Q3Table::Single << TRUE << 0 << 3 << 1 << 1;
|
|
QTest::newRow("MultiSelection") << Q3Table::Multi << TRUE << 0 << 3 << 1 << 1;
|
|
QTest::newRow("SingleRowSelection") << Q3Table::SingleRow << TRUE << 0 << 3 << 1 << 1;
|
|
QTest::newRow("MultiRowSelection") << Q3Table::MultiRow << TRUE << 0 << 3 << 1 << 1;
|
|
}
|
|
|
|
void tst_Q3Table::selectColumn()
|
|
{
|
|
QFETCH(Q3Table::SelectionMode,selectionMode);
|
|
QFETCH(bool,activeSelection);
|
|
QFETCH(int,topRow);
|
|
QFETCH(int,bottomRow);
|
|
QFETCH(int,leftCol);
|
|
QFETCH(int,rightCol);
|
|
|
|
testWidget->setSelectionMode(selectionMode);
|
|
testWidget->selectColumn(1);
|
|
Q3TableSelection ts = testWidget->selection(testWidget->currentSelection());
|
|
QCOMPARE(ts.isActive(), activeSelection);
|
|
|
|
if (activeSelection) {
|
|
QCOMPARE(ts.topRow(), topRow);
|
|
QCOMPARE(ts.bottomRow(), bottomRow);
|
|
QCOMPARE(ts.leftCol(), leftCol);
|
|
QCOMPARE(ts.rightCol(), rightCol);
|
|
}
|
|
|
|
testWidget->clearSelection();
|
|
ts = testWidget->selection(testWidget->currentSelection());
|
|
QVERIFY(!ts.isActive());
|
|
|
|
testWidget->selectColumn(1);
|
|
ts = testWidget->selection(testWidget->currentSelection());
|
|
QCOMPARE(ts.isActive(), activeSelection);
|
|
if (activeSelection) {
|
|
QCOMPARE(ts.topRow(), topRow);
|
|
QCOMPARE(ts.bottomRow(), bottomRow);
|
|
QCOMPARE(ts.leftCol(), leftCol);
|
|
QCOMPARE(ts.rightCol(), rightCol);
|
|
}
|
|
}
|
|
|
|
void tst_Q3Table::cellNavigation()
|
|
{
|
|
#if 0
|
|
setupTableItems();
|
|
#endif
|
|
|
|
testWidget->setCurrentCell(0, 0);
|
|
|
|
// Check tab key first
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Tab);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
QCOMPARE(testWidget->currentColumn(), 1);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Tab);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
QCOMPARE(testWidget->currentColumn(), 2);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Tab);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
// One more, and it should stay where it is
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Tab);
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
QCOMPARE(testWidget->currentColumn(), 3);
|
|
|
|
testWidget->setCurrentCell(3,3);
|
|
|
|
// Now check backtab key
|
|
QCOMPARE(testWidget->currentRow(), 3);
|
|
QCOMPARE(testWidget->currentColumn(), 3);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_BackTab);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(testWidget->currentRow(), 3);
|
|
QCOMPARE(testWidget->currentColumn(), 2);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_BackTab);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(testWidget->currentRow(), 3);
|
|
QCOMPARE(testWidget->currentColumn(), 1);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_BackTab);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
// One more, and it should stay where it is
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_BackTab);
|
|
QCOMPARE(testWidget->currentRow(), 3);
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
testWidget->setCurrentCell(0, 0);
|
|
|
|
// Now check enter key
|
|
for (int row = 0; row < 3; ++row) {
|
|
QCOMPARE(testWidget->currentRow(), row);
|
|
QCOMPARE(testWidget->currentColumn(), 0);
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Enter);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
}
|
|
// One more, and it should go to back
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_Enter);
|
|
QCOMPARE(testWidget->currentRow(), 0);
|
|
QCOMPARE(testWidget->currentColumn(), 1);
|
|
}
|
|
|
|
void tst_Q3Table::cellNavigationWhileEditing()
|
|
{
|
|
// This is basically the cellNavigation() test
|
|
// with the current cell being edited before
|
|
// navigation.
|
|
#if 0
|
|
setupTableItems();
|
|
|
|
int a, b;
|
|
QPoint contentPos;
|
|
// Check tab key first
|
|
for (a = 0;a < 4;a++) {
|
|
for (b = 0;b < 4;b++) {
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
contentPos = QPoint(testWidget->columnPos(b) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Tab);
|
|
}
|
|
}
|
|
// One more should put it at the beginning again
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Tab);
|
|
QCOMPARE(testWidget->currentRow(),0);
|
|
QCOMPARE(testWidget->currentColumn(),0);
|
|
|
|
testWidget->setCurrentCell(3,3);
|
|
// Now check backtab key
|
|
for (a = 3;a > -1;a--) {
|
|
for (b = 3;b > -1;b--) {
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
contentPos = QPoint(testWidget->columnPos(b) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_BackTab);
|
|
}
|
|
}
|
|
// One more should put it at the end again
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_BackTab);
|
|
QCOMPARE(testWidget->currentRow(),3);
|
|
QCOMPARE(testWidget->currentColumn(),3);
|
|
|
|
testWidget->setCurrentCell(0,0);
|
|
// Now check enter key
|
|
for (a = 0;a < 4;a++) {
|
|
for (b = 0;b < 4;b++) {
|
|
QCOMPARE(testWidget->currentColumn(),a);
|
|
QCOMPARE(testWidget->currentRow(),b);
|
|
contentPos = QPoint(testWidget->columnPos(a) + 3, testWidget->rowPos(b) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Enter);
|
|
}
|
|
}
|
|
// One more should put it at the beginning again
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Enter);
|
|
QCOMPARE(testWidget->currentRow(),0);
|
|
QCOMPARE(testWidget->currentColumn(),0);
|
|
|
|
// Reset it back to the top
|
|
contentPos = QPoint(testWidget->columnPos(0) + 3, testWidget->rowPos(0) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
|
|
// Now check down key
|
|
for (a = 0;a < 4;a++) {
|
|
for (b = 0;b < 4;b++) {
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
contentPos = QPoint(testWidget->columnPos(b) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Down);
|
|
if (a == 3) {
|
|
// Check it hasn't moved from the bottom even
|
|
// after clicking down
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
// Put it in correct place for next check
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Home);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Right);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start at the bottom now
|
|
contentPos = QPoint(testWidget->columnPos(0) + 3, testWidget->rowPos(3) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
|
|
// Now check up key
|
|
for (a = 3;a > -1;a--) {
|
|
for (b = 3;b > -1;b--) {
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
contentPos = QPoint(testWidget->columnPos(b) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Up);
|
|
if (a == 0) {
|
|
// Check it hasn't moved from the bottom even
|
|
// after clicking down
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
// Put it in correct place for next check
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_End);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Right);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Reset it back to the top
|
|
contentPos = QPoint(testWidget->columnPos(0) + 3, testWidget->rowPos(0) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
|
|
// Now check right key
|
|
for (a = 0;a < 4;a++) {
|
|
for (b = 0;b < 4;b++) {
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
contentPos = QPoint(testWidget->columnPos(b) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Right);
|
|
if (b == 3) {
|
|
// Check it hasn't moved from the bottom even
|
|
// after clicking down
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
// Put it in correct place for next check
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Home);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Down);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start it at the far left
|
|
contentPos = QPoint(testWidget->columnPos(3) + 3, testWidget->rowPos(0) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
|
|
// Now check up key
|
|
for (a = 3;a > -1;a--) {
|
|
for (b = 3;b > -1;b--) {
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
contentPos = QPoint(testWidget->columnPos(b) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoButton,
|
|
testWidget->contentsToViewport(contentPos));
|
|
if(a == 0 && b == 2) // On typing item
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_A);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Left);
|
|
if (b == 0) {
|
|
// Check it hasn't moved from the bottom even
|
|
// after clicking down
|
|
QCOMPARE(testWidget->currentRow(),a);
|
|
QCOMPARE(testWidget->currentColumn(),b);
|
|
// Put it in correct place for next check
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_End);
|
|
QTest::keyClick(testWidget->viewport(),Qt::Key_Down);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
QSKIP( "This test currently fails on all versions", SkipAll);
|
|
#endif
|
|
}
|
|
|
|
void tst_Q3Table::removeRow_data()
|
|
{
|
|
QTest::addColumn<Q3Table::SelectionMode>("selectionMode");
|
|
|
|
QTest::newRow("NoSelection") << Q3Table::NoSelection;
|
|
QTest::newRow("SingleSelection") << Q3Table::Single;
|
|
QTest::newRow("MultiSelection") << Q3Table::Multi;
|
|
QTest::newRow("SingleRowSelection") << Q3Table::SingleRow;
|
|
QTest::newRow("MultiRowSelection") << Q3Table::MultiRow;
|
|
}
|
|
|
|
|
|
void tst_Q3Table::removeRow()
|
|
{
|
|
QFETCH(Q3Table::SelectionMode, selectionMode);
|
|
|
|
#if 1
|
|
if(selectionMode == Q3Table::SingleRow
|
|
|| selectionMode == Q3Table::MultiRow)
|
|
QSKIP("removeRow() is expected to fail in SingleRow/MultiRow selection modes in all versions", SkipAll);
|
|
#endif
|
|
// This tests task 26419
|
|
|
|
|
|
setupTableItems();
|
|
testWidget->setSelectionMode(selectionMode);
|
|
for(int a = 3;a > -1;a--) {
|
|
QPoint contentPos(testWidget->columnPos(0) + 3, testWidget->rowPos(a) + 3);
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoModifier,
|
|
testWidget->contentsToViewport(contentPos));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
if (selectionMode != Q3Table::NoSelection) {
|
|
Q3TableSelection ts = testWidget->selection(testWidget->currentSelection());
|
|
QVERIFY(ts.isActive());
|
|
QVERIFY(ts.topRow() == a);
|
|
QVERIFY(ts.bottomRow() == a);
|
|
}
|
|
testWidget->removeRow(a);
|
|
// a is actually now the number of rows because the row sections are
|
|
// zero-based
|
|
QVERIFY(testWidget->numRows() == a);
|
|
QVERIFY(!testWidget->selection(testWidget->currentSelection()).isActive());
|
|
}
|
|
}
|
|
|
|
|
|
class SwapRowMemoryLeakTableItem : public Q3TableItem
|
|
{
|
|
public:
|
|
SwapRowMemoryLeakTableItem(Q3Table * table, const QString & text, bool * deletionFlag)
|
|
: Q3TableItem(table, OnTyping, text)
|
|
{
|
|
this->deletionFlag = deletionFlag;
|
|
}
|
|
|
|
~SwapRowMemoryLeakTableItem()
|
|
{
|
|
*deletionFlag = TRUE;
|
|
}
|
|
|
|
private:
|
|
bool * deletionFlag;
|
|
};
|
|
|
|
|
|
void tst_Q3Table::swapRowMemoryLeak()
|
|
{
|
|
//Although this should fail due to code in Q3Table::swapRows() it dose not becuse it is saved
|
|
//in ~Q3Table
|
|
Q3Table * quickTable = new Q3Table(2, 1);
|
|
|
|
|
|
bool i1deletionFlag = FALSE;
|
|
SwapRowMemoryLeakTableItem * i1 = new SwapRowMemoryLeakTableItem(quickTable,"item 1", &i1deletionFlag);
|
|
quickTable->setItem(0, 0, i1);
|
|
bool i2deletionFlag = FALSE;
|
|
SwapRowMemoryLeakTableItem * i2 = new SwapRowMemoryLeakTableItem(quickTable,"item 2", &i2deletionFlag);
|
|
quickTable->setItem(1, 0, i2);
|
|
|
|
quickTable->swapRows(0, 1);
|
|
|
|
// quickTable->removeRow(0);
|
|
|
|
delete quickTable;
|
|
|
|
QVERIFY(i1deletionFlag);
|
|
QVERIFY(i2deletionFlag);
|
|
}
|
|
|
|
void tst_Q3Table::insertRows_data()
|
|
{
|
|
QTest::addColumn<int>("rowToInsertAt");
|
|
QTest::addColumn<int>("numberOfRowsToInsert");
|
|
|
|
QTest::newRow("firstRowOneRow") << 1 << 1;
|
|
QTest::newRow("secondRowTenRows") << 2 << 10;
|
|
QTest::newRow("thirdRowNoRows") << 3 << 0;
|
|
QTest::newRow("zerothRowNegativeRows") << 0 << -1;
|
|
}
|
|
|
|
void tst_Q3Table::insertRows()
|
|
{
|
|
QFETCH(int, rowToInsertAt);
|
|
QFETCH(int, numberOfRowsToInsert);
|
|
|
|
int i = 0;
|
|
for (i = 0;i < 4;i++)
|
|
testWidget->setText(i, 0, QString("Item %0,0").arg(i));
|
|
|
|
testWidget->insertRows(rowToInsertAt, numberOfRowsToInsert);
|
|
if(numberOfRowsToInsert <= 0) {
|
|
QVERIFY(testWidget->numRows() == 4);
|
|
} else {
|
|
QVERIFY(testWidget->numRows() == 4 + numberOfRowsToInsert);
|
|
}
|
|
|
|
int rowNumber = 0;
|
|
for (i = 0;i < rowToInsertAt;i++) {
|
|
QCOMPARE(testWidget->text(i, 0), QString("Item %0,0").arg(rowNumber));
|
|
rowNumber++;
|
|
}
|
|
|
|
if (numberOfRowsToInsert > 0) {
|
|
for (i = rowToInsertAt;i < rowToInsertAt + numberOfRowsToInsert;i++)
|
|
QCOMPARE(testWidget->text(i, 0), QString());
|
|
|
|
for (i = rowToInsertAt + numberOfRowsToInsert;i < 4 + numberOfRowsToInsert;i++) {
|
|
QCOMPARE(testWidget->text(i, 0), QString("Item %0,0").arg(rowNumber));
|
|
rowNumber++;
|
|
}
|
|
}
|
|
}
|
|
|
|
class EditCheckQ3Table : public Q3Table
|
|
{
|
|
public:
|
|
int endEditCount;
|
|
int beginEditCount;
|
|
|
|
EditCheckQ3Table(int r, int c, QWidget *parent = 0, const char *name = 0)
|
|
: Q3Table(r, c, parent, name)
|
|
{
|
|
endEditCount = beginEditCount = 0;
|
|
}
|
|
protected:
|
|
void endEdit(int row, int col, bool accept, bool replace)
|
|
{
|
|
endEditCount++;
|
|
Q3Table::endEdit(row, col, accept, replace);
|
|
}
|
|
QWidget * beginEdit(int row, int col, bool replace)
|
|
{
|
|
beginEditCount++;
|
|
return Q3Table::beginEdit(row, col, replace);
|
|
}
|
|
};
|
|
|
|
void tst_Q3Table::editCheck()
|
|
{
|
|
// Test for task 28086
|
|
#if 1
|
|
QSKIP("This test currently fails on all versions", SkipAll);
|
|
#endif
|
|
|
|
EditCheckQ3Table table(10, 10, 0);
|
|
table.show();
|
|
QApplication::setActiveWindow(&table);
|
|
QTest::qWaitForWindowShown(&table);
|
|
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&table));
|
|
table.setCurrentCell(0, 0);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(table.viewport(), Qt::Key_T);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
// After the first keyevent, the table starts editing the item
|
|
QLineEdit *le = qFindChild<QLineEdit *>(testWidget->viewport(), "qt_lineeditor");
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(le, Qt::Key_Enter);
|
|
le = 0;
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(table.beginEditCount, 1);
|
|
QEXPECT_FAIL("", "this fails because endEdit is called for the old current item when we set a new one", Abort);
|
|
QCOMPARE(table.endEditCount, 1);
|
|
}
|
|
|
|
void tst_Q3Table::setCellWidgetFocus()
|
|
{
|
|
#define CELLWIDGET_CHEAT 1
|
|
// Test for task 27683
|
|
int numRows = testWidget->numRows();
|
|
int numCols = testWidget->numCols();
|
|
testWidget->setNumRows(1);
|
|
testWidget->setNumCols(1);
|
|
#if CELLWIDGET_CHEAT
|
|
qApp->processEvents();
|
|
#endif
|
|
QLineEdit *lineedit = new QLineEdit(testWidget);
|
|
testWidget->setCellWidget(0, 0, lineedit);
|
|
testWidget->show();
|
|
qApp->setActiveWindow(testWidget);
|
|
lineedit->setFocus();
|
|
QVERIFY(lineedit->hasFocus());
|
|
testWidget->setNumRows(numRows);
|
|
testWidget->setNumCols(numCols);
|
|
}
|
|
|
|
void tst_Q3Table::selectionWithMouse_data()
|
|
{
|
|
QTest::addColumn<QPoint>("clickPos");
|
|
QTest::addColumn<Q3Table::SelectionMode>("selectionMode");
|
|
QTest::addColumn<int>("numSelections");
|
|
QTest::addColumn<bool>("activeSelection");
|
|
QTest::addColumn<int>("topRow");
|
|
QTest::addColumn<int>("bottomRow");
|
|
QTest::addColumn<int>("leftCol");
|
|
QTest::addColumn<int>("rightCol");
|
|
|
|
QTest::newRow("NoSelection") << QPoint(20, 15) << Q3Table::NoSelection << 0 << FALSE << -1 << -1 << -1 << -1;
|
|
QTest::newRow("SingleSelection") << QPoint(20, 15) << Q3Table::Single << 1 << TRUE << 0 << 0 << 0 << 0;
|
|
QTest::newRow("MultiSelection") << QPoint(20, 15) << Q3Table::Multi << 1 << TRUE << 0 << 0 << 0 << 0;
|
|
QTest::newRow("SingleRowSelection") << QPoint(20, 15) << Q3Table::SingleRow << 1 << TRUE << 0 << 0 << 0 << 3;
|
|
QTest::newRow("MultiRowSelection") << QPoint(20, 15) << Q3Table::MultiRow << 1 << TRUE << 0 << 0 << 0 << 3;
|
|
}
|
|
|
|
void tst_Q3Table::selectionWithMouse()
|
|
{
|
|
QFETCH(QPoint, clickPos);
|
|
QFETCH(Q3Table::SelectionMode, selectionMode);
|
|
QFETCH(int, numSelections);
|
|
QFETCH(bool, activeSelection);
|
|
QFETCH(int, topRow);
|
|
QFETCH(int, bottomRow);
|
|
QFETCH(int, leftCol);
|
|
QFETCH(int, rightCol);
|
|
|
|
testWidget->setSelectionMode((Q3Table::SelectionMode)selectionMode);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::mouseClick(testWidget->viewport(), Qt::LeftButton, Qt::NoModifier, clickPos);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QVERIFY(testWidget->numSelections() == numSelections);
|
|
Q3TableSelection ts = testWidget->selection(testWidget->currentSelection());
|
|
QVERIFY(ts.isActive() == activeSelection);
|
|
if (activeSelection) {
|
|
QVERIFY(ts.topRow() == topRow);
|
|
QVERIFY(ts.bottomRow() == bottomRow);
|
|
QVERIFY(ts.leftCol() == leftCol);
|
|
QVERIFY(ts.rightCol() == rightCol);
|
|
}
|
|
}
|
|
|
|
class TimeTableItem : public Q3TableItem
|
|
{
|
|
public:
|
|
TimeTableItem(Q3Table *parent=0)
|
|
: Q3TableItem(parent, Q3TableItem::OnTyping, ""),
|
|
editorWasTimeEdit(false)
|
|
{ setReplaceable(false); }
|
|
|
|
QWidget* createEditor() const
|
|
{
|
|
return new Q3TimeEdit(table()->viewport(), "time_edit");
|
|
}
|
|
|
|
void setContentFromEditor(QWidget* widget)
|
|
{
|
|
Q3TimeEdit *time_edit = ::qobject_cast<Q3TimeEdit*>(widget);
|
|
if (!time_edit) {
|
|
editorWasTimeEdit = false;
|
|
Q3TableItem::setContentFromEditor(widget);
|
|
return;
|
|
}
|
|
editorWasTimeEdit = true;
|
|
QTime res = time_edit->time();
|
|
setText(QString::number(QTime().secsTo(res)));
|
|
}
|
|
|
|
bool editorWasTimeEdit;
|
|
};
|
|
|
|
void tst_Q3Table::onValueChanged(int, int)
|
|
{
|
|
isValueChanged = true;
|
|
}
|
|
|
|
void tst_Q3Table::valueChanged()
|
|
{
|
|
// task 27496
|
|
isValueChanged = false;
|
|
TimeTableItem *ti = new TimeTableItem(testWidget);
|
|
testWidget->setItem(0, 0, ti);
|
|
connect(testWidget,SIGNAL(valueChanged(int,int)),this,SLOT(onValueChanged(int,int)));
|
|
testWidget->show();
|
|
QApplication::setActiveWindow(testWidget);
|
|
QTest::qWaitForWindowShown(testWidget);
|
|
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(testWidget));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_1);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTRY_VERIFY(qApp->focusWidget());
|
|
QTest::keyClick(qApp->focusWidget(), Qt::Key_Enter);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QVERIFY(ti->editorWasTimeEdit);
|
|
disconnect(testWidget,SIGNAL(valueChanged(int,int)),this,SLOT(onValueChanged(int,int)));
|
|
}
|
|
|
|
void tst_Q3Table::numSelections()
|
|
{
|
|
// task 28017
|
|
int numRows = testWidget->numRows();
|
|
int numCols = testWidget->numCols();
|
|
testWidget->setNumRows(10);
|
|
testWidget->setNumCols(10);
|
|
for (int i=0;i<10;++i)
|
|
for (int j=0;j<10;++j)
|
|
testWidget->setItem(i,j,new Q3TableItem(testWidget,Q3TableItem::OnTyping,"Item"));
|
|
QCOMPARE(testWidget->numSelections(),0);
|
|
testWidget->clearSelection();
|
|
QCOMPARE(testWidget->numSelections(),0);
|
|
testWidget->selectRow(2);
|
|
QCOMPARE(testWidget->numSelections(),1);
|
|
testWidget->selectRow(4);
|
|
QCOMPARE(testWidget->numSelections(),2);
|
|
testWidget->selectRow(5);
|
|
QCOMPARE(testWidget->numSelections(),3);
|
|
testWidget->clearSelection();
|
|
QCOMPARE(testWidget->numSelections(),0);
|
|
testWidget->setNumRows(numRows);
|
|
testWidget->setNumCols(numCols);
|
|
}
|
|
|
|
void tst_Q3Table::dateTimeEdit()
|
|
{
|
|
// task 29002
|
|
TimeTableItem *ti = new TimeTableItem(testWidget);
|
|
testWidget->setItem(0, 0, ti);
|
|
testWidget->show();
|
|
QApplication::setActiveWindow(testWidget);
|
|
QTest::qWaitForWindowShown(testWidget);
|
|
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(testWidget));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(testWidget->viewport(), Qt::Key_1);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTRY_VERIFY(qApp->focusWidget());
|
|
QTest::keyClick(qApp->focusWidget(), Qt::Key_Enter);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QVERIFY(ti->editorWasTimeEdit);
|
|
}
|
|
|
|
void tst_Q3Table::moreNumSelections_data()
|
|
{
|
|
QTest::addColumn<Q3Table::SelectionMode>("selectionMode");
|
|
QTest::addColumn<int>("numSelectionsBeforeAnyRowClicked");
|
|
QTest::addColumn<int>("numSelectionsAfter1stRowClicked");
|
|
QTest::addColumn<int>("numSelectionsAfter3rdRowClicked");
|
|
QTest::addColumn<int>("numSelectionsAfter3rdRowClickedAgain");
|
|
|
|
QTest::newRow("NoSelection") << Q3Table::NoSelection << 0 << 0 << 0 << 0;
|
|
QTest::newRow("SingleSelection") << Q3Table::Single << 0 << 1 << 1 << 1;
|
|
QTest::newRow("MultiSelection") << Q3Table::Multi << 0 << 1 << 2 << 2;
|
|
// in row selection modes the current item is always selected
|
|
QTest::newRow("SingleRowSelection") << Q3Table::SingleRow << 1 << 1 << 1 << 1;
|
|
QTest::newRow("MultiRowSelection") << Q3Table::MultiRow << 1 << 1 << 2 << 2;
|
|
}
|
|
|
|
void tst_Q3Table::moreNumSelections()
|
|
{
|
|
#if 0
|
|
QFETCH(Q3Table::SelectionMode, selectionMode);
|
|
QFETCH(int, numSelectionsBeforeAnyRowClicked);
|
|
QFETCH(int, numSelectionsAfter1stRowClicked);
|
|
QFETCH(int, numSelectionsAfter3rdRowClicked);
|
|
QFETCH(int, numSelectionsAfter3rdRowClickedAgain);
|
|
|
|
if((Q3Table::SelectionMode)selectionMode == Q3Table::Multi ||
|
|
(Q3Table::SelectionMode)selectionMode == Q3Table::MultiRow) {
|
|
QSKIP("numSelections() currently fails on all versions", SkipAll);
|
|
}
|
|
|
|
testWidget->setSelectionMode((Q3Table::SelectionMode)selectionMode);
|
|
QCOMPARE(testWidget->numSelections(), numSelectionsBeforeAnyRowClicked);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
|
|
QTest::mouseClick(testWidget->verticalHeader(), QtTestCase::LeftButton, QtTestCase::NoButton,
|
|
QPoint(5, testWidget->verticalHeader()->sectionPos(0)+2));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(testWidget->numSelections(), numSelectionsAfter1stRowClicked);
|
|
|
|
QTest::mouseClick(testWidget->verticalHeader(), QtTestCase::LeftButton, QtTestCase::NoButton,
|
|
QPoint(5, testWidget->verticalHeader()->sectionPos(2)+2));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QEXPECT_FAIL("MultiSelection", "Will not fix this for 3.x", Abort);
|
|
QEXPECT_FAIL("MultiRowSelection", "Will not fix this for 3.x", Abort);
|
|
QCOMPARE(testWidget->numSelections(), numSelectionsAfter3rdRowClicked);
|
|
|
|
QTest::mouseClick(testWidget->verticalHeader(), QtTestCase::LeftButton, QtTestCase::NoButton,
|
|
QPoint(5, testWidget->verticalHeader()->sectionPos(2)+2));
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QCOMPARE(testWidget->numSelections(), numSelectionsAfter3rdRowClickedAgain);
|
|
#else
|
|
QSKIP( "This test is expected to fail on >= 3.2", SkipAll);
|
|
#endif
|
|
}
|
|
|
|
void tst_Q3Table::headerSwapIconset()
|
|
{
|
|
#if 0
|
|
QIconSet is0, is1;
|
|
QString hl0, hl1;
|
|
if (testWidget->horizontalHeader()->iconSet(0))
|
|
is0 = *testWidget->horizontalHeader()->iconSet(0);
|
|
hl0 = testWidget->horizontalHeader()->label(0);
|
|
if (testWidget->horizontalHeader()->iconSet(1))
|
|
is1 = *testWidget->horizontalHeader()->iconSet(1);
|
|
hl1 = testWidget->horizontalHeader()->label(1);
|
|
|
|
testWidget->show();
|
|
testWidget->horizontalHeader()->setLabel(1, QPixmap(fileopen), "Test");
|
|
testWidget->swapColumns(0, 1, true);
|
|
QVERIFY(!testWidget->horizontalHeader()->iconSet(1)
|
|
|| testWidget->horizontalHeader()->iconSet(1)->isNull());
|
|
|
|
testWidget->horizontalHeader()->setLabel(0, is0, hl0);
|
|
testWidget->horizontalHeader()->setLabel(1, is1, hl1);
|
|
#else
|
|
QSKIP( "This test fails in Qt 4", SkipAll);
|
|
#endif
|
|
}
|
|
|
|
|
|
class EscapeKeyDialog : public QDialog
|
|
{
|
|
public:
|
|
EscapeKeyDialog() : QDialog(0), recievedEscape(false) {}
|
|
bool recievedEscape;
|
|
protected:
|
|
void keyPressEvent(QKeyEvent *e)
|
|
{
|
|
if (e->key() == Qt::Key_Escape)
|
|
recievedEscape = TRUE;
|
|
QDialog::keyPressEvent(e);
|
|
}
|
|
};
|
|
|
|
void tst_Q3Table::propagateEscapeKey()
|
|
{
|
|
#if 0
|
|
EscapeKeyDialog ekd;
|
|
Q3Table *table = new Q3Table(5, 5, &ekd);
|
|
ekd.show();
|
|
#ifdef Q_WS_X11
|
|
qt_x11_wait_for_window_manager(&ekd);
|
|
#endif
|
|
table->setCurrentCell(0,0);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(table->viewport(), Qt::Key_A);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QTest::keyClick(table->viewport(), Qt::Key_Escape);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QVERIFY(!ekd.recievedEscape);
|
|
QVERIFY(table->text(0,0).isEmpty());
|
|
QTest::keyClick(table->viewport(), Qt::Key_Escape);
|
|
#ifdef WAITS
|
|
QTest::qWait(50);
|
|
#endif
|
|
QVERIFY(ekd.recievedEscape);
|
|
#else
|
|
QSKIP("This test fails for all versions of Qt", SkipAll);
|
|
#endif
|
|
}
|
|
|
|
void tst_Q3Table::removeSelection_selectionChanged()
|
|
{
|
|
int numRows = testWidget->numRows();
|
|
int numCols = testWidget->numCols();
|
|
testWidget->setNumRows(3);
|
|
testWidget->setNumCols(3);
|
|
Q3TableSelection sel(1, 1, 2, 2);
|
|
testWidget->addSelection(sel);
|
|
QObject::connect(testWidget, SIGNAL(selectionChanged()),
|
|
this, SLOT(selectionWasChanged()));
|
|
receivedSelectionChanged = false;
|
|
testWidget->removeSelection(sel);
|
|
qApp->processEvents();
|
|
QVERIFY(receivedSelectionChanged);
|
|
testWidget->setNumRows(numRows);
|
|
testWidget->setNumCols(numCols);
|
|
QObject::disconnect(testWidget, SIGNAL(selectionChanged()),
|
|
this, SLOT(selectionWasChanged()));
|
|
}
|
|
|
|
void tst_Q3Table::selectionWasChanged()
|
|
{
|
|
receivedSelectionChanged = true;
|
|
}
|
|
|
|
QTEST_MAIN(tst_Q3Table)
|
|
#include "tst_q3table.moc"
|
|
|