2011-04-27 10:05:43 +00:00
|
|
|
/****************************************************************************
|
|
|
|
**
|
|
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
|
** All rights reserved.
|
|
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
|
|
**
|
|
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
|
|
**
|
|
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
|
|
** GNU Lesser General Public License Usage
|
2011-05-24 09:34:08 +00:00
|
|
|
** 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.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
|
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
2011-05-24 09:34:08 +00:00
|
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
2011-04-27 10:05:43 +00:00
|
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
|
|
**
|
2011-05-24 09:34:08 +00:00
|
|
|
** 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.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
2011-05-24 09:34:08 +00:00
|
|
|
** Other Usage
|
|
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
|
|
|
**
|
|
|
|
**
|
|
|
|
**
|
|
|
|
**
|
|
|
|
** $QT_END_LICENSE$
|
|
|
|
**
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
#include <QtTest/QtTest>
|
|
|
|
#include <qdebug.h>
|
|
|
|
#include <qapplication.h>
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
|
|
#ifdef Q_WS_X11
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <qspinbox.h>
|
|
|
|
#include <qlocale.h>
|
|
|
|
#include <qlineedit.h>
|
|
|
|
#include <qlayout.h>
|
|
|
|
#include <QSpinBox>
|
|
|
|
#include <QWidget>
|
|
|
|
#include <QString>
|
|
|
|
#include <QValidator>
|
|
|
|
#include <QLineEdit>
|
|
|
|
#include <QObject>
|
|
|
|
#include <QStringList>
|
|
|
|
#include <QList>
|
|
|
|
#include <QLocale>
|
|
|
|
#include <QDoubleSpinBox>
|
|
|
|
#include <QVBoxLayout>
|
|
|
|
#include <QKeySequence>
|
|
|
|
#include <QStackedWidget>
|
|
|
|
#include <QDebug>
|
|
|
|
#include "../../shared/util.h"
|
|
|
|
|
|
|
|
//TESTED_CLASS=
|
|
|
|
//TESTED_FILES=
|
|
|
|
|
|
|
|
class SpinBox : public QSpinBox
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
SpinBox(QWidget *parent = 0)
|
|
|
|
: QSpinBox(parent)
|
|
|
|
{}
|
|
|
|
QString textFromValue(int v) const
|
|
|
|
{
|
|
|
|
return QSpinBox::textFromValue(v);
|
|
|
|
}
|
|
|
|
QValidator::State validate(QString &text, int &pos) const
|
|
|
|
{
|
|
|
|
return QSpinBox::validate(text, pos);
|
|
|
|
}
|
|
|
|
int valueFromText(const QString &text) const
|
|
|
|
{
|
|
|
|
return QSpinBox::valueFromText(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
QLineEdit *lineEdit() const { return QSpinBox::lineEdit(); }
|
|
|
|
};
|
|
|
|
|
|
|
|
class tst_QSpinBox : public QObject
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
public:
|
|
|
|
tst_QSpinBox();
|
|
|
|
virtual ~tst_QSpinBox();
|
|
|
|
public slots:
|
|
|
|
void initTestCase();
|
|
|
|
void init();
|
|
|
|
void cleanupTestCase();
|
|
|
|
private slots:
|
|
|
|
void getSetCheck();
|
|
|
|
void setValue_data();
|
|
|
|
void setValue();
|
|
|
|
|
|
|
|
void setPrefixSuffix_data();
|
|
|
|
void setPrefixSuffix();
|
|
|
|
|
|
|
|
void setReadOnly();
|
|
|
|
|
|
|
|
void setTracking_data();
|
|
|
|
void setTracking();
|
|
|
|
|
|
|
|
void locale_data();
|
|
|
|
void locale();
|
|
|
|
|
|
|
|
void setWrapping_data();
|
|
|
|
void setWrapping();
|
|
|
|
|
|
|
|
void setSpecialValueText_data();
|
|
|
|
void setSpecialValueText();
|
|
|
|
|
|
|
|
void setSingleStep_data();
|
|
|
|
void setSingleStep();
|
|
|
|
|
|
|
|
void setMinMax_data();
|
|
|
|
void setMinMax();
|
|
|
|
|
|
|
|
void editingFinished();
|
|
|
|
|
|
|
|
void valueFromTextAndValidate_data();
|
|
|
|
void valueFromTextAndValidate();
|
|
|
|
|
|
|
|
void removeAll();
|
|
|
|
void startWithDash();
|
|
|
|
void undoRedo();
|
|
|
|
|
|
|
|
void specialValue();
|
|
|
|
void textFromValue();
|
|
|
|
|
|
|
|
void sizeHint();
|
|
|
|
|
|
|
|
void taskQTBUG_5008_textFromValueAndValidate();
|
|
|
|
|
|
|
|
public slots:
|
|
|
|
void valueChangedHelper(const QString &);
|
|
|
|
void valueChangedHelper(int);
|
|
|
|
private:
|
|
|
|
QStringList actualTexts;
|
|
|
|
QList<int> actualValues;
|
|
|
|
QWidget *testFocusWidget;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef QList<int> IntList;
|
|
|
|
Q_DECLARE_METATYPE(IntList)
|
|
|
|
Q_DECLARE_METATYPE(QLocale)
|
|
|
|
|
|
|
|
// Testing get/set functions
|
|
|
|
void tst_QSpinBox::getSetCheck()
|
|
|
|
{
|
|
|
|
QSpinBox obj1;
|
|
|
|
// int QSpinBox::singleStep()
|
|
|
|
// void QSpinBox::setSingleStep(int)
|
|
|
|
obj1.setSingleStep(0);
|
|
|
|
QCOMPARE(0, obj1.singleStep());
|
|
|
|
obj1.setSingleStep(INT_MIN);
|
|
|
|
QCOMPARE(0, obj1.singleStep()); // Can't have negative steps => keep old value
|
|
|
|
obj1.setSingleStep(INT_MAX);
|
|
|
|
QCOMPARE(INT_MAX, obj1.singleStep());
|
|
|
|
|
|
|
|
// int QSpinBox::minimum()
|
|
|
|
// void QSpinBox::setMinimum(int)
|
|
|
|
obj1.setMinimum(0);
|
|
|
|
QCOMPARE(0, obj1.minimum());
|
|
|
|
obj1.setMinimum(INT_MIN);
|
|
|
|
QCOMPARE(INT_MIN, obj1.minimum());
|
|
|
|
obj1.setMinimum(INT_MAX);
|
|
|
|
QCOMPARE(INT_MAX, obj1.minimum());
|
|
|
|
|
|
|
|
// int QSpinBox::maximum()
|
|
|
|
// void QSpinBox::setMaximum(int)
|
|
|
|
obj1.setMaximum(0);
|
|
|
|
QCOMPARE(0, obj1.maximum());
|
|
|
|
obj1.setMaximum(INT_MIN);
|
|
|
|
QCOMPARE(INT_MIN, obj1.maximum());
|
|
|
|
obj1.setMaximum(INT_MAX);
|
|
|
|
QCOMPARE(INT_MAX, obj1.maximum());
|
|
|
|
|
|
|
|
// int QSpinBox::value()
|
|
|
|
// void QSpinBox::setValue(int)
|
|
|
|
obj1.setValue(0);
|
|
|
|
QCOMPARE(0, obj1.value());
|
|
|
|
obj1.setValue(INT_MIN);
|
|
|
|
QCOMPARE(INT_MIN, obj1.value());
|
|
|
|
obj1.setValue(INT_MAX);
|
|
|
|
QCOMPARE(INT_MAX, obj1.value());
|
|
|
|
|
|
|
|
QDoubleSpinBox obj2;
|
|
|
|
// double QDoubleSpinBox::singleStep()
|
|
|
|
// void QDoubleSpinBox::setSingleStep(double)
|
|
|
|
obj2.setSingleStep(0.0);
|
|
|
|
QCOMPARE(0.0, obj2.singleStep());
|
|
|
|
obj2.setSingleStep(1.0);
|
|
|
|
QCOMPARE(1.0, obj2.singleStep());
|
|
|
|
|
|
|
|
// double QDoubleSpinBox::minimum()
|
|
|
|
// void QDoubleSpinBox::setMinimum(double)
|
|
|
|
obj2.setMinimum(1.0);
|
|
|
|
QCOMPARE(1.0, obj2.minimum());
|
|
|
|
obj2.setMinimum(0.0);
|
|
|
|
QCOMPARE(0.0, obj2.minimum());
|
|
|
|
obj2.setMinimum(-1.0);
|
|
|
|
QCOMPARE(-1.0, obj2.minimum());
|
|
|
|
|
|
|
|
// double QDoubleSpinBox::maximum()
|
|
|
|
// void QDoubleSpinBox::setMaximum(double)
|
|
|
|
obj2.setMaximum(-1.0);
|
|
|
|
QCOMPARE(-1.0, obj2.maximum());
|
|
|
|
obj2.setMaximum(0.0);
|
|
|
|
QCOMPARE(0.0, obj2.maximum());
|
|
|
|
obj2.setMaximum(1.0);
|
|
|
|
QCOMPARE(1.0, obj2.maximum());
|
|
|
|
|
|
|
|
// int QDoubleSpinBox::decimals()
|
|
|
|
// void QDoubleSpinBox::setDecimals(int)
|
|
|
|
obj2.setDecimals(0);
|
|
|
|
QCOMPARE(0, obj2.decimals());
|
|
|
|
obj2.setDecimals(INT_MIN);
|
|
|
|
QCOMPARE(0, obj2.decimals()); // Range<0, 13>
|
|
|
|
|
|
|
|
//obj2.setDecimals(INT_MAX);
|
|
|
|
//QCOMPARE(13, obj2.decimals()); // Range<0, 13>
|
|
|
|
obj2.setDecimals(128);
|
|
|
|
QCOMPARE(obj2.decimals(), 128); // Range<0, 128>
|
|
|
|
|
|
|
|
// double QDoubleSpinBox::value()
|
|
|
|
// void QDoubleSpinBox::setValue(double)
|
|
|
|
obj2.setValue(-1.0);
|
|
|
|
QCOMPARE(-1.0, obj2.value());
|
|
|
|
obj2.setValue(0.0);
|
|
|
|
QCOMPARE(0.0, obj2.value());
|
|
|
|
obj2.setValue(1.0);
|
|
|
|
QCOMPARE(1.0, obj2.value());
|
|
|
|
|
|
|
|
// Make sure we update line edit geometry when updating
|
|
|
|
// buttons - see task 235747
|
|
|
|
QRect oldEditGeometry = obj1.childrenRect();
|
|
|
|
obj1.setButtonSymbols(QAbstractSpinBox::NoButtons);
|
|
|
|
QVERIFY(obj1.childrenRect() != oldEditGeometry);
|
|
|
|
}
|
|
|
|
|
|
|
|
tst_QSpinBox::tst_QSpinBox()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
tst_QSpinBox::~tst_QSpinBox()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::initTestCase()
|
|
|
|
{
|
|
|
|
testFocusWidget = new QWidget(0);
|
|
|
|
testFocusWidget->resize(200, 100);
|
|
|
|
testFocusWidget->show();
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::init()
|
|
|
|
{
|
|
|
|
QLocale::setDefault(QLocale(QLocale::C));
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::cleanupTestCase()
|
|
|
|
{
|
|
|
|
delete testFocusWidget;
|
|
|
|
testFocusWidget = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setValue_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<int>("set");
|
|
|
|
QTest::addColumn<int>("expected");
|
|
|
|
|
|
|
|
QTest::newRow("data0") << 0 << 0;
|
|
|
|
QTest::newRow("data1") << 100 << 100;
|
|
|
|
QTest::newRow("data2") << -100 << -100;
|
|
|
|
QTest::newRow("data3") << INT_MIN << INT_MIN;
|
|
|
|
QTest::newRow("data4") << INT_MAX << INT_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setValue()
|
|
|
|
{
|
|
|
|
QFETCH(int, set);
|
|
|
|
QFETCH(int, expected);
|
|
|
|
QSpinBox spin(0);
|
|
|
|
spin.setRange(INT_MIN, INT_MAX);
|
|
|
|
spin.setValue(set);
|
|
|
|
QCOMPARE(spin.value(), expected);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setPrefixSuffix_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<QString>("prefix");
|
|
|
|
QTest::addColumn<QString>("suffix");
|
|
|
|
QTest::addColumn<int>("value");
|
|
|
|
QTest::addColumn<QString>("expectedText");
|
|
|
|
QTest::addColumn<QString>("expectedCleanText");
|
|
|
|
QTest::addColumn<bool>("show");
|
|
|
|
|
|
|
|
QTest::newRow("data0") << QString() << QString() << 10 << "10" << "10" << false;
|
|
|
|
QTest::newRow("data1") << QString() << "cm" << 10 << "10cm" << "10" << false;
|
|
|
|
QTest::newRow("data2") << "cm: " << QString() << 10 << "cm: 10" << "10" << false;
|
|
|
|
QTest::newRow("data3") << "length: " << "cm" << 10 << "length: 10cm" << "10" << false;
|
|
|
|
|
|
|
|
QTest::newRow("data4") << QString() << QString() << 10 << "10" << "10" << true;
|
|
|
|
QTest::newRow("data5") << QString() << "cm" << 10 << "10cm" << "10" << true;
|
|
|
|
QTest::newRow("data6") << "cm: " << QString() << 10 << "cm: 10" << "10" << true;
|
|
|
|
QTest::newRow("data7") << "length: " << "cm" << 10 << "length: 10cm" << "10" << true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setPrefixSuffix()
|
|
|
|
{
|
|
|
|
QFETCH(QString, prefix);
|
|
|
|
QFETCH(QString, suffix);
|
|
|
|
QFETCH(int, value);
|
|
|
|
QFETCH(QString, expectedText);
|
|
|
|
QFETCH(QString, expectedCleanText);
|
|
|
|
QFETCH(bool, show);
|
|
|
|
|
|
|
|
QSpinBox spin(0);
|
|
|
|
spin.setPrefix(prefix);
|
|
|
|
spin.setSuffix(suffix);
|
|
|
|
spin.setValue(value);
|
|
|
|
if (show)
|
|
|
|
spin.show();
|
|
|
|
|
|
|
|
QCOMPARE(spin.prefix(), prefix);
|
|
|
|
QCOMPARE(spin.suffix(), suffix);
|
|
|
|
QCOMPARE(spin.text(), expectedText);
|
|
|
|
QCOMPARE(spin.cleanText(), expectedCleanText);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::valueChangedHelper(const QString &text)
|
|
|
|
{
|
|
|
|
actualTexts << text;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::valueChangedHelper(int value)
|
|
|
|
{
|
|
|
|
actualValues << value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setReadOnly()
|
|
|
|
{
|
|
|
|
QSpinBox spin(0);
|
|
|
|
spin.show();
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Up);
|
|
|
|
QCOMPARE(spin.value(), 1);
|
|
|
|
spin.setReadOnly(true);
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Up);
|
|
|
|
QCOMPARE(spin.value(), 1);
|
|
|
|
spin.stepBy(1);
|
|
|
|
QCOMPARE(spin.value(), 2);
|
|
|
|
spin.setReadOnly(false);
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Up);
|
|
|
|
QCOMPARE(spin.value(), 3);
|
|
|
|
}
|
|
|
|
void tst_QSpinBox::setTracking_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<QTestEventList>("keys");
|
|
|
|
QTest::addColumn<QStringList>("texts");
|
|
|
|
QTest::addColumn<bool>("tracking");
|
|
|
|
|
|
|
|
QTestEventList keys;
|
|
|
|
QStringList texts1;
|
|
|
|
QStringList texts2;
|
|
|
|
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
keys.addKeyClick(Qt::Key_Right, Qt::ControlModifier);
|
|
|
|
#else
|
|
|
|
keys.addKeyClick(Qt::Key_End);
|
|
|
|
#endif
|
|
|
|
keys.addKeyClick('7');
|
|
|
|
keys.addKeyClick('9');
|
|
|
|
keys.addKeyClick(Qt::Key_Enter);
|
|
|
|
keys.addKeyClick(Qt::Key_Enter);
|
|
|
|
keys.addKeyClick(Qt::Key_Enter);
|
|
|
|
texts1 << "07" << "079" << "79" << "79" << "79";
|
|
|
|
texts2 << "79";
|
|
|
|
QTest::newRow("data1") << keys << texts1 << true;
|
|
|
|
QTest::newRow("data2") << keys << texts2 << false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setTracking()
|
|
|
|
{
|
|
|
|
actualTexts.clear();
|
|
|
|
QFETCH(QTestEventList, keys);
|
|
|
|
QFETCH(QStringList, texts);
|
|
|
|
QFETCH(bool, tracking);
|
|
|
|
|
|
|
|
QSpinBox spin(0);
|
|
|
|
spin.setKeyboardTracking(tracking);
|
|
|
|
spin.show();
|
|
|
|
connect(&spin, SIGNAL(valueChanged(QString)), this, SLOT(valueChangedHelper(const QString &)));
|
|
|
|
|
|
|
|
keys.simulate(&spin);
|
|
|
|
QCOMPARE(actualTexts, texts);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setWrapping_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<bool>("wrapping");
|
|
|
|
QTest::addColumn<int>("minimum");
|
|
|
|
QTest::addColumn<int>("maximum");
|
|
|
|
QTest::addColumn<int>("startValue");
|
|
|
|
QTest::addColumn<QTestEventList>("keys");
|
|
|
|
QTest::addColumn<IntList>("expected");
|
|
|
|
|
|
|
|
QTestEventList keys;
|
|
|
|
IntList values;
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
values << 10;
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
QTest::newRow("data0") << false << 0 << 10 << 9 << keys << values;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
values << 10;
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
values << 0;
|
|
|
|
QTest::newRow("data1") << true << 0 << 10 << 9 << keys << values;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_Delete); // doesn't emit because lineedit is empty so intermediate
|
|
|
|
keys.addKeyClick('1');
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
values << 1 << 0;
|
|
|
|
QTest::newRow("data2") << false << 0 << 10 << 9 << keys << values;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_Delete);
|
|
|
|
keys.addKeyClick('1');
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
values << 1 << 0 << 10;
|
|
|
|
QTest::newRow("data3") << true << 0 << 10 << 9 << keys << values;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
values << 0;
|
|
|
|
QTest::newRow("data4") << false << 0 << 10 << 6 << keys << values;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
values << 0 << 10;
|
|
|
|
QTest::newRow("data5") << true << 0 << 10 << 6 << keys << values;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_PageUp);
|
|
|
|
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
|
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
|
values << 10 << 0 << 10 << 0 << 10 << 0;
|
|
|
|
QTest::newRow("data6") << true << 0 << 10 << 6 << keys << values;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void tst_QSpinBox::setWrapping()
|
|
|
|
{
|
|
|
|
QFETCH(bool, wrapping);
|
|
|
|
QFETCH(int, minimum);
|
|
|
|
QFETCH(int, maximum);
|
|
|
|
QFETCH(int, startValue);
|
|
|
|
QFETCH(QTestEventList, keys);
|
|
|
|
QFETCH(IntList, expected);
|
|
|
|
|
|
|
|
QSpinBox spin(0);
|
|
|
|
QVERIFY(!spin.wrapping());
|
|
|
|
spin.setMinimum(minimum);
|
|
|
|
spin.setMaximum(maximum);
|
|
|
|
spin.setValue(startValue);
|
|
|
|
spin.setWrapping(wrapping);
|
|
|
|
spin.show();
|
|
|
|
actualValues.clear();
|
|
|
|
connect(&spin, SIGNAL(valueChanged(int)), this, SLOT(valueChangedHelper(int)));
|
|
|
|
|
|
|
|
keys.simulate(&spin);
|
|
|
|
|
|
|
|
QCOMPARE(actualValues.size(), expected.size());
|
|
|
|
for (int i=0; i<qMin(actualValues.size(), expected.size()); ++i) {
|
|
|
|
QCOMPARE(actualValues.at(i), expected.at(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setSpecialValueText_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<QString>("specialValueText");
|
|
|
|
QTest::addColumn<int>("minimum");
|
|
|
|
QTest::addColumn<int>("maximum");
|
|
|
|
QTest::addColumn<int>("value");
|
|
|
|
QTest::addColumn<QString>("expected");
|
|
|
|
QTest::addColumn<bool>("show");
|
|
|
|
|
|
|
|
QTest::newRow("data0") << QString() << 0 << 10 << 1 << "1" << false;
|
|
|
|
QTest::newRow("data1") << QString() << 0 << 10 << 1 << "1" << true;
|
|
|
|
QTest::newRow("data2") << "foo" << 0 << 10 << 0 << "foo" << false;
|
|
|
|
QTest::newRow("data3") << "foo" << 0 << 10 << 0 << "foo" << true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setSpecialValueText()
|
|
|
|
{
|
|
|
|
QFETCH(QString, specialValueText);
|
|
|
|
QFETCH(int, minimum);
|
|
|
|
QFETCH(int, maximum);
|
|
|
|
QFETCH(int, value);
|
|
|
|
QFETCH(QString, expected);
|
|
|
|
QFETCH(bool, show);
|
|
|
|
|
|
|
|
QSpinBox spin(0);
|
|
|
|
spin.setSpecialValueText(specialValueText);
|
|
|
|
QCOMPARE(spin.specialValueText(), specialValueText);
|
|
|
|
spin.setMinimum(minimum);
|
|
|
|
spin.setMaximum(maximum);
|
|
|
|
spin.setValue(value);
|
|
|
|
if (show)
|
|
|
|
spin.show();
|
|
|
|
|
|
|
|
QCOMPARE(spin.text(), expected);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setSingleStep_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<int>("singleStep");
|
|
|
|
QTest::addColumn<int>("startValue");
|
|
|
|
QTest::addColumn<QTestEventList>("keys");
|
|
|
|
QTest::addColumn<IntList>("expected");
|
|
|
|
QTest::addColumn<bool>("show");
|
|
|
|
|
|
|
|
QTestEventList keys;
|
|
|
|
IntList values;
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
values << 11 << 10 << 11;
|
|
|
|
QTest::newRow("data0") << 1 << 10 << keys << values << false;
|
|
|
|
QTest::newRow("data1") << 1 << 10 << keys << values << true;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
values.clear();
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_Down);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
values << 12 << 10 << 12;
|
|
|
|
QTest::newRow("data2") << 2 << 10 << keys << values << false;
|
|
|
|
QTest::newRow("data3") << 2 << 10 << keys << values << true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setSingleStep()
|
|
|
|
{
|
|
|
|
QFETCH(int, singleStep);
|
|
|
|
QFETCH(int, startValue);
|
|
|
|
QFETCH(QTestEventList, keys);
|
|
|
|
QFETCH(IntList, expected);
|
|
|
|
QFETCH(bool, show);
|
|
|
|
|
|
|
|
QSpinBox spin(0);
|
|
|
|
actualValues.clear();
|
|
|
|
spin.setSingleStep(singleStep);
|
|
|
|
QCOMPARE(spin.singleStep(), singleStep);
|
|
|
|
spin.setValue(startValue);
|
|
|
|
if (show)
|
|
|
|
spin.show();
|
|
|
|
connect(&spin, SIGNAL(valueChanged(int)), this, SLOT(valueChangedHelper(int)));
|
|
|
|
|
|
|
|
QCOMPARE(actualValues.size(), 0);
|
|
|
|
keys.simulate(&spin);
|
|
|
|
QCOMPARE(actualValues.size(), expected.size());
|
|
|
|
for (int i=0; i<qMin(actualValues.size(), expected.size()); ++i) {
|
|
|
|
QCOMPARE(actualValues.at(i), expected.at(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setMinMax_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<int>("startValue");
|
|
|
|
QTest::addColumn<int>("mini");
|
|
|
|
QTest::addColumn<int>("maxi");
|
|
|
|
QTest::addColumn<QTestEventList>("keys");
|
|
|
|
QTest::addColumn<int>("expected");
|
|
|
|
QTest::addColumn<bool>("show");
|
|
|
|
|
|
|
|
QTestEventList keys;
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
keys.addKeyClick(Qt::Key_Up);
|
|
|
|
QTest::newRow("data0") << 1 << INT_MIN << 2 << keys << 2 << false;
|
|
|
|
QTest::newRow("data1") << 1 << INT_MIN << 2 << keys << 2 << true;
|
|
|
|
|
|
|
|
keys.clear();
|
|
|
|
QTest::newRow("data2") << 2 << INT_MAX - 2 << INT_MAX << keys << INT_MAX - 2 << false;
|
|
|
|
QTest::newRow("data3") << 2 << INT_MAX - 2 << INT_MAX << keys << INT_MAX - 2 << true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::setMinMax()
|
|
|
|
{
|
|
|
|
QFETCH(int, startValue);
|
|
|
|
QFETCH(int, mini);
|
|
|
|
QFETCH(int, maxi);
|
|
|
|
QFETCH(QTestEventList, keys);
|
|
|
|
QFETCH(int, expected);
|
|
|
|
QFETCH(bool, show);
|
|
|
|
|
|
|
|
QSpinBox spin(0);
|
|
|
|
spin.setValue(startValue);
|
|
|
|
spin.setMinimum(mini);
|
|
|
|
spin.setMaximum(maxi);
|
|
|
|
QCOMPARE(spin.minimum(), mini);
|
|
|
|
QCOMPARE(spin.maximum(), maxi);
|
|
|
|
if (show)
|
|
|
|
spin.show();
|
|
|
|
keys.simulate(&spin);
|
|
|
|
QCOMPARE(spin.value(), expected);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::valueFromTextAndValidate_data()
|
|
|
|
{
|
|
|
|
const int Intermediate = QValidator::Intermediate;
|
|
|
|
const int Invalid = QValidator::Invalid;
|
|
|
|
const int Acceptable = QValidator::Acceptable;
|
|
|
|
|
|
|
|
QTest::addColumn<QString>("txt");
|
|
|
|
QTest::addColumn<int>("state");
|
|
|
|
QTest::addColumn<int>("mini");
|
|
|
|
QTest::addColumn<int>("maxi");
|
|
|
|
QTest::addColumn<QString>("expectedText"); // if empty we don't check
|
|
|
|
|
|
|
|
QTest::newRow("data0") << QString("2") << Intermediate << 3 << 5 << QString();
|
|
|
|
QTest::newRow("data1") << QString() << Intermediate << 0 << 100 << QString();
|
|
|
|
QTest::newRow("data2") << QString("asd") << Invalid << 0 << 100 << QString();
|
|
|
|
QTest::newRow("data3") << QString("2") << Acceptable << 0 << 100 << QString();
|
|
|
|
QTest::newRow("data4") << QString() << Intermediate << 0 << 1 << QString();
|
|
|
|
QTest::newRow("data5") << QString() << Invalid << 0 << 0 << QString();
|
|
|
|
QTest::newRow("data5") << QString("5") << Intermediate << 2004 << 2005 << QString();
|
|
|
|
QTest::newRow("data6") << QString("50") << Intermediate << 2004 << 2005 << QString();
|
|
|
|
QTest::newRow("data7") << QString("205") << Intermediate << 2004 << 2005 << QString();
|
|
|
|
QTest::newRow("data8") << QString("2005") << Acceptable << 2004 << 2005 << QString();
|
|
|
|
QTest::newRow("data9") << QString("3") << Intermediate << 2004 << 2005 << QString();
|
|
|
|
QTest::newRow("data10") << QString("-") << Intermediate << -20 << -10 << QString();
|
|
|
|
QTest::newRow("data11") << QString("-1") << Intermediate << -20 << -10 << QString();
|
|
|
|
QTest::newRow("data12") << QString("-5") << Intermediate << -20 << -10 << QString();
|
|
|
|
QTest::newRow("data13") << QString("-5") << Intermediate << -20 << -16 << QString();
|
|
|
|
QTest::newRow("data14") << QString("-2") << Intermediate << -20 << -16 << QString();
|
|
|
|
QTest::newRow("data15") << QString("2") << Invalid << -20 << -16 << QString();
|
|
|
|
QTest::newRow("data16") << QString() << Intermediate << -20 << -16 << QString();
|
|
|
|
QTest::newRow("data17") << QString(" 22") << Acceptable << 0 << 1000 << QString("22");
|
|
|
|
QTest::newRow("data18") << QString("22 ") << Acceptable << 0 << 1000 << QString("22");
|
|
|
|
QTest::newRow("data19") << QString(" 22 ") << Acceptable << 0 << 1000 << QString("22");
|
|
|
|
QTest::newRow("data20") << QString("2 2") << Invalid << 0 << 1000 << QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
static QString stateName(int state)
|
|
|
|
{
|
|
|
|
switch (state) {
|
|
|
|
case QValidator::Acceptable: return QString("Acceptable");
|
|
|
|
case QValidator::Intermediate: return QString("Intermediate");
|
|
|
|
case QValidator::Invalid: return QString("Invalid");
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
qWarning("%s %d: this should never happen", __FILE__, __LINE__);
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::valueFromTextAndValidate()
|
|
|
|
{
|
|
|
|
QFETCH(QString, txt);
|
|
|
|
QFETCH(int, state);
|
|
|
|
QFETCH(int, mini);
|
|
|
|
QFETCH(int, maxi);
|
|
|
|
QFETCH(QString, expectedText);
|
|
|
|
|
|
|
|
SpinBox sb(0);
|
|
|
|
sb.show();
|
|
|
|
sb.setRange(mini, maxi);
|
|
|
|
int unused = 0;
|
|
|
|
QCOMPARE(stateName(sb.validate(txt, unused)), stateName(state));
|
|
|
|
if (!expectedText.isEmpty())
|
|
|
|
QCOMPARE(txt, expectedText);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::locale_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<QLocale>("loc");
|
|
|
|
QTest::addColumn<int>("value");
|
|
|
|
QTest::addColumn<QString>("textFromVal");
|
|
|
|
QTest::addColumn<QString>("text");
|
|
|
|
QTest::addColumn<int>("valFromText");
|
|
|
|
|
|
|
|
QTest::newRow("data0") << QLocale(QLocale::Norwegian, QLocale::Norway) << 1234 << QString("1234") << QString("2345") << 2345;
|
|
|
|
QTest::newRow("data1") << QLocale(QLocale::German, QLocale::Germany) << 1234 << QString("1234") << QString("2345") << 2345;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::locale()
|
|
|
|
{
|
|
|
|
QFETCH(QLocale, loc);
|
|
|
|
QFETCH(int, value);
|
|
|
|
QFETCH(QString, textFromVal);
|
|
|
|
QFETCH(QString, text);
|
|
|
|
QFETCH(int, valFromText);
|
|
|
|
|
|
|
|
QLocale old;
|
|
|
|
|
|
|
|
QLocale::setDefault(loc);
|
|
|
|
SpinBox box;
|
|
|
|
box.setMaximum(100000);
|
|
|
|
box.setValue(value);
|
|
|
|
QCOMPARE(box.cleanText(), textFromVal);
|
|
|
|
|
|
|
|
box.lineEdit()->setText(text);
|
|
|
|
QCOMPARE(box.cleanText(), text);
|
|
|
|
box.interpretText();
|
|
|
|
|
|
|
|
QCOMPARE(box.value(), valFromText);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void tst_QSpinBox::editingFinished()
|
|
|
|
{
|
|
|
|
QVBoxLayout *layout = new QVBoxLayout(testFocusWidget);
|
|
|
|
QSpinBox *box = new QSpinBox(testFocusWidget);
|
|
|
|
layout->addWidget(box);
|
|
|
|
QSpinBox *box2 = new QSpinBox(testFocusWidget);
|
|
|
|
layout->addWidget(box2);
|
|
|
|
|
|
|
|
testFocusWidget->show();
|
|
|
|
QApplication::setActiveWindow(testFocusWidget);
|
|
|
|
QTest::qWaitForWindowShown(testFocusWidget);
|
|
|
|
box->activateWindow();
|
|
|
|
box->setFocus();
|
|
|
|
|
|
|
|
QTRY_COMPARE(qApp->focusWidget(), (QWidget *)box);
|
|
|
|
|
|
|
|
QSignalSpy editingFinishedSpy1(box, SIGNAL(editingFinished()));
|
|
|
|
QSignalSpy editingFinishedSpy2(box2, SIGNAL(editingFinished()));
|
|
|
|
|
|
|
|
box->setFocus();
|
|
|
|
QTest::keyClick(box, Qt::Key_Up);
|
|
|
|
QTest::keyClick(box, Qt::Key_Up);
|
|
|
|
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 0);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 0);
|
|
|
|
|
|
|
|
QTest::keyClick(box2, Qt::Key_Up);
|
|
|
|
QTest::keyClick(box2, Qt::Key_Up);
|
|
|
|
box2->setFocus();
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
|
box->setFocus();
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
|
QTest::keyClick(box, Qt::Key_Up);
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
|
QTest::keyClick(box, Qt::Key_Enter);
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 2);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
|
QTest::keyClick(box, Qt::Key_Return);
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 3);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
|
box2->setFocus();
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
|
QTest::keyClick(box2, Qt::Key_Enter);
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 2);
|
|
|
|
QTest::keyClick(box2, Qt::Key_Return);
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 3);
|
|
|
|
|
|
|
|
testFocusWidget->hide();
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
|
QCOMPARE(editingFinishedSpy2.count(), 4);
|
|
|
|
QTest::qWait(100);
|
|
|
|
|
|
|
|
//task203285
|
|
|
|
editingFinishedSpy1.clear();
|
|
|
|
testFocusWidget->show();
|
|
|
|
QTest::qWait(100);
|
|
|
|
box->setKeyboardTracking(false);
|
|
|
|
qApp->setActiveWindow(testFocusWidget);
|
|
|
|
testFocusWidget->activateWindow();
|
|
|
|
box->setFocus();
|
|
|
|
QTRY_VERIFY(box->hasFocus());
|
|
|
|
box->setValue(0);
|
|
|
|
QTest::keyClick(box, '2');
|
|
|
|
QCOMPARE(box->text(), QLatin1String("20"));
|
|
|
|
box2->setFocus();
|
|
|
|
QTRY_VERIFY(qApp->focusWidget() != box);
|
|
|
|
QCOMPARE(box->text(), QLatin1String("20"));
|
|
|
|
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
|
|
|
|
|
testFocusWidget->hide();
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::removeAll()
|
|
|
|
{
|
|
|
|
SpinBox spin(0);
|
|
|
|
spin.setPrefix("foo");
|
|
|
|
spin.setSuffix("bar");
|
|
|
|
spin.setValue(2);
|
|
|
|
spin.show();
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Left, Qt::ControlModifier);
|
|
|
|
#else
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Home);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Right, Qt::ControlModifier|Qt::ShiftModifier);
|
|
|
|
#else
|
|
|
|
QTest::keyClick(&spin, Qt::Key_End, Qt::ShiftModifier);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
QCOMPARE(spin.lineEdit()->selectedText(), QString("foo2bar"));
|
|
|
|
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
|
QCOMPARE(spin.text(), QString("foo1bar"));
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::startWithDash()
|
|
|
|
{
|
|
|
|
SpinBox spin(0);
|
|
|
|
spin.show();
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Left, Qt::ControlModifier);
|
|
|
|
#else
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Home);
|
|
|
|
#endif
|
|
|
|
QCOMPARE(spin.text(), QString("0"));
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Minus);
|
|
|
|
QCOMPARE(spin.text(), QString("0"));
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::undoRedo()
|
|
|
|
{
|
|
|
|
//test undo/redo feature (in conjunction with the "undoRedoEnabled" property)
|
|
|
|
SpinBox spin(0);
|
|
|
|
spin.show();
|
|
|
|
|
|
|
|
//the undo/redo is disabled by default
|
|
|
|
|
|
|
|
QCOMPARE(spin.value(), 0); //this is the default value
|
|
|
|
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
|
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
|
|
|
|
|
spin.lineEdit()->selectAll(); //ensures everything is selected and will be cleared by typing a key
|
|
|
|
QTest::keyClick(&spin, Qt::Key_1); //we put 1 into the spinbox
|
|
|
|
QCOMPARE(spin.value(), 1);
|
|
|
|
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
|
|
|
|
|
//testing CTRL+Z (undo)
|
|
|
|
int val = QKeySequence(QKeySequence::Undo)[0];
|
|
|
|
Qt::KeyboardModifiers mods = (Qt::KeyboardModifiers)(val & Qt::KeyboardModifierMask);
|
|
|
|
QTest::keyClick(&spin, val & ~mods, mods);
|
|
|
|
|
|
|
|
QCOMPARE(spin.value(), 0);
|
|
|
|
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
|
QVERIFY(spin.lineEdit()->isRedoAvailable());
|
|
|
|
|
|
|
|
//testing CTRL+Y (redo)
|
|
|
|
val = QKeySequence(QKeySequence::Redo)[0];
|
|
|
|
mods = (Qt::KeyboardModifiers)(val & Qt::KeyboardModifierMask);
|
|
|
|
QTest::keyClick(&spin, val & ~mods, mods);
|
|
|
|
QCOMPARE(spin.value(), 1);
|
|
|
|
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
|
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
|
|
|
|
|
spin.setValue(55);
|
|
|
|
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
|
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
|
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Return);
|
|
|
|
QTest::keyClick(&spin, '1');
|
|
|
|
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
|
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
|
spin.lineEdit()->undo();
|
|
|
|
QCOMPARE(spin.value(), 55);
|
|
|
|
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
|
QVERIFY(spin.lineEdit()->isRedoAvailable());
|
|
|
|
spin.lineEdit()->redo();
|
|
|
|
QCOMPARE(spin.value(), 1);
|
|
|
|
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
|
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::specialValue()
|
|
|
|
{
|
|
|
|
QString specialText="foo";
|
|
|
|
|
|
|
|
QWidget topWidget;
|
|
|
|
QVBoxLayout layout(&topWidget);
|
|
|
|
SpinBox spin(&topWidget);
|
|
|
|
layout.addWidget(&spin);
|
|
|
|
SpinBox box2(&topWidget);
|
|
|
|
layout.addWidget(&box2);
|
|
|
|
|
|
|
|
spin.setSpecialValueText(specialText);
|
|
|
|
spin.setMinimum(0);
|
|
|
|
spin.setMaximum(100);
|
|
|
|
spin.setValue(50);
|
|
|
|
topWidget.show();
|
|
|
|
#ifdef Q_WS_X11
|
|
|
|
qt_x11_wait_for_window_manager(&topWidget);
|
|
|
|
#endif
|
|
|
|
QTest::qWait(100);
|
|
|
|
//make sure we have the focus (even if editingFinished fails)
|
|
|
|
qApp->setActiveWindow(&topWidget);
|
|
|
|
topWidget.activateWindow();
|
|
|
|
spin.setFocus();
|
|
|
|
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Return);
|
|
|
|
QTest::keyClick(&spin, '0');
|
|
|
|
QCOMPARE(spin.text(), QString("0"));
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Return);
|
|
|
|
QCOMPARE(spin.text(), specialText);
|
|
|
|
|
|
|
|
spin.setValue(50);
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Return);
|
|
|
|
QTest::keyClick(&spin, '0');
|
|
|
|
QCOMPARE(spin.text(), QString("0"));
|
|
|
|
QTest::keyClick(spin.lineEdit(), Qt::Key_Tab);
|
|
|
|
QCOMPARE(spin.text(), specialText);
|
|
|
|
|
|
|
|
spin.setValue(50);
|
|
|
|
spin.setFocus();
|
|
|
|
QTest::keyClick(&spin, Qt::Key_Return);
|
|
|
|
QTest::keyClick(&spin, '0');
|
|
|
|
QCOMPARE(spin.text(), QString("0"));
|
|
|
|
box2.setFocus();
|
|
|
|
QCOMPARE(spin.text(), specialText);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::textFromValue()
|
|
|
|
{
|
|
|
|
SpinBox spinBox;
|
|
|
|
QCOMPARE(spinBox.textFromValue(INT_MIN), QString::number(INT_MIN));
|
|
|
|
}
|
|
|
|
|
|
|
|
class sizeHint_SpinBox : public QSpinBox
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
QSize sizeHint() const
|
|
|
|
{
|
|
|
|
++sizeHintRequests;
|
|
|
|
return QSpinBox::sizeHint();
|
|
|
|
}
|
|
|
|
mutable int sizeHintRequests;
|
|
|
|
};
|
|
|
|
|
|
|
|
void tst_QSpinBox::sizeHint()
|
|
|
|
{
|
|
|
|
QWidget *widget = new QWidget;
|
|
|
|
QHBoxLayout *layout = new QHBoxLayout(widget);
|
|
|
|
sizeHint_SpinBox *spinBox = new sizeHint_SpinBox;
|
|
|
|
layout->addWidget(spinBox);
|
|
|
|
widget->show();
|
|
|
|
QTest::qWaitForWindowShown(widget);
|
|
|
|
|
|
|
|
// Prefix
|
|
|
|
spinBox->sizeHintRequests = 0;
|
|
|
|
spinBox->setPrefix(QLatin1String("abcdefghij"));
|
|
|
|
qApp->processEvents();
|
|
|
|
QTRY_VERIFY(spinBox->sizeHintRequests > 0);
|
|
|
|
|
|
|
|
// Suffix
|
|
|
|
spinBox->sizeHintRequests = 0;
|
|
|
|
spinBox->setSuffix(QLatin1String("abcdefghij"));
|
|
|
|
qApp->processEvents();
|
|
|
|
QTRY_VERIFY(spinBox->sizeHintRequests > 0);
|
|
|
|
|
|
|
|
// Range
|
|
|
|
spinBox->sizeHintRequests = 0;
|
|
|
|
spinBox->setRange(0, 1234567890);
|
|
|
|
spinBox->setValue(spinBox->maximum());
|
|
|
|
qApp->processEvents();
|
|
|
|
QTRY_VERIFY(spinBox->sizeHintRequests > 0);
|
|
|
|
|
|
|
|
delete widget;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_QSpinBox::taskQTBUG_5008_textFromValueAndValidate()
|
|
|
|
{
|
|
|
|
class DecoratedSpinBox : public QSpinBox
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
DecoratedSpinBox()
|
|
|
|
{
|
|
|
|
setLocale(QLocale::French);
|
|
|
|
setMaximum(100000000);
|
|
|
|
setValue(1000000);
|
|
|
|
}
|
|
|
|
|
|
|
|
QLineEdit *lineEdit() const
|
|
|
|
{
|
|
|
|
return QSpinBox::lineEdit();
|
|
|
|
}
|
|
|
|
|
|
|
|
//we use the French delimiters here
|
|
|
|
QString textFromValue (int value) const
|
|
|
|
{
|
|
|
|
return locale().toString(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
} spinbox;
|
|
|
|
spinbox.show();
|
|
|
|
spinbox.activateWindow();
|
|
|
|
spinbox.setFocus();
|
|
|
|
QApplication::setActiveWindow(&spinbox);
|
|
|
|
QTest::qWaitForWindowShown(&spinbox);
|
|
|
|
QTRY_VERIFY(spinbox.hasFocus());
|
|
|
|
QTRY_COMPARE(static_cast<QWidget *>(&spinbox), QApplication::activeWindow());
|
|
|
|
QCOMPARE(spinbox.text(), spinbox.locale().toString(spinbox.value()));
|
|
|
|
spinbox.lineEdit()->setCursorPosition(2); //just after the first thousand separator
|
|
|
|
QTest::keyClick(0, Qt::Key_0); // let's insert a 0
|
|
|
|
QCOMPARE(spinbox.value(), 10000000); //it's been multiplied by 10
|
|
|
|
spinbox.clearFocus(); //make sure the value is correctly formatted
|
|
|
|
QCOMPARE(spinbox.text(), spinbox.locale().toString(spinbox.value()));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTEST_MAIN(tst_QSpinBox)
|
|
|
|
#include "tst_qspinbox.moc"
|