AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
218f0ca3b0
qt5base-lts/tests/auto/qspinbox/tst_qspinbox.cpp
Jo Asplin d4923df10e Disambiguated access to QTestLib API 
Commit 2cca7e0884 overloads
QTestLib so that QWindow * can be passed directly to
certain functions.

This fix disambiguates access to the new API by selecting
the QWindow * versions. This assumes that the QWidget *
versions are kept mostly for backwards compatibility.

Change-Id: I8755c86d5ebeb275dfa9162b0168d9179a61982d
Reviewed-on: http://codereview.qt-project.org/4640
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Matthew Cattell <matthew.cattell@nokia.com>
2011-09-12 10:20:32 +02:00

1051 lines
30 KiB
C++
Raw Blame History

/****************************************************************************
**
** 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
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** 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.
**
** 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.
**
**
**
**
**
** $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(static_cast<QWindow *>(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"
Reference in New Issue View Git Blame Copy Permalink