|
0
|
1 |
/****************************************************************************
|
|
|
2 |
**
|
|
|
3 |
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
4 |
** All rights reserved.
|
|
|
5 |
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
|
6 |
**
|
|
|
7 |
** This file is part of the test suite of the Qt Toolkit.
|
|
|
8 |
**
|
|
|
9 |
** $QT_BEGIN_LICENSE:LGPL$
|
|
|
10 |
** No Commercial Usage
|
|
|
11 |
** This file contains pre-release code and may not be distributed.
|
|
|
12 |
** You may use this file in accordance with the terms and conditions
|
|
|
13 |
** contained in the Technology Preview License Agreement accompanying
|
|
|
14 |
** this package.
|
|
|
15 |
**
|
|
|
16 |
** GNU Lesser General Public License Usage
|
|
|
17 |
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
|
18 |
** General Public License version 2.1 as published by the Free Software
|
|
|
19 |
** Foundation and appearing in the file LICENSE.LGPL included in the
|
|
|
20 |
** packaging of this file. Please review the following information to
|
|
|
21 |
** ensure the GNU Lesser General Public License version 2.1 requirements
|
|
|
22 |
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
|
23 |
**
|
|
|
24 |
** In addition, as a special exception, Nokia gives you certain additional
|
|
|
25 |
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
|
26 |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
|
27 |
**
|
|
|
28 |
** If you have questions regarding the use of this file, please contact
|
|
|
29 |
** Nokia at qt-info@nokia.com.
|
|
|
30 |
**
|
|
|
31 |
**
|
|
|
32 |
**
|
|
|
33 |
**
|
|
|
34 |
**
|
|
|
35 |
**
|
|
|
36 |
**
|
|
|
37 |
**
|
|
|
38 |
** $QT_END_LICENSE$
|
|
|
39 |
**
|
|
|
40 |
****************************************************************************/
|
|
|
41 |
|
|
|
42 |
|
|
|
43 |
#include <QtTest/QtTest>
|
|
|
44 |
#include <qapplication.h>
|
|
|
45 |
#include <limits.h>
|
|
|
46 |
|
|
|
47 |
#include <float.h>
|
|
|
48 |
|
|
|
49 |
#include <qspinbox.h>
|
|
|
50 |
#include <qlocale.h>
|
|
|
51 |
#include <qlayout.h>
|
|
|
52 |
|
|
|
53 |
#include <qlineedit.h>
|
|
|
54 |
#include <qdebug.h>
|
|
|
55 |
|
|
|
56 |
#include "../../shared/util.h"
|
|
|
57 |
|
|
|
58 |
//TESTED_CLASS=
|
|
|
59 |
//TESTED_FILES=gui/widgets/qspinbox.h gui/widgets/qspinbox.cpp gui/widgets/qabstractspinbox.cpp gui/widgets/qabstractspinbox_p.h gui/widgets/qabstractspinbox.h
|
|
|
60 |
|
|
|
61 |
|
|
|
62 |
class DoubleSpinBox : public QDoubleSpinBox
|
|
|
63 |
{
|
|
|
64 |
Q_OBJECT
|
|
|
65 |
public:
|
|
|
66 |
DoubleSpinBox(QWidget *parent = 0)
|
|
|
67 |
: QDoubleSpinBox(parent)
|
|
|
68 |
{ /*connect(this, SIGNAL(valueChanged(double)), this, SLOT(foo(double)));*/ }
|
|
|
69 |
QString textFromValue(double v) const
|
|
|
70 |
{
|
|
|
71 |
return QDoubleSpinBox::textFromValue(v);
|
|
|
72 |
}
|
|
|
73 |
QValidator::State validate(QString &text, int &pos) const
|
|
|
74 |
{
|
|
|
75 |
return QDoubleSpinBox::validate(text, pos);
|
|
|
76 |
}
|
|
|
77 |
double valueFromText(const QString &text) const
|
|
|
78 |
{
|
|
|
79 |
return QDoubleSpinBox::valueFromText(text);
|
|
|
80 |
}
|
|
|
81 |
|
|
|
82 |
QLineEdit* lineEdit() const { return QDoubleSpinBox::lineEdit(); }
|
|
|
83 |
public slots:
|
|
|
84 |
void foo(double vla)
|
|
|
85 |
{
|
|
|
86 |
qDebug() << vla;
|
|
|
87 |
}
|
|
|
88 |
};
|
|
|
89 |
|
|
|
90 |
|
|
|
91 |
class tst_QDoubleSpinBox : public QObject
|
|
|
92 |
{
|
|
|
93 |
Q_OBJECT
|
|
|
94 |
public:
|
|
|
95 |
tst_QDoubleSpinBox();
|
|
|
96 |
virtual ~tst_QDoubleSpinBox();
|
|
|
97 |
public slots:
|
|
|
98 |
void initTestCase();
|
|
|
99 |
void cleanupTestCase();
|
|
|
100 |
void init();
|
|
|
101 |
|
|
|
102 |
private slots:
|
|
|
103 |
void germanTest();
|
|
|
104 |
|
|
|
105 |
void task54433();
|
|
|
106 |
|
|
|
107 |
void setValue_data();
|
|
|
108 |
void setValue();
|
|
|
109 |
|
|
|
110 |
void setPrefixSuffix_data();
|
|
|
111 |
void setPrefixSuffix();
|
|
|
112 |
|
|
|
113 |
void setTracking_data();
|
|
|
114 |
void setTracking();
|
|
|
115 |
|
|
|
116 |
void setWrapping_data();
|
|
|
117 |
void setWrapping();
|
|
|
118 |
|
|
|
119 |
void setSpecialValueText_data();
|
|
|
120 |
void setSpecialValueText();
|
|
|
121 |
|
|
|
122 |
void setSingleStep_data();
|
|
|
123 |
void setSingleStep();
|
|
|
124 |
|
|
|
125 |
void setMinMax_data();
|
|
|
126 |
void setMinMax();
|
|
|
127 |
|
|
|
128 |
void setDecimals_data();
|
|
|
129 |
void setDecimals();
|
|
|
130 |
|
|
|
131 |
void doubleDot();
|
|
|
132 |
|
|
|
133 |
void undoRedo();
|
|
|
134 |
|
|
|
135 |
void valueFromTextAndValidate_data();
|
|
|
136 |
void valueFromTextAndValidate();
|
|
|
137 |
|
|
|
138 |
void setReadOnly();
|
|
|
139 |
|
|
|
140 |
void editingFinished();
|
|
|
141 |
|
|
|
142 |
void removeAll();
|
|
|
143 |
|
|
|
144 |
void task199226_stateAfterEnter();
|
|
|
145 |
void task224497_fltMax();
|
|
|
146 |
|
|
|
147 |
void task221221();
|
|
|
148 |
void task255471_decimalsValidation();
|
|
|
149 |
|
|
|
150 |
public slots:
|
|
|
151 |
void valueChangedHelper(const QString &);
|
|
|
152 |
void valueChangedHelper(double);
|
|
|
153 |
private:
|
|
|
154 |
QStringList actualTexts;
|
|
|
155 |
QList<double> actualValues;
|
|
|
156 |
QWidget *testFocusWidget;
|
|
|
157 |
};
|
|
|
158 |
|
|
|
159 |
typedef QList<double> DoubleList;
|
|
|
160 |
Q_DECLARE_METATYPE(DoubleList)
|
|
|
161 |
|
|
|
162 |
tst_QDoubleSpinBox::tst_QDoubleSpinBox()
|
|
|
163 |
|
|
|
164 |
{
|
|
|
165 |
}
|
|
|
166 |
|
|
|
167 |
tst_QDoubleSpinBox::~tst_QDoubleSpinBox()
|
|
|
168 |
{
|
|
|
169 |
|
|
|
170 |
}
|
|
|
171 |
|
|
|
172 |
void tst_QDoubleSpinBox::initTestCase()
|
|
|
173 |
{
|
|
|
174 |
testFocusWidget = new QWidget(0);
|
|
|
175 |
testFocusWidget->resize(200, 100);
|
|
|
176 |
testFocusWidget->show();
|
|
|
177 |
}
|
|
|
178 |
|
|
|
179 |
void tst_QDoubleSpinBox::cleanupTestCase()
|
|
|
180 |
{
|
|
|
181 |
delete testFocusWidget;
|
|
|
182 |
testFocusWidget = 0;
|
|
|
183 |
}
|
|
|
184 |
|
|
|
185 |
void tst_QDoubleSpinBox::init()
|
|
|
186 |
{
|
|
|
187 |
QLocale::setDefault(QLocale(QLocale::C));
|
|
|
188 |
}
|
|
|
189 |
|
|
|
190 |
void tst_QDoubleSpinBox::setValue_data()
|
|
|
191 |
{
|
|
|
192 |
QTest::addColumn<double>("val");
|
|
|
193 |
|
|
|
194 |
QTest::newRow("data0") << 0.0;
|
|
|
195 |
QTest::newRow("data1") << 100.5;
|
|
|
196 |
QTest::newRow("data2") << -100.5;
|
|
|
197 |
QTest::newRow("data3") << -DBL_MAX;
|
|
|
198 |
QTest::newRow("data4") << DBL_MAX;
|
|
|
199 |
}
|
|
|
200 |
|
|
|
201 |
void tst_QDoubleSpinBox::setValue()
|
|
|
202 |
{
|
|
|
203 |
QFETCH(double, val);
|
|
|
204 |
QDoubleSpinBox spin(0);
|
|
|
205 |
spin.setRange(-DBL_MAX, DBL_MAX);
|
|
|
206 |
spin.setValue(val);
|
|
|
207 |
QCOMPARE(spin.value(), val);
|
|
|
208 |
}
|
|
|
209 |
|
|
|
210 |
void tst_QDoubleSpinBox::setPrefixSuffix_data()
|
|
|
211 |
{
|
|
|
212 |
QTest::addColumn<QString>("prefix");
|
|
|
213 |
QTest::addColumn<QString>("suffix");
|
|
|
214 |
QTest::addColumn<double>("value");
|
|
|
215 |
QTest::addColumn<int>("decimals");
|
|
|
216 |
QTest::addColumn<QString>("expectedText");
|
|
|
217 |
QTest::addColumn<QString>("expectedCleanText");
|
|
|
218 |
QTest::addColumn<bool>("show");
|
|
|
219 |
|
|
|
220 |
QTest::newRow("data0") << QString() << QString() << 10.5 << 1 << "10.5" << "10.5" << false;
|
|
|
221 |
QTest::newRow("data1") << QString() << "cm" << 10.5 << 2 << "10.50cm" << "10.50" << false;
|
|
|
222 |
QTest::newRow("data2") << "cm: " << QString() << 10.5 << 0 << "cm: 10" << "10" << false;
|
|
|
223 |
QTest::newRow("data3") << "length: " << "cm" << 10.5 << 3 << "length: 10.500cm" << "10.500" << false;
|
|
|
224 |
|
|
|
225 |
QTest::newRow("data4") << QString() << QString() << 10.5 << 1 << "10.5" << "10.5" << true;
|
|
|
226 |
QTest::newRow("data5") << QString() << "cm" << 10.5 << 2 << "10.50cm" << "10.50" << true;
|
|
|
227 |
QTest::newRow("data6") << "cm: " << QString() << 10.5 << 0 << "cm: 10" << "10" << true;
|
|
|
228 |
QTest::newRow("data7") << "length: " << "cm" << 10.5 << 3 << "length: 10.500cm" << "10.500" << true;
|
|
|
229 |
}
|
|
|
230 |
|
|
|
231 |
void tst_QDoubleSpinBox::setPrefixSuffix()
|
|
|
232 |
{
|
|
|
233 |
QFETCH(QString, prefix);
|
|
|
234 |
QFETCH(QString, suffix);
|
|
|
235 |
QFETCH(double, value);
|
|
|
236 |
QFETCH(int, decimals);
|
|
|
237 |
QFETCH(QString, expectedText);
|
|
|
238 |
QFETCH(QString, expectedCleanText);
|
|
|
239 |
QFETCH(bool, show);
|
|
|
240 |
|
|
|
241 |
QDoubleSpinBox spin(0);
|
|
|
242 |
spin.setDecimals(decimals);
|
|
|
243 |
spin.setPrefix(prefix);
|
|
|
244 |
spin.setSuffix(suffix);
|
|
|
245 |
spin.setValue(value);
|
|
|
246 |
if (show)
|
|
|
247 |
spin.show();
|
|
|
248 |
|
|
|
249 |
QCOMPARE(spin.text(), expectedText);
|
|
|
250 |
QCOMPARE(spin.cleanText(), expectedCleanText);
|
|
|
251 |
}
|
|
|
252 |
|
|
|
253 |
void tst_QDoubleSpinBox::valueChangedHelper(const QString &text)
|
|
|
254 |
{
|
|
|
255 |
actualTexts << text;
|
|
|
256 |
}
|
|
|
257 |
|
|
|
258 |
void tst_QDoubleSpinBox::valueChangedHelper(double value)
|
|
|
259 |
{
|
|
|
260 |
actualValues << value;
|
|
|
261 |
}
|
|
|
262 |
|
|
|
263 |
void tst_QDoubleSpinBox::setTracking_data()
|
|
|
264 |
{
|
|
|
265 |
QTest::addColumn<int>("decimals");
|
|
|
266 |
QTest::addColumn<QTestEventList>("keys");
|
|
|
267 |
QTest::addColumn<QStringList>("texts");
|
|
|
268 |
QTest::addColumn<bool>("tracking");
|
|
|
269 |
|
|
|
270 |
QTestEventList keys;
|
|
|
271 |
QStringList texts1;
|
|
|
272 |
QStringList texts2;
|
|
|
273 |
#ifdef Q_WS_MAC
|
|
|
274 |
keys.addKeyClick(Qt::Key_Right, Qt::ControlModifier);
|
|
|
275 |
#else
|
|
|
276 |
keys.addKeyClick(Qt::Key_End);
|
|
|
277 |
#endif
|
|
|
278 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
279 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
280 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
281 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
282 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
283 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
284 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
285 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
286 |
keys.addKeyClick('7');
|
|
|
287 |
keys.addKeyClick('.');
|
|
|
288 |
keys.addKeyClick('9');
|
|
|
289 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
290 |
keys.addKeyClick('2');
|
|
|
291 |
keys.addKeyClick(Qt::Key_Enter);
|
|
|
292 |
keys.addKeyClick(Qt::Key_Enter);
|
|
|
293 |
keys.addKeyClick(Qt::Key_Enter);
|
|
|
294 |
texts1 << "7" << "7.9" << "7." << "7.2" << "7.200" << "7.200" << "7.200";
|
|
|
295 |
texts2 << "7.200";
|
|
|
296 |
QTest::newRow("data1") << 3 << keys << texts1 << true;
|
|
|
297 |
QTest::newRow("data2") << 3 << keys << texts2 << false;
|
|
|
298 |
|
|
|
299 |
}
|
|
|
300 |
|
|
|
301 |
void tst_QDoubleSpinBox::setTracking()
|
|
|
302 |
{
|
|
|
303 |
QLocale::setDefault(QLocale(QLocale::C));
|
|
|
304 |
|
|
|
305 |
actualTexts.clear();
|
|
|
306 |
QFETCH(int, decimals);
|
|
|
307 |
QFETCH(QTestEventList, keys);
|
|
|
308 |
QFETCH(QStringList, texts);
|
|
|
309 |
QFETCH(bool, tracking);
|
|
|
310 |
|
|
|
311 |
QDoubleSpinBox spin(0);
|
|
|
312 |
spin.setKeyboardTracking(tracking);
|
|
|
313 |
spin.setDecimals(decimals);
|
|
|
314 |
spin.show();
|
|
|
315 |
|
|
|
316 |
connect(&spin, SIGNAL(valueChanged(QString)), this, SLOT(valueChangedHelper(const QString &)));
|
|
|
317 |
|
|
|
318 |
keys.simulate(&spin);
|
|
|
319 |
QCOMPARE(actualTexts, texts);
|
|
|
320 |
}
|
|
|
321 |
|
|
|
322 |
void tst_QDoubleSpinBox::setWrapping_data()
|
|
|
323 |
{
|
|
|
324 |
QTest::addColumn<bool>("wrapping");
|
|
|
325 |
QTest::addColumn<double>("minimum");
|
|
|
326 |
QTest::addColumn<double>("maximum");
|
|
|
327 |
QTest::addColumn<double>("startValue");
|
|
|
328 |
QTest::addColumn<QTestEventList>("keys");
|
|
|
329 |
QTest::addColumn<DoubleList>("expected");
|
|
|
330 |
|
|
|
331 |
QTestEventList keys;
|
|
|
332 |
DoubleList values;
|
|
|
333 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
334 |
values << 10;
|
|
|
335 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
336 |
QTest::newRow("data0") << false << 0.0 << 10.0 << 9.0 << keys << values;
|
|
|
337 |
|
|
|
338 |
keys.clear();
|
|
|
339 |
values.clear();
|
|
|
340 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
341 |
values << 10;
|
|
|
342 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
343 |
values << 0;
|
|
|
344 |
QTest::newRow("data1") << true << 0.0 << 10.0 << 9.0 << keys << values;
|
|
|
345 |
|
|
|
346 |
keys.clear();
|
|
|
347 |
values.clear();
|
|
|
348 |
#ifdef Q_WS_MAC
|
|
|
349 |
keys.addKeyClick(Qt::Key_Right, Qt::ControlModifier);
|
|
|
350 |
#else
|
|
|
351 |
keys.addKeyClick(Qt::Key_End);
|
|
|
352 |
#endif
|
|
|
353 |
keys.addKeyClick(Qt::Key_Backspace);
|
|
|
354 |
keys.addKeyClick('1');
|
|
|
355 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
356 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
357 |
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
358 |
values << 9.01 << 8.01 << 7.01 << 0.0;
|
|
|
359 |
QTest::newRow("data2") << false << 0.0 << 10.0 << 9.0 << keys << values;
|
|
|
360 |
|
|
|
361 |
keys.clear();
|
|
|
362 |
values.clear();
|
|
|
363 |
#ifdef Q_WS_MAC
|
|
|
364 |
keys.addKeyClick(Qt::Key_Left, Qt::ControlModifier);
|
|
|
365 |
#else
|
|
|
366 |
keys.addKeyClick(Qt::Key_Home);
|
|
|
367 |
#endif
|
|
|
368 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
369 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
370 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
371 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
372 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
373 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
374 |
keys.addKeyClick(Qt::Key_Delete);
|
|
|
375 |
keys.addKeyClick('1');
|
|
|
376 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
377 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
378 |
values << 0 << 1 << 0 << 10;
|
|
|
379 |
QTest::newRow("data3") << true << 0.0 << 10.0 << 9.0 << keys << values;
|
|
|
380 |
|
|
|
381 |
keys.clear();
|
|
|
382 |
values.clear();
|
|
|
383 |
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
384 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
385 |
values << 0;
|
|
|
386 |
QTest::newRow("data4") << false << 0.0 << 10.0 << 6.0 << keys << values;
|
|
|
387 |
|
|
|
388 |
keys.clear();
|
|
|
389 |
values.clear();
|
|
|
390 |
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
391 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
392 |
values << 0 << 10;
|
|
|
393 |
QTest::newRow("data5") << true << 0.0 << 10.0 << 6.0 << keys << values;
|
|
|
394 |
|
|
|
395 |
keys.clear();
|
|
|
396 |
values.clear();
|
|
|
397 |
keys.addKeyClick(Qt::Key_PageUp);
|
|
|
398 |
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
399 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
400 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
401 |
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
402 |
keys.addKeyClick(Qt::Key_PageDown);
|
|
|
403 |
values << 10 << 0 << 10 << 0 << 10 << 0;
|
|
|
404 |
QTest::newRow("data6") << true << 0.0 << 10.0 << 6.0 << keys << values;
|
|
|
405 |
|
|
|
406 |
}
|
|
|
407 |
|
|
|
408 |
|
|
|
409 |
void tst_QDoubleSpinBox::setWrapping()
|
|
|
410 |
{
|
|
|
411 |
QLocale::setDefault(QLocale(QLocale::C));
|
|
|
412 |
QFETCH(bool, wrapping);
|
|
|
413 |
QFETCH(double, minimum);
|
|
|
414 |
QFETCH(double, maximum);
|
|
|
415 |
QFETCH(double, startValue);
|
|
|
416 |
QFETCH(QTestEventList, keys);
|
|
|
417 |
QFETCH(DoubleList, expected);
|
|
|
418 |
|
|
|
419 |
QDoubleSpinBox spin(0);
|
|
|
420 |
spin.setMinimum(minimum);
|
|
|
421 |
spin.setMaximum(maximum);
|
|
|
422 |
spin.setValue(startValue);
|
|
|
423 |
spin.setWrapping(wrapping);
|
|
|
424 |
spin.show();
|
|
|
425 |
actualValues.clear();
|
|
|
426 |
connect(&spin, SIGNAL(valueChanged(double)), this, SLOT(valueChangedHelper(double)));
|
|
|
427 |
|
|
|
428 |
keys.simulate(&spin);
|
|
|
429 |
|
|
|
430 |
QCOMPARE(actualValues.size(), expected.size());
|
|
|
431 |
for (int i=0; i<qMin(actualValues.size(), expected.size()); ++i) {
|
|
|
432 |
QCOMPARE(actualValues.at(i), expected.at(i));
|
|
|
433 |
}
|
|
|
434 |
}
|
|
|
435 |
|
|
|
436 |
void tst_QDoubleSpinBox::setSpecialValueText_data()
|
|
|
437 |
{
|
|
|
438 |
QTest::addColumn<QString>("specialValueText");
|
|
|
439 |
QTest::addColumn<double>("minimum");
|
|
|
440 |
QTest::addColumn<double>("maximum");
|
|
|
441 |
QTest::addColumn<double>("value");
|
|
|
442 |
QTest::addColumn<int>("decimals");
|
|
|
443 |
QTest::addColumn<QString>("expected");
|
|
|
444 |
QTest::addColumn<bool>("show");
|
|
|
445 |
|
|
|
446 |
QTest::newRow("data0") << QString() << 0.0 << 10.0 << 1.0 << 4 << "1.0000" << false;
|
|
|
447 |
QTest::newRow("data1") << QString() << 0.0 << 10.0 << 1.0 << 4 << "1.0000" << true;
|
|
|
448 |
QTest::newRow("data2") << "foo" << 0.0 << 10.0 << 0.0 << 2 << "foo" << false;
|
|
|
449 |
QTest::newRow("data3") << "foo" << 0.0 << 10.0 << 0.0 << 2 << "foo" << true;
|
|
|
450 |
}
|
|
|
451 |
|
|
|
452 |
void tst_QDoubleSpinBox::setSpecialValueText()
|
|
|
453 |
{
|
|
|
454 |
QFETCH(QString, specialValueText);
|
|
|
455 |
QFETCH(double, minimum);
|
|
|
456 |
QFETCH(double, maximum);
|
|
|
457 |
QFETCH(double, value);
|
|
|
458 |
QFETCH(int, decimals);
|
|
|
459 |
QFETCH(QString, expected);
|
|
|
460 |
QFETCH(bool, show);
|
|
|
461 |
|
|
|
462 |
QDoubleSpinBox spin(0);
|
|
|
463 |
spin.setSpecialValueText(specialValueText);
|
|
|
464 |
spin.setMinimum(minimum);
|
|
|
465 |
spin.setMaximum(maximum);
|
|
|
466 |
spin.setValue(value);
|
|
|
467 |
spin.setDecimals(decimals);
|
|
|
468 |
if (show)
|
|
|
469 |
spin.show();
|
|
|
470 |
|
|
|
471 |
QCOMPARE(spin.text(), expected);
|
|
|
472 |
}
|
|
|
473 |
|
|
|
474 |
void tst_QDoubleSpinBox::setSingleStep_data()
|
|
|
475 |
{
|
|
|
476 |
QTest::addColumn<double>("singleStep");
|
|
|
477 |
QTest::addColumn<double>("startValue");
|
|
|
478 |
QTest::addColumn<QTestEventList>("keys");
|
|
|
479 |
QTest::addColumn<DoubleList>("expected");
|
|
|
480 |
QTest::addColumn<bool>("show");
|
|
|
481 |
|
|
|
482 |
QTestEventList keys;
|
|
|
483 |
DoubleList values;
|
|
|
484 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
485 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
486 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
487 |
values << 11 << 10 << 11;
|
|
|
488 |
QTest::newRow("data0") << 1.0 << 10.0 << keys << values << false;
|
|
|
489 |
QTest::newRow("data1") << 1.0 << 10.0 << keys << values << true;
|
|
|
490 |
|
|
|
491 |
keys.clear();
|
|
|
492 |
values.clear();
|
|
|
493 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
494 |
keys.addKeyClick(Qt::Key_Down);
|
|
|
495 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
496 |
values << 12.5 << 10.0 << 12.5;
|
|
|
497 |
QTest::newRow("data2") << 2.5 << 10.0 << keys << values << false;
|
|
|
498 |
QTest::newRow("data3") << 2.5 << 10.0 << keys << values << true;
|
|
|
499 |
}
|
|
|
500 |
|
|
|
501 |
void tst_QDoubleSpinBox::setSingleStep()
|
|
|
502 |
{
|
|
|
503 |
QFETCH(double, singleStep);
|
|
|
504 |
QFETCH(double, startValue);
|
|
|
505 |
QFETCH(QTestEventList, keys);
|
|
|
506 |
QFETCH(DoubleList, expected);
|
|
|
507 |
QFETCH(bool, show);
|
|
|
508 |
|
|
|
509 |
QDoubleSpinBox spin(0);
|
|
|
510 |
actualValues.clear();
|
|
|
511 |
spin.setSingleStep(singleStep);
|
|
|
512 |
spin.setValue(startValue);
|
|
|
513 |
if (show)
|
|
|
514 |
spin.show();
|
|
|
515 |
connect(&spin, SIGNAL(valueChanged(double)), this, SLOT(valueChangedHelper(double)));
|
|
|
516 |
|
|
|
517 |
QCOMPARE(actualValues.size(), 0);
|
|
|
518 |
keys.simulate(&spin);
|
|
|
519 |
QCOMPARE(actualValues.size(), expected.size());
|
|
|
520 |
for (int i=0; i<qMin(actualValues.size(), expected.size()); ++i) {
|
|
|
521 |
QCOMPARE(actualValues.at(i), expected.at(i));
|
|
|
522 |
}
|
|
|
523 |
}
|
|
|
524 |
|
|
|
525 |
void tst_QDoubleSpinBox::setMinMax_data()
|
|
|
526 |
{
|
|
|
527 |
QTest::addColumn<double>("startValue");
|
|
|
528 |
QTest::addColumn<double>("minimum");
|
|
|
529 |
QTest::addColumn<double>("maximum");
|
|
|
530 |
QTest::addColumn<QTestEventList>("keys");
|
|
|
531 |
QTest::addColumn<double>("expected");
|
|
|
532 |
QTest::addColumn<bool>("show");
|
|
|
533 |
|
|
|
534 |
QTestEventList keys;
|
|
|
535 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
536 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
537 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
538 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
539 |
keys.addKeyClick(Qt::Key_Up);
|
|
|
540 |
QTest::newRow("data0") << 1.0 << -DBL_MAX << 2.0 << keys << 2.0 << false;
|
|
|
541 |
QTest::newRow("data1") << 1.0 << -DBL_MAX << 2.0 << keys << 2.0 << true;
|
|
|
542 |
QTest::newRow("data2") << -20000.0 << -15000.0 << -13000.0 << keys << -14995.0 << false;
|
|
|
543 |
QTest::newRow("data3") << -20000.0 << -15000.0 << -13000.0 << keys << -14995.0 << true;
|
|
|
544 |
QTest::newRow("data4") << 20.0 << -101.2 << -102.0 << QTestEventList() << -102.0 << false;
|
|
|
545 |
QTest::newRow("data5") << 20.0 << -101.2 << -102.0 << QTestEventList() << -102.0 << true;
|
|
|
546 |
}
|
|
|
547 |
|
|
|
548 |
void tst_QDoubleSpinBox::setMinMax()
|
|
|
549 |
{
|
|
|
550 |
QFETCH(double, startValue);
|
|
|
551 |
QFETCH(double, minimum);
|
|
|
552 |
QFETCH(double, maximum);
|
|
|
553 |
QFETCH(QTestEventList, keys);
|
|
|
554 |
QFETCH(double, expected);
|
|
|
555 |
QFETCH(bool, show);
|
|
|
556 |
|
|
|
557 |
{
|
|
|
558 |
QDoubleSpinBox spin(0);
|
|
|
559 |
spin.setMinimum(minimum);
|
|
|
560 |
spin.setMaximum(maximum);
|
|
|
561 |
spin.setValue(startValue);
|
|
|
562 |
|
|
|
563 |
if (show)
|
|
|
564 |
spin.show();
|
|
|
565 |
keys.simulate(&spin);
|
|
|
566 |
QCOMPARE(spin.value(), expected);
|
|
|
567 |
}
|
|
|
568 |
|
|
|
569 |
{
|
|
|
570 |
QDoubleSpinBox spin(0);
|
|
|
571 |
spin.setMaximum(maximum);
|
|
|
572 |
spin.setMinimum(minimum);
|
|
|
573 |
spin.setValue(startValue);
|
|
|
574 |
|
|
|
575 |
if (show)
|
|
|
576 |
spin.show();
|
|
|
577 |
keys.simulate(&spin);
|
|
|
578 |
}
|
|
|
579 |
|
|
|
580 |
{
|
|
|
581 |
QDoubleSpinBox spin(0);
|
|
|
582 |
spin.setRange(minimum, maximum);
|
|
|
583 |
spin.setValue(startValue);
|
|
|
584 |
|
|
|
585 |
if (show)
|
|
|
586 |
spin.show();
|
|
|
587 |
keys.simulate(&spin);
|
|
|
588 |
}
|
|
|
589 |
|
|
|
590 |
|
|
|
591 |
}
|
|
|
592 |
|
|
|
593 |
void tst_QDoubleSpinBox::setDecimals_data()
|
|
|
594 |
{
|
|
|
595 |
QTest::addColumn<int>("decimals");
|
|
|
596 |
QTest::addColumn<int>("expectedDecimals");
|
|
|
597 |
QTest::addColumn<double>("startValue");
|
|
|
598 |
QTest::addColumn<QString>("expected");
|
|
|
599 |
|
|
|
600 |
QTest::newRow("data0") << 4 << 4 << 1.0 << "1.0000";
|
|
|
601 |
QTest::newRow("data1") << 1 << 1 << 1.243443 << "1.2";
|
|
|
602 |
QTest::newRow("data2") << 6 << 6 << 1.29 << "1.290000";
|
|
|
603 |
QTest::newRow("data3") << 8 << 8 << 9.1234567809 << "9.12345678";
|
|
|
604 |
QTest::newRow("data4") << 13 << 13 << 0.12345678901237 << "0.1234567890124";
|
|
|
605 |
QTest::newRow("data5") << 13 << 13 << -0.12345678901237 << "-0.1234567890124";
|
|
|
606 |
QTest::newRow("data6") << 13 << 13 << -0.12345678901237 << "-0.1234567890124";
|
|
|
607 |
QTest::newRow("data7") << -1 << 0 << 0.1 << "0";
|
|
|
608 |
QTest::newRow("data8") << 120 << 120 << -0.12345678901237 << "-0.123456789012370005131913330842508003115653991699218750000000000000000000000000000000000000000000000000000000000000000000";
|
|
|
609 |
|
|
|
610 |
}
|
|
|
611 |
|
|
|
612 |
void tst_QDoubleSpinBox::setDecimals()
|
|
|
613 |
{
|
|
|
614 |
QFETCH(int, decimals);
|
|
|
615 |
QFETCH(int, expectedDecimals);
|
|
|
616 |
QFETCH(double, startValue);
|
|
|
617 |
QFETCH(QString, expected);
|
|
|
618 |
|
|
|
619 |
QDoubleSpinBox spin(0);
|
|
|
620 |
spin.setRange(-DBL_MAX, DBL_MAX);
|
|
|
621 |
spin.setDecimals(decimals);
|
|
|
622 |
spin.setValue(startValue);
|
|
|
623 |
QCOMPARE(spin.decimals(), expectedDecimals);
|
|
|
624 |
if (sizeof(qreal) == sizeof(float))
|
|
|
625 |
QCOMPARE(spin.text().left(17), expected.left(17));
|
|
|
626 |
else
|
|
|
627 |
QCOMPARE(spin.text(), expected);
|
|
|
628 |
|
|
|
629 |
if (spin.decimals() > 0) {
|
|
|
630 |
#ifdef Q_WS_MAC
|
|
|
631 |
QTest::keyClick(&spin, Qt::Key_Right, Qt::ControlModifier);
|
|
|
632 |
#else
|
|
|
633 |
QTest::keyClick(&spin, Qt::Key_End);
|
|
|
634 |
#endif
|
|
|
635 |
QTest::keyClick(&spin, Qt::Key_1); // just make sure we can't input more decimals than what is specified
|
|
|
636 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
637 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
638 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
639 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
640 |
if (sizeof(qreal) == sizeof(float))
|
|
|
641 |
QCOMPARE(spin.text().left(17), expected.left(17));
|
|
|
642 |
else
|
|
|
643 |
QCOMPARE(spin.text(), expected);
|
|
|
644 |
}
|
|
|
645 |
}
|
|
|
646 |
|
|
|
647 |
static QString stateName(int state)
|
|
|
648 |
{
|
|
|
649 |
switch (state) {
|
|
|
650 |
case QValidator::Acceptable: return QString("Acceptable");
|
|
|
651 |
case QValidator::Intermediate: return QString("Intermediate");
|
|
|
652 |
case QValidator::Invalid: return QString("Invalid");
|
|
|
653 |
default: break;
|
|
|
654 |
}
|
|
|
655 |
qWarning("%s %d: this should never happen", __FILE__, __LINE__);
|
|
|
656 |
return QString();
|
|
|
657 |
}
|
|
|
658 |
|
|
|
659 |
void tst_QDoubleSpinBox::valueFromTextAndValidate_data()
|
|
|
660 |
{
|
|
|
661 |
const int Intermediate = QValidator::Intermediate;
|
|
|
662 |
const int Invalid = QValidator::Invalid;
|
|
|
663 |
const int Acceptable = QValidator::Acceptable;
|
|
|
664 |
|
|
|
665 |
QTest::addColumn<QString>("txt");
|
|
|
666 |
QTest::addColumn<int>("state");
|
|
|
667 |
QTest::addColumn<double>("mini");
|
|
|
668 |
QTest::addColumn<double>("maxi");
|
|
|
669 |
QTest::addColumn<int>("language");
|
|
|
670 |
QTest::addColumn<QString>("expectedText"); // if empty we don't check
|
|
|
671 |
|
|
|
672 |
QTest::newRow("data0") << QString("2.2") << Intermediate << 3.0 << 5.0 << (int)QLocale::C << QString();
|
|
|
673 |
QTest::newRow("data1") << QString() << Intermediate << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
674 |
QTest::newRow("data2") << QString("asd") << Invalid << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
675 |
QTest::newRow("data3") << QString("2.2") << Acceptable << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
676 |
QTest::newRow("data4") << QString(" ") << Intermediate << 0.0 << 100.0 << (int)QLocale::Norwegian << QString();
|
|
|
677 |
QTest::newRow("data5") << QString(" ") << Intermediate << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
678 |
QTest::newRow("data6") << QString(",") << Intermediate << 0.0 << 100.0 << (int)QLocale::Norwegian << QString();
|
|
|
679 |
QTest::newRow("data7") << QString(",") << Invalid << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
680 |
QTest::newRow("data8") << QString("1 ") << Acceptable << 0.0 << 1000.0 << (int)QLocale::Norwegian << QString("1");
|
|
|
681 |
QTest::newRow("data9") << QString("1 ") << Acceptable << 0.0 << 100.0 << (int)QLocale::C << QString("1");
|
|
|
682 |
QTest::newRow("data10") << QString(" 1") << Acceptable << 0.0 << 100.0 << (int)QLocale::Norwegian << QString("1");
|
|
|
683 |
QTest::newRow("data11") << QString(" 1") << Acceptable << 0.0 << 100.0 << (int)QLocale::C << QString("1");
|
|
|
684 |
QTest::newRow("data12") << QString("1,") << Acceptable << 0.0 << 100.0 << (int)QLocale::Norwegian << QString();
|
|
|
685 |
QTest::newRow("data13") << QString("1,") << Intermediate << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
686 |
QTest::newRow("data14") << QString("1, ") << Acceptable << 0.0 << 100.0 << (int)QLocale::Norwegian << QString("1,");
|
|
|
687 |
QTest::newRow("data15") << QString("1, ") << Invalid << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
688 |
QTest::newRow("data16") << QString("2") << Intermediate << 100.0 << 102.0 << (int)QLocale::C << QString();
|
|
|
689 |
QTest::newRow("data17") << QString("22.0") << Intermediate << 100.0 << 102.0 << (int)QLocale::C << QString();
|
|
|
690 |
QTest::newRow("data18") << QString("12.0") << Intermediate << 100.0 << 102.0 << (int)QLocale::C << QString();
|
|
|
691 |
QTest::newRow("data19") << QString("12.2") << Intermediate << 100. << 102.0 << (int)QLocale::C << QString();
|
|
|
692 |
QTest::newRow("data20") << QString("21.") << Intermediate << 100.0 << 102.0 << (int)QLocale::C << QString();
|
|
|
693 |
QTest::newRow("data21") << QString("-21.") << Intermediate << -102.0 << -100.0 << (int)QLocale::C << QString();
|
|
|
694 |
QTest::newRow("data22") << QString("-12.") << Intermediate << -102.0 << -100.0 << (int)QLocale::C << QString();
|
|
|
695 |
QTest::newRow("data23") << QString("-11.11") << Intermediate << -102.0 << -101.2 << (int)QLocale::C << QString();
|
|
|
696 |
QTest::newRow("data24") << QString("-11.4") << Intermediate << -102.0 << -101.3 << (int)QLocale::C << QString();
|
|
|
697 |
QTest::newRow("data25") << QString("11.400") << Invalid << 0.0 << 100.0 << (int)QLocale::C << QString();
|
|
|
698 |
QTest::newRow("data26") << QString(".4") << Intermediate << 0.45 << 0.5 << (int)QLocale::C << QString();
|
|
|
699 |
QTest::newRow("data27") << QString("+.4") << Intermediate << 0.45 << 0.5 << (int)QLocale::C << QString();
|
|
|
700 |
QTest::newRow("data28") << QString("-.4") << Intermediate << -0.5 << -0.45 << (int)QLocale::C << QString();
|
|
|
701 |
QTest::newRow("data29") << QString(".4") << Intermediate << 1.0 << 2.4 << (int)QLocale::C << QString();
|
|
|
702 |
QTest::newRow("data30") << QString("-.4") << Intermediate << -2.3 << -1.9 << (int)QLocale::C << QString();
|
|
|
703 |
QTest::newRow("data31") << QString("-42") << Invalid << -2.43 << -1.0 << (int)QLocale::C << QString();
|
|
|
704 |
QTest::newRow("data32") << QString("-4") << Invalid << -1.4 << -1.0 << (int)QLocale::C << QString();
|
|
|
705 |
QTest::newRow("data33") << QString("-42") << Invalid << -1.4 << -1.0 << (int)QLocale::C << QString();
|
|
|
706 |
QTest::newRow("data34") << QString("1000000000000") << Invalid << -140.0 << -120.2 << (int)QLocale::C << QString();
|
|
|
707 |
QTest::newRow("data35") << QString("+.12") << Invalid << -5.0 << -3.2 << (int)QLocale::C << QString();
|
|
|
708 |
QTest::newRow("data36") << QString("-.12") << Invalid << 5.0 << 33.2 << (int)QLocale::C << QString();
|
|
|
709 |
QTest::newRow("data37") << QString("12.2") << Intermediate << 100. << 103.0 << (int)QLocale::C << QString();
|
|
|
710 |
QTest::newRow("data38") << QString("12.2") << Intermediate << 100. << 102.3 << (int)QLocale::C << QString();
|
|
|
711 |
QTest::newRow("data39") << QString("-12.") << Acceptable << -102.0 << 102.0 << (int)QLocale::C << QString();
|
|
|
712 |
QTest::newRow("data40") << QString("12.") << Invalid << -102.0 << 11.0 << (int)QLocale::C << QString();
|
|
|
713 |
QTest::newRow("data41") << QString("103.") << Invalid << -102.0 << 11.0 << (int)QLocale::C << QString();
|
|
|
714 |
QTest::newRow("data42") << QString("122") << Invalid << 10.0 << 12.2 << (int)QLocale::C << QString();
|
|
|
715 |
QTest::newRow("data43") << QString("-2.2") << Intermediate << -12.2 << -3.2 << (int)QLocale::C << QString();
|
|
|
716 |
QTest::newRow("data44") << QString("-2.20") << Intermediate << -12.1 << -3.2 << (int)QLocale::C << QString();
|
|
|
717 |
QTest::newRow("data45") << QString("200,2") << Invalid << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
718 |
QTest::newRow("data46") << QString("200,2") << Acceptable << 0.0 << 1000.0 << (int)QLocale::German << QString();
|
|
|
719 |
QTest::newRow("data47") << QString("2.2") << Acceptable << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
720 |
QTest::newRow("data48") << QString("2.2") << Intermediate << 0.0 << 1000.0 << (int)QLocale::German << QString();
|
|
|
721 |
QTest::newRow("data49") << QString("2.2,00") << Intermediate << 0.0 << 1000.0 << (int)QLocale::German << QString();
|
|
|
722 |
QTest::newRow("data50") << QString("2.2") << Acceptable << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
723 |
QTest::newRow("data51") << QString("2.2,00") << Invalid << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
724 |
QTest::newRow("data52") << QString("2..2,00") << Invalid << 0.0 << 1000.0 << (int)QLocale::German << QString();
|
|
|
725 |
QTest::newRow("data53") << QString("2.2") << Invalid << 0.0 << 1000.0 << (int)QLocale::Norwegian << QString();
|
|
|
726 |
QTest::newRow("data54") << QString(" 2.2") << Acceptable << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
727 |
QTest::newRow("data55") << QString("2.2 ") << Acceptable << 0.0 << 1000.0 << (int)QLocale::C << QString("2.2");
|
|
|
728 |
QTest::newRow("data56") << QString(" 2.2 ") << Acceptable << 0.0 << 1000.0 << (int)QLocale::C << QString("2.2");
|
|
|
729 |
QTest::newRow("data57") << QString("2 2") << Invalid << 0.0 << 1000.0 << (int)QLocale::C << QString();
|
|
|
730 |
}
|
|
|
731 |
|
|
|
732 |
void tst_QDoubleSpinBox::valueFromTextAndValidate()
|
|
|
733 |
{
|
|
|
734 |
QFETCH(QString, txt);
|
|
|
735 |
QFETCH(int, state);
|
|
|
736 |
QFETCH(double, mini);
|
|
|
737 |
QFETCH(double, maxi);
|
|
|
738 |
QFETCH(int, language);
|
|
|
739 |
QFETCH(QString, expectedText);
|
|
|
740 |
QLocale::setDefault(QLocale((QLocale::Language)language));
|
|
|
741 |
|
|
|
742 |
DoubleSpinBox sb(0);
|
|
|
743 |
sb.show();
|
|
|
744 |
sb.setRange(mini, maxi);
|
|
|
745 |
|
|
|
746 |
int unused = 0;
|
|
|
747 |
QCOMPARE(stateName(sb.validate(txt, unused)), stateName(state));
|
|
|
748 |
if (!expectedText.isEmpty())
|
|
|
749 |
QCOMPARE(txt, expectedText);
|
|
|
750 |
}
|
|
|
751 |
|
|
|
752 |
void tst_QDoubleSpinBox::setReadOnly()
|
|
|
753 |
{
|
|
|
754 |
QDoubleSpinBox spin(0);
|
|
|
755 |
spin.setValue(0.2);
|
|
|
756 |
spin.show();
|
|
|
757 |
QCOMPARE(spin.value(), 0.2);
|
|
|
758 |
QTest::keyClick(&spin, Qt::Key_Up);
|
|
|
759 |
QCOMPARE(spin.value(), 1.2);
|
|
|
760 |
spin.setReadOnly(true);
|
|
|
761 |
QTest::keyClick(&spin, Qt::Key_Up);
|
|
|
762 |
QCOMPARE(spin.value(), 1.2);
|
|
|
763 |
spin.stepBy(1);
|
|
|
764 |
QCOMPARE(spin.value(), 2.2);
|
|
|
765 |
spin.setReadOnly(false);
|
|
|
766 |
QTest::keyClick(&spin, Qt::Key_Up);
|
|
|
767 |
QCOMPARE(spin.value(), 3.2);
|
|
|
768 |
}
|
|
|
769 |
|
|
|
770 |
void tst_QDoubleSpinBox::editingFinished()
|
|
|
771 |
{
|
|
|
772 |
QVBoxLayout *layout = new QVBoxLayout(testFocusWidget);
|
|
|
773 |
QDoubleSpinBox *box = new QDoubleSpinBox(testFocusWidget);
|
|
|
774 |
layout->addWidget(box);
|
|
|
775 |
QDoubleSpinBox *box2 = new QDoubleSpinBox(testFocusWidget);
|
|
|
776 |
layout->addWidget(box2);
|
|
|
777 |
|
|
|
778 |
testFocusWidget->show();
|
|
|
779 |
QApplication::setActiveWindow(testFocusWidget);
|
|
|
780 |
QTest::qWait(10);
|
|
|
781 |
QTRY_VERIFY(testFocusWidget->isActiveWindow());
|
|
|
782 |
box->setFocus();
|
|
|
783 |
QTRY_VERIFY(box->hasFocus());
|
|
|
784 |
|
|
|
785 |
QSignalSpy editingFinishedSpy1(box, SIGNAL(editingFinished()));
|
|
|
786 |
QSignalSpy editingFinishedSpy2(box2, SIGNAL(editingFinished()));
|
|
|
787 |
|
|
|
788 |
box->setFocus();
|
|
|
789 |
QTest::keyClick(box, Qt::Key_Up);
|
|
|
790 |
QTest::keyClick(box, Qt::Key_Up);
|
|
|
791 |
|
|
|
792 |
|
|
|
793 |
QCOMPARE(editingFinishedSpy1.count(), 0);
|
|
|
794 |
QCOMPARE(editingFinishedSpy2.count(), 0);
|
|
|
795 |
|
|
|
796 |
QTest::keyClick(box2, Qt::Key_Up);
|
|
|
797 |
QTest::keyClick(box2, Qt::Key_Up);
|
|
|
798 |
box2->setFocus();
|
|
|
799 |
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
800 |
box->setFocus();
|
|
|
801 |
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
802 |
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
803 |
QTest::keyClick(box, Qt::Key_Up);
|
|
|
804 |
QCOMPARE(editingFinishedSpy1.count(), 1);
|
|
|
805 |
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
806 |
QTest::keyClick(box, Qt::Key_Enter);
|
|
|
807 |
QCOMPARE(editingFinishedSpy1.count(), 2);
|
|
|
808 |
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
809 |
QTest::keyClick(box, Qt::Key_Return);
|
|
|
810 |
QCOMPARE(editingFinishedSpy1.count(), 3);
|
|
|
811 |
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
812 |
box2->setFocus();
|
|
|
813 |
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
814 |
QCOMPARE(editingFinishedSpy2.count(), 1);
|
|
|
815 |
QTest::keyClick(box2, Qt::Key_Enter);
|
|
|
816 |
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
817 |
QCOMPARE(editingFinishedSpy2.count(), 2);
|
|
|
818 |
QTest::keyClick(box2, Qt::Key_Return);
|
|
|
819 |
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
820 |
QCOMPARE(editingFinishedSpy2.count(), 3);
|
|
|
821 |
testFocusWidget->hide();
|
|
|
822 |
QCOMPARE(editingFinishedSpy1.count(), 4);
|
|
|
823 |
QCOMPARE(editingFinishedSpy2.count(), 4);
|
|
|
824 |
|
|
|
825 |
}
|
|
|
826 |
|
|
|
827 |
void tst_QDoubleSpinBox::removeAll()
|
|
|
828 |
{
|
|
|
829 |
DoubleSpinBox spin(0);
|
|
|
830 |
spin.setPrefix("foo");
|
|
|
831 |
spin.setSuffix("bar");
|
|
|
832 |
spin.setValue(0.2);
|
|
|
833 |
spin.setDecimals(1);
|
|
|
834 |
spin.show();
|
|
|
835 |
#ifdef Q_WS_MAC
|
|
|
836 |
QTest::keyClick(&spin, Qt::Key_Left, Qt::ControlModifier);
|
|
|
837 |
#else
|
|
|
838 |
QTest::keyClick(&spin, Qt::Key_Home);
|
|
|
839 |
#endif
|
|
|
840 |
|
|
|
841 |
#ifdef Q_WS_MAC
|
|
|
842 |
QTest::keyClick(&spin, Qt::Key_Right, Qt::ControlModifier|Qt::ShiftModifier);
|
|
|
843 |
#else
|
|
|
844 |
QTest::keyClick(&spin, Qt::Key_End, Qt::ShiftModifier);
|
|
|
845 |
#endif
|
|
|
846 |
|
|
|
847 |
QCOMPARE(spin.lineEdit()->selectedText(), QString("foo0.2bar"));
|
|
|
848 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
849 |
QCOMPARE(spin.text(), QString("foo1bar"));
|
|
|
850 |
}
|
|
|
851 |
|
|
|
852 |
void tst_QDoubleSpinBox::task54433()
|
|
|
853 |
{
|
|
|
854 |
DoubleSpinBox priceSpinBox;
|
|
|
855 |
priceSpinBox.show();
|
|
|
856 |
priceSpinBox.setRange(0.0, 999.99);
|
|
|
857 |
priceSpinBox.setDecimals(2);
|
|
|
858 |
priceSpinBox.setValue(999.99);
|
|
|
859 |
QCOMPARE(priceSpinBox.text(), QString("999.99"));
|
|
|
860 |
QCOMPARE(priceSpinBox.value(), 999.99);
|
|
|
861 |
QCOMPARE(priceSpinBox.maximum(), 999.99);
|
|
|
862 |
priceSpinBox.setDecimals(1);
|
|
|
863 |
QCOMPARE(priceSpinBox.value(), 1000.0);
|
|
|
864 |
QCOMPARE(priceSpinBox.maximum(), 1000.0);
|
|
|
865 |
QCOMPARE(priceSpinBox.text(), QString("1000.0"));
|
|
|
866 |
|
|
|
867 |
priceSpinBox.setDecimals(2);
|
|
|
868 |
priceSpinBox.setRange(-999.99, 0.0);
|
|
|
869 |
priceSpinBox.setValue(-999.99);
|
|
|
870 |
QCOMPARE(priceSpinBox.text(), QString("-999.99"));
|
|
|
871 |
QCOMPARE(priceSpinBox.value(), -999.99);
|
|
|
872 |
QCOMPARE(priceSpinBox.minimum(), -999.99);
|
|
|
873 |
priceSpinBox.setDecimals(1);
|
|
|
874 |
QCOMPARE(priceSpinBox.value(), -1000.0);
|
|
|
875 |
QCOMPARE(priceSpinBox.minimum(), -1000.0);
|
|
|
876 |
QCOMPARE(priceSpinBox.text(), QString("-1000.0"));
|
|
|
877 |
}
|
|
|
878 |
|
|
|
879 |
|
|
|
880 |
|
|
|
881 |
void tst_QDoubleSpinBox::germanTest()
|
|
|
882 |
{
|
|
|
883 |
QLocale::setDefault(QLocale(QLocale::German));
|
|
|
884 |
DoubleSpinBox spin;
|
|
|
885 |
spin.show();
|
|
|
886 |
spin.setValue(2.12);
|
|
|
887 |
#ifdef Q_WS_MAC
|
|
|
888 |
QTest::keyClick(&spin, Qt::Key_Right, Qt::ControlModifier);
|
|
|
889 |
#else
|
|
|
890 |
QTest::keyClick(&spin, Qt::Key_End);
|
|
|
891 |
#endif
|
|
|
892 |
QTest::keyClick(&spin, Qt::Key_Backspace);
|
|
|
893 |
QCOMPARE(spin.text(), QString("2,1"));
|
|
|
894 |
QTest::keyClick(&spin, Qt::Key_Enter);
|
|
|
895 |
QCOMPARE(spin.text(), QString("2,10"));
|
|
|
896 |
}
|
|
|
897 |
|
|
|
898 |
void tst_QDoubleSpinBox::doubleDot()
|
|
|
899 |
{
|
|
|
900 |
DoubleSpinBox spin;
|
|
|
901 |
spin.show();
|
|
|
902 |
spin.setValue(2.12);
|
|
|
903 |
QTest::keyClick(&spin, Qt::Key_Backspace);
|
|
|
904 |
QCOMPARE(spin.text(), QString("2.12"));
|
|
|
905 |
#ifdef Q_WS_MAC
|
|
|
906 |
QTest::keyClick(&spin, Qt::Key_Left, Qt::ControlModifier);
|
|
|
907 |
#else
|
|
|
908 |
QTest::keyClick(&spin, Qt::Key_Home);
|
|
|
909 |
#endif
|
|
|
910 |
QTest::keyClick(&spin, Qt::Key_Right, Qt::ShiftModifier);
|
|
|
911 |
QCOMPARE(spin.lineEdit()->selectedText(), QString("2"));
|
|
|
912 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
913 |
QCOMPARE(spin.text(), QString("1.12"));
|
|
|
914 |
QCOMPARE(spin.lineEdit()->cursorPosition(), 1);
|
|
|
915 |
QTest::keyClick(&spin, Qt::Key_Period);
|
|
|
916 |
QCOMPARE(spin.text(), QString("1.12"));
|
|
|
917 |
QCOMPARE(spin.lineEdit()->cursorPosition(), 2);
|
|
|
918 |
}
|
|
|
919 |
|
|
|
920 |
void tst_QDoubleSpinBox::undoRedo()
|
|
|
921 |
{
|
|
|
922 |
//test undo/redo feature (in conjunction with the "undoRedoEnabled" property)
|
|
|
923 |
DoubleSpinBox spin(0);
|
|
|
924 |
spin.show();
|
|
|
925 |
|
|
|
926 |
//the undo/redo is disabled by default
|
|
|
927 |
|
|
|
928 |
QCOMPARE(spin.value(), 0.0); //this is the default value
|
|
|
929 |
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
930 |
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
931 |
|
|
|
932 |
spin.lineEdit()->selectAll(); //ensures everything is selected and will be cleared by typing a key
|
|
|
933 |
QTest::keyClick(&spin, Qt::Key_1); //we put 1 into the spinbox
|
|
|
934 |
QCOMPARE(spin.value(), 1.0);
|
|
|
935 |
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
936 |
|
|
|
937 |
//testing CTRL+Z (undo)
|
|
|
938 |
int val = QKeySequence(QKeySequence::Undo)[0];
|
|
|
939 |
if (val != 0) {
|
|
|
940 |
Qt::KeyboardModifiers mods = (Qt::KeyboardModifiers)(val & Qt::KeyboardModifierMask);
|
|
|
941 |
QTest::keyClick(&spin, val & ~mods, mods);
|
|
|
942 |
QCOMPARE(spin.value(), 0.0);
|
|
|
943 |
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
944 |
QVERIFY(spin.lineEdit()->isRedoAvailable());
|
|
|
945 |
} else {
|
|
|
946 |
QWARN("Undo not tested because no key sequence associated to QKeySequence::Redo");
|
|
|
947 |
}
|
|
|
948 |
|
|
|
949 |
|
|
|
950 |
//testing CTRL+Y (redo)
|
|
|
951 |
val = QKeySequence(QKeySequence::Redo)[0];
|
|
|
952 |
if (val != 0) {
|
|
|
953 |
Qt::KeyboardModifiers mods = (Qt::KeyboardModifiers)(val & Qt::KeyboardModifierMask);
|
|
|
954 |
QTest::keyClick(&spin, val & ~mods, mods);
|
|
|
955 |
QCOMPARE(spin.value(), 1.0);
|
|
|
956 |
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
957 |
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
958 |
} else {
|
|
|
959 |
QWARN("Redo not tested because no key sequence associated to QKeySequence::Redo");
|
|
|
960 |
}
|
|
|
961 |
|
|
|
962 |
|
|
|
963 |
spin.setValue(55.0);
|
|
|
964 |
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
965 |
QVERIFY(!spin.lineEdit()->isRedoAvailable());
|
|
|
966 |
}
|
|
|
967 |
|
|
|
968 |
struct task199226_DoubleSpinBox : public QDoubleSpinBox
|
|
|
969 |
{
|
|
|
970 |
task199226_DoubleSpinBox(QWidget *parent = 0) : QDoubleSpinBox(parent) {}
|
|
|
971 |
QLineEdit *lineEdit() { return QAbstractSpinBox::lineEdit(); }
|
|
|
972 |
};
|
|
|
973 |
|
|
|
974 |
void tst_QDoubleSpinBox::task199226_stateAfterEnter()
|
|
|
975 |
{
|
|
|
976 |
task199226_DoubleSpinBox spin;
|
|
|
977 |
spin.setMinimum(0);
|
|
|
978 |
spin.setMaximum(10);
|
|
|
979 |
spin.setDecimals(0);
|
|
|
980 |
spin.show();
|
|
|
981 |
QTest::mouseDClick(spin.lineEdit(), Qt::LeftButton);
|
|
|
982 |
QTest::keyClick(spin.lineEdit(), Qt::Key_3);
|
|
|
983 |
QVERIFY(spin.lineEdit()->isModified());
|
|
|
984 |
QVERIFY(spin.lineEdit()->isUndoAvailable());
|
|
|
985 |
QTest::keyClick(spin.lineEdit(), Qt::Key_Enter);
|
|
|
986 |
QVERIFY(!spin.lineEdit()->isModified());
|
|
|
987 |
QVERIFY(!spin.lineEdit()->isUndoAvailable());
|
|
|
988 |
}
|
|
|
989 |
|
|
|
990 |
class task224497_fltMax_DoubleSpinBox : public QDoubleSpinBox
|
|
|
991 |
{
|
|
|
992 |
public:
|
|
|
993 |
QLineEdit * lineEdit () const { return QDoubleSpinBox::lineEdit(); }
|
|
|
994 |
};
|
|
|
995 |
|
|
|
996 |
void tst_QDoubleSpinBox::task224497_fltMax()
|
|
|
997 |
{
|
|
|
998 |
task224497_fltMax_DoubleSpinBox *dspin = new task224497_fltMax_DoubleSpinBox;
|
|
|
999 |
dspin->setMinimum(3);
|
|
|
1000 |
dspin->setMaximum(FLT_MAX);
|
|
|
1001 |
dspin->show();
|
|
|
1002 |
QTest::qWait(1000);
|
|
|
1003 |
dspin->lineEdit()->selectAll();
|
|
|
1004 |
QTest::keyClick(dspin->lineEdit(), Qt::Key_Delete);
|
|
|
1005 |
QTest::keyClick(dspin->lineEdit(), Qt::Key_1);
|
|
|
1006 |
QCOMPARE(dspin->cleanText(), QLatin1String("1"));
|
|
|
1007 |
}
|
|
|
1008 |
|
|
|
1009 |
void tst_QDoubleSpinBox::task221221()
|
|
|
1010 |
{
|
|
|
1011 |
QDoubleSpinBox spin;
|
|
|
1012 |
QTest::keyClick(&spin, Qt::Key_1);
|
|
|
1013 |
QCOMPARE(spin.text(), QLatin1String("1"));
|
|
|
1014 |
spin.show();
|
|
|
1015 |
#ifdef Q_WS_X11
|
|
|
1016 |
qt_x11_wait_for_window_manager(&spin);
|
|
|
1017 |
#endif
|
|
|
1018 |
QVERIFY(spin.isVisible());
|
|
|
1019 |
QCOMPARE(spin.text(), QLatin1String("1"));
|
|
|
1020 |
}
|
|
|
1021 |
|
|
|
1022 |
void tst_QDoubleSpinBox::task255471_decimalsValidation()
|
|
|
1023 |
{
|
|
|
1024 |
// QDoubleSpinBox shouldn't crash with large numbers of decimals. Even if
|
|
|
1025 |
// the results are useless ;-)
|
|
|
1026 |
for (int i = 0; i < 32; ++i)
|
|
|
1027 |
{
|
|
|
1028 |
QDoubleSpinBox spinBox;
|
|
|
1029 |
spinBox.setDecimals(i);
|
|
|
1030 |
spinBox.setMinimum(0.3);
|
|
|
1031 |
spinBox.setMaximum(12);
|
|
|
1032 |
|
|
|
1033 |
spinBox.show();
|
|
|
1034 |
QTRY_VERIFY(spinBox.isVisible());
|
|
|
1035 |
spinBox.setFocus();
|
|
|
1036 |
QTRY_VERIFY(spinBox.hasFocus());
|
|
|
1037 |
|
|
|
1038 |
QTest::keyPress(&spinBox, Qt::Key_Right);
|
|
|
1039 |
QTest::keyPress(&spinBox, Qt::Key_Right);
|
|
|
1040 |
QTest::keyPress(&spinBox, Qt::Key_Delete);
|
|
|
1041 |
|
|
|
1042 |
// Don't crash!
|
|
|
1043 |
QTest::keyPress(&spinBox, Qt::Key_2);
|
|
|
1044 |
}
|
|
|
1045 |
}
|
|
|
1046 |
|
|
|
1047 |
|
|
|
1048 |
QTEST_MAIN(tst_QDoubleSpinBox)
|
|
|
1049 |
#include "tst_qdoublespinbox.moc"
|