← Back to branch summary

~gabriel1984sibiu/minitube/qt5.6

« back to all changes in this revision

Viewing changes to tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp

  • Committer: Grevutiu Gabriel
  • Date: 2017-06-13 08:43:17 UTC
  • Revision ID: gabriel1984sibiu@gmail.com-20170613084317-ek0zqe0u9g3ocvi8
Original upstream code

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2016 The Qt Company Ltd.
 
4
** Contact: https://www.qt.io/licensing/
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and The Qt Company. For licensing terms
 
14
** and conditions see https://www.qt.io/terms-conditions. For further
 
15
** information use the contact form at https://www.qt.io/contact-us.
 
16
**
 
17
** GNU General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU
 
19
** General Public License version 3 as published by the Free Software
 
20
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
 
21
** included in the packaging of this file. Please review the following
 
22
** information to ensure the GNU General Public License requirements will
 
23
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
 
24
**
 
25
** $QT_END_LICENSE$
 
26
**
 
27
****************************************************************************/
 
28
 
 
29
 
 
30
#include <QtTest/QtTest>
 
31
#include <qapplication.h>
 
32
#include <qgroupbox.h>
 
33
#include <qlineedit.h>
 
34
 
 
35
 
 
36
 
 
37
#include <qdatetimeedit.h>
 
38
#include <qlocale.h>
 
39
#include <qlayout.h>
 
40
#include <qeventloop.h>
 
41
#include <qstyle.h>
 
42
#include <qstyle.h>
 
43
#include <QStyleOptionSpinBox>
 
44
#include <QDate>
 
45
#include <QDateTime>
 
46
#include <QTime>
 
47
#include <QList>
 
48
#include <QDateTimeEdit>
 
49
#include <QCalendarWidget>
 
50
#include <QWidget>
 
51
#include <QLineEdit>
 
52
#include <QObject>
 
53
#include <QLocale>
 
54
#include <QString>
 
55
#include <QVariantList>
 
56
#include <QVariant>
 
57
#include <QApplication>
 
58
#include <QPoint>
 
59
#include <QVBoxLayout>
 
60
#include <QRect>
 
61
#include <QCursor>
 
62
#include <QEventLoop>
 
63
#include <QStyle>
 
64
#include <QStyleOptionComboBox>
 
65
#include <QTimeEdit>
 
66
#include <QMetaType>
 
67
#include <QDebug>
 
68
#include <QWheelEvent>
 
69
#include <QTest>
 
70
#include <QSignalSpy>
 
71
#include <QTestEventList>
 
72
#include <QDateEdit>
 
73
 
 
74
#include <private/qdatetimeedit_p.h>
 
75
 
 
76
#ifdef Q_OS_WIN
 
77
# include <windows.h>
 
78
# undef min
 
79
# undef max
 
80
#endif
 
81
 
 
82
 
 
83
Q_DECLARE_METATYPE(Qt::Key);
 
84
Q_DECLARE_METATYPE(Qt::KeyboardModifiers);
 
85
Q_DECLARE_METATYPE(Qt::KeyboardModifier);
 
86
 
 
87
#if defined(Q_OS_WINCE)
 
88
#ifndef SPI_GETPLATFORMTYPE
 
89
#define SPI_GETPLATFORMTYPE 257
 
90
#endif
 
91
 
 
92
bool qt_wince_is_platform(const QString &platformString) {
 
93
    wchar_t tszPlatform[64];
 
94
    if (SystemParametersInfo(SPI_GETPLATFORMTYPE,
 
95
                             sizeof(tszPlatform)/sizeof(*tszPlatform),tszPlatform,0))
 
96
      if (0 == _tcsicmp(reinterpret_cast<const wchar_t *> (platformString.utf16()), tszPlatform))
 
97
            return true;
 
98
    return false;
 
99
}
 
100
bool qt_wince_is_pocket_pc() {
 
101
    return qt_wince_is_platform(QString::fromLatin1("PocketPC"));
 
102
}
 
103
bool qt_wince_is_smartphone() {
 
104
       return qt_wince_is_platform(QString::fromLatin1("Smartphone"));
 
105
}
 
106
bool qt_wince_is_mobile() {
 
107
     return (qt_wince_is_smartphone() || qt_wince_is_pocket_pc());
 
108
}
 
109
#endif
 
110
 
 
111
class EditorDateEdit : public QDateTimeEdit
 
112
{
 
113
    Q_OBJECT
 
114
public:
 
115
    EditorDateEdit(QWidget *parent = 0) : QDateTimeEdit(parent) {}
 
116
    QLineEdit *lineEdit() { return QDateTimeEdit::lineEdit(); }
 
117
    friend class tst_QDateTimeEdit;
 
118
};
 
119
 
 
120
class tst_QDateTimeEdit : public QObject
 
121
{
 
122
    Q_OBJECT
 
123
 
 
124
private slots:
 
125
    void initTestCase();
 
126
    void init();
 
127
    void cleanup();
 
128
    void cleanupTestCase();
 
129
 
 
130
    void cachedDayTest();
 
131
    void getSetCheck();
 
132
    void constructor_qwidget();
 
133
    void constructor_qdatetime_data();
 
134
    void constructor_qdatetime();
 
135
    void constructor_qdate_data();
 
136
    void constructor_qdate();
 
137
    void constructor_qtime_data();
 
138
    void constructor_qtime();
 
139
 
 
140
    void sectionText_data();
 
141
    void sectionText();
 
142
    void dateTimeSignalChecking_data();
 
143
    void dateTimeSignalChecking();
 
144
    void mousePress();
 
145
    void stepHourAMPM_data();
 
146
 
 
147
    void stepHourAMPM();
 
148
    void displayedSections_data();
 
149
    void displayedSections();
 
150
    void currentSection_data();
 
151
    void currentSection();
 
152
 
 
153
    void setCurrentSection();
 
154
    void setCurrentSection_data();
 
155
 
 
156
    void minimumDate_data();
 
157
    void minimumDate();
 
158
    void maximumDate_data();
 
159
    void maximumDate();
 
160
    void clearMinimumDate_data();
 
161
    void clearMinimumDate();
 
162
    void clearMaximumDate_data();
 
163
    void clearMaximumDate();
 
164
 
 
165
    void minimumDateTime_data();
 
166
    void minimumDateTime();
 
167
    void maximumDateTime_data();
 
168
    void maximumDateTime();
 
169
 
 
170
    void clearMinimumDateTime_data();
 
171
    void clearMinimumDateTime();
 
172
    void clearMaximumDateTime_data();
 
173
    void clearMaximumDateTime();
 
174
 
 
175
    void displayFormat_data();
 
176
    void displayFormat();
 
177
 
 
178
    void specialValueText();
 
179
    void setRange_data();
 
180
    void setRange();
 
181
 
 
182
    void selectAndScrollWithKeys();
 
183
    void backspaceKey();
 
184
    void deleteKey();
 
185
    void tabKeyNavigation();
 
186
    void tabKeyNavigationWithPrefix();
 
187
    void tabKeyNavigationWithSuffix();
 
188
    void enterKey();
 
189
 
 
190
    void readOnly();
 
191
 
 
192
    void wrappingDate_data();
 
193
    void wrappingDate();
 
194
 
 
195
    void dateSignalChecking_data();
 
196
    void dateSignalChecking();
 
197
 
 
198
    void wrappingTime_data();
 
199
    void wrappingTime();
 
200
 
 
201
    void userKeyPress_Time_data();
 
202
    void userKeyPress_Time();
 
203
 
 
204
    void timeSignalChecking_data();
 
205
    void timeSignalChecking();
 
206
 
 
207
    void weirdCase();
 
208
    void newCase();
 
209
    void newCase2();
 
210
    void newCase3();
 
211
    void newCase4();
 
212
    void newCase5();
 
213
    void newCase6();
 
214
 
 
215
    void task98554();
 
216
    void task149097();
 
217
 
 
218
    void cursorPos();
 
219
    void calendarPopup();
 
220
 
 
221
    void hour12Test();
 
222
    void yyTest();
 
223
    void task108572();
 
224
 
 
225
    void task148725();
 
226
    void task148522();
 
227
 
 
228
    void setSelectedSection();
 
229
    void reverseTest();
 
230
 
 
231
    void ddMMMMyyyy();
 
232
#ifndef QT_NO_WHEELEVENT
 
233
    void wheelEvent();
 
234
#endif
 
235
 
 
236
    void specialValueCornerCase();
 
237
    void cursorPositionOnInit();
 
238
 
 
239
    void task118867();
 
240
 
 
241
    void nextPrevSection_data();
 
242
    void nextPrevSection();
 
243
 
 
244
    void dateEditTimeEditFormats();
 
245
    void timeSpec_data();
 
246
    void timeSpec();
 
247
    void timeSpecBug();
 
248
    void timeSpecInit();
 
249
 
 
250
    void monthEdgeCase();
 
251
    void setLocale();
 
252
 
 
253
    void potentialYYValueBug();
 
254
    void textSectionAtEnd();
 
255
 
 
256
    void keypadAutoAdvance_data();
 
257
    void keypadAutoAdvance();
 
258
 
 
259
    void task196924();
 
260
    void focusNextPrevChild();
 
261
 
 
262
    void taskQTBUG_12384_timeSpecShowTimeOnly();
 
263
 
 
264
    void deleteCalendarWidget();
 
265
 
 
266
#ifdef QT_BUILD_INTERNAL
 
267
    void dateEditCorrectSectionSize_data();
 
268
    void dateEditCorrectSectionSize();
 
269
#endif
 
270
private:
 
271
    EditorDateEdit* testWidget;
 
272
    QWidget *testFocusWidget;
 
273
};
 
274
 
 
275
typedef QList<QTime> TimeList;
 
276
typedef QList<Qt::Key> KeyList;
 
277
 
 
278
// Testing get/set functions
 
279
void tst_QDateTimeEdit::getSetCheck()
 
280
{
 
281
    QDateTimeEdit obj1;
 
282
    QCOMPARE(obj1.inputMethodQuery(Qt::ImHints), QVariant(int(Qt::ImhPreferNumbers)));
 
283
    obj1.setDisplayFormat("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z AP");
 
284
    // Section QDateTimeEdit::currentSection()
 
285
    // void QDateTimeEdit::setCurrentSection(Section)
 
286
    obj1.setCurrentSection(QDateTimeEdit::NoSection);
 
287
    QVERIFY(obj1.currentSection() != QDateTimeEdit::NoSection);
 
288
    obj1.setCurrentSection(QDateTimeEdit::AmPmSection);
 
289
    QCOMPARE(QDateTimeEdit::AmPmSection, obj1.currentSection());
 
290
    obj1.setCurrentSection(QDateTimeEdit::MSecSection);
 
291
    QCOMPARE(QDateTimeEdit::MSecSection, obj1.currentSection());
 
292
    obj1.setCurrentSection(QDateTimeEdit::SecondSection);
 
293
    QCOMPARE(QDateTimeEdit::SecondSection, obj1.currentSection());
 
294
    obj1.setCurrentSection(QDateTimeEdit::MinuteSection);
 
295
    QCOMPARE(QDateTimeEdit::MinuteSection, obj1.currentSection());
 
296
    obj1.setCurrentSection(QDateTimeEdit::HourSection);
 
297
    QCOMPARE(QDateTimeEdit::HourSection, obj1.currentSection());
 
298
    obj1.setCurrentSection(QDateTimeEdit::DaySection);
 
299
    QCOMPARE(QDateTimeEdit::DaySection, obj1.currentSection());
 
300
    obj1.setCurrentSection(QDateTimeEdit::MonthSection);
 
301
    QCOMPARE(QDateTimeEdit::MonthSection, obj1.currentSection());
 
302
    obj1.setCurrentSection(QDateTimeEdit::YearSection);
 
303
    QCOMPARE(QDateTimeEdit::YearSection, obj1.currentSection());
 
304
 
 
305
    QDateEdit dateEdit;
 
306
    QCOMPARE(dateEdit.inputMethodQuery(Qt::ImHints), QVariant(int(Qt::ImhPreferNumbers)));
 
307
    QTimeEdit timeEdit;
 
308
    QCOMPARE(timeEdit.inputMethodQuery(Qt::ImHints), QVariant(int(Qt::ImhPreferNumbers)));
 
309
}
 
310
 
 
311
void tst_QDateTimeEdit::initTestCase()
 
312
{
 
313
    QLocale system = QLocale::system();
 
314
    if (system.language() != QLocale::C && system.language() != QLocale::English)
 
315
        qWarning("Running under locale %s/%s -- this test may generate failures due to language differences",
 
316
                 qPrintable(QLocale::languageToString(system.language())),
 
317
                 qPrintable(QLocale::countryToString(system.country())));
 
318
    testWidget = new EditorDateEdit(0);
 
319
    testFocusWidget = new QWidget(0);
 
320
    testFocusWidget->resize(200, 100);
 
321
    testFocusWidget->show();
 
322
}
 
323
 
 
324
void tst_QDateTimeEdit::cleanupTestCase()
 
325
{
 
326
    delete testFocusWidget;
 
327
    testFocusWidget = 0;
 
328
    delete testWidget;
 
329
    testWidget = 0;
 
330
}
 
331
 
 
332
void tst_QDateTimeEdit::init()
 
333
{
 
334
    QLocale::setDefault(QLocale(QLocale::C));
 
335
#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
 
336
    SetThreadLocale(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT));
 
337
#endif
 
338
    testWidget->setDisplayFormat("dd/MM/yyyy"); // Nice default to have
 
339
    testWidget->setDateTime(QDateTime(QDate(2000, 1, 1), QTime(0, 0)));
 
340
    testWidget->show();
 
341
    testFocusWidget->move(-1000, -1000);
 
342
}
 
343
 
 
344
void tst_QDateTimeEdit::cleanup()
 
345
{
 
346
    testWidget->clearMinimumDateTime();
 
347
    testWidget->clearMaximumDateTime();
 
348
    testWidget->setTimeSpec(Qt::LocalTime);
 
349
    testWidget->setSpecialValueText(QString());
 
350
    testWidget->setWrapping(false);
 
351
}
 
352
 
 
353
void tst_QDateTimeEdit::constructor_qwidget()
 
354
{
 
355
    testWidget->hide();
 
356
    QDateTimeEdit dte(0);
 
357
    dte.show();
 
358
    QCOMPARE(dte.dateTime(), QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0)));
 
359
    QCOMPARE(dte.minimumDate(), QDate(1752, 9, 14));
 
360
    QCOMPARE(dte.minimumTime(), QTime(0, 0, 0, 0));
 
361
    QCOMPARE(dte.maximumDate(), QDate(7999, 12, 31));
 
362
    QCOMPARE(dte.maximumTime(), QTime(23, 59, 59, 999));
 
363
}
 
364
 
 
365
void tst_QDateTimeEdit::constructor_qdatetime_data()
 
366
{
 
367
    QTest::addColumn<QDateTime>("parameter");
 
368
    QTest::addColumn<QDateTime>("displayDateTime");
 
369
    QTest::addColumn<QDate>("minimumDate");
 
370
    QTest::addColumn<QTime>("minimumTime");
 
371
    QTest::addColumn<QDate>("maximumDate");
 
372
    QTest::addColumn<QTime>("maximumTime");
 
373
 
 
374
    QTest::newRow("normal") << QDateTime(QDate(2004, 6, 16), QTime(13, 46, 32, 764))
 
375
                            << QDateTime(QDate(2004, 6, 16), QTime(13, 46, 32, 764))
 
376
                            << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
 
377
                            << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
 
378
 
 
379
    QTest::newRow("invalid") << QDateTime(QDate(9999, 99, 99), QTime(13, 46, 32, 764))
 
380
                             << QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0))
 
381
                             << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
 
382
                             << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
 
383
}
 
384
 
 
385
void tst_QDateTimeEdit::constructor_qdatetime()
 
386
{
 
387
    QFETCH(QDateTime, parameter);
 
388
    QFETCH(QDateTime, displayDateTime);
 
389
    QFETCH(QDate, minimumDate);
 
390
    QFETCH(QTime, minimumTime);
 
391
    QFETCH(QDate, maximumDate);
 
392
    QFETCH(QTime, maximumTime);
 
393
 
 
394
    testWidget->hide();
 
395
 
 
396
    QDateTimeEdit dte(parameter);
 
397
    dte.show();
 
398
    QCOMPARE(dte.dateTime(), displayDateTime);
 
399
    QCOMPARE(dte.minimumDate(), minimumDate);
 
400
    QCOMPARE(dte.minimumTime(), minimumTime);
 
401
    QCOMPARE(dte.maximumDate(), maximumDate);
 
402
    QCOMPARE(dte.maximumTime(), maximumTime);
 
403
}
 
404
 
 
405
void tst_QDateTimeEdit::constructor_qdate_data()
 
406
{
 
407
    QTest::addColumn<QDate>("parameter");
 
408
    QTest::addColumn<QDateTime>("displayDateTime");
 
409
    QTest::addColumn<QDate>("minimumDate");
 
410
    QTest::addColumn<QTime>("minimumTime");
 
411
    QTest::addColumn<QDate>("maximumDate");
 
412
    QTest::addColumn<QTime>("maximumTime");
 
413
 
 
414
    QTest::newRow("normal") << QDate(2004, 6, 16)
 
415
                            << QDateTime(QDate(2004, 6, 16), QTime(0, 0, 0, 0))
 
416
                            << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
 
417
                            << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
 
418
 
 
419
    QTest::newRow("invalid") << QDate(9999, 99, 99)
 
420
                             << QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0))
 
421
                             << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
 
422
                             << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
 
423
}
 
424
 
 
425
void tst_QDateTimeEdit::constructor_qdate()
 
426
{
 
427
    QFETCH(QDate, parameter);
 
428
    QFETCH(QDateTime, displayDateTime);
 
429
    QFETCH(QDate, minimumDate);
 
430
    QFETCH(QTime, minimumTime);
 
431
    QFETCH(QDate, maximumDate);
 
432
    QFETCH(QTime, maximumTime);
 
433
 
 
434
    testWidget->hide();
 
435
 
 
436
    QDateTimeEdit dte(parameter);
 
437
    dte.show();
 
438
    QCOMPARE(dte.dateTime(), displayDateTime);
 
439
    QCOMPARE(dte.minimumDate(), minimumDate);
 
440
    QCOMPARE(dte.minimumTime(), minimumTime);
 
441
    QCOMPARE(dte.maximumDate(), maximumDate);
 
442
    QCOMPARE(dte.maximumTime(), maximumTime);
 
443
}
 
444
 
 
445
void tst_QDateTimeEdit::constructor_qtime_data()
 
446
{
 
447
    QTest::addColumn<QTime>("parameter");
 
448
    QTest::addColumn<QDateTime>("displayDateTime");
 
449
    QTest::addColumn<QDate>("minimumDate");
 
450
    QTest::addColumn<QTime>("minimumTime");
 
451
    QTest::addColumn<QDate>("maximumDate");
 
452
    QTest::addColumn<QTime>("maximumTime");
 
453
 
 
454
    QTest::newRow("normal") << QTime(13, 46, 32, 764)
 
455
                            << QDateTime(QDate(2000, 1, 1), QTime(13, 46, 32, 764))
 
456
                            << QDate(2000, 1, 1) << QTime(0, 0, 0, 0)
 
457
                            << QDate(2000, 1, 1) << QTime(23, 59, 59, 999);
 
458
 
 
459
    QTest::newRow("invalid") << QTime(99, 99, 99, 5000)
 
460
                             << QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0))
 
461
                             << QDate(2000, 1, 1) << QTime(0, 0, 0, 0)
 
462
                             << QDate(2000, 1, 1) << QTime(23, 59, 59, 999);
 
463
}
 
464
 
 
465
void tst_QDateTimeEdit::constructor_qtime()
 
466
{
 
467
    QFETCH(QTime, parameter);
 
468
    QFETCH(QDateTime, displayDateTime);
 
469
    QFETCH(QDate, minimumDate);
 
470
    QFETCH(QTime, minimumTime);
 
471
    QFETCH(QDate, maximumDate);
 
472
    QFETCH(QTime, maximumTime);
 
473
 
 
474
    testWidget->hide();
 
475
 
 
476
    QDateTimeEdit dte(parameter);
 
477
    dte.show();
 
478
    QCOMPARE(dte.dateTime(), displayDateTime);
 
479
    QCOMPARE(dte.minimumDate(), minimumDate);
 
480
    QCOMPARE(dte.minimumTime(), minimumTime);
 
481
    QCOMPARE(dte.maximumDate(), maximumDate);
 
482
    QCOMPARE(dte.maximumTime(), maximumTime);
 
483
}
 
484
 
 
485
void tst_QDateTimeEdit::minimumDate_data()
 
486
{
 
487
    QTest::addColumn<QDate>("minimumDate");
 
488
    QTest::addColumn<QDate>("expectedMinDate");
 
489
 
 
490
    QTest::newRow("normal-0") << QDate(2004, 5, 10) << QDate(2004, 5, 10);
 
491
    QTest::newRow("normal-1") << QDate(2002, 3, 15) << QDate(2002, 3, 15);
 
492
    QTest::newRow("normal-2") << QDate(7999, 12, 31) << QDate(7999, 12, 31);
 
493
    QTest::newRow("normal-3") << QDate(1753, 1, 1) << QDate(1753, 1, 1);
 
494
    QTest::newRow("invalid-0") << QDate(0, 0, 0) << QDate(1752, 9, 14);
 
495
    QTest::newRow("old") << QDate(1492, 8, 3) << QDate(1492, 8, 3);
 
496
}
 
497
 
 
498
void tst_QDateTimeEdit::minimumDate()
 
499
{
 
500
    QFETCH(QDate, minimumDate);
 
501
    QFETCH(QDate, expectedMinDate);
 
502
 
 
503
    testWidget->setMinimumDate(minimumDate);
 
504
    QCOMPARE(testWidget->minimumDate(), expectedMinDate);
 
505
}
 
506
 
 
507
void tst_QDateTimeEdit::minimumDateTime_data()
 
508
{
 
509
    QTest::addColumn<QDateTime>("minimumDateTime");
 
510
    QTest::addColumn<QDateTime>("expectedMinDateTime");
 
511
 
 
512
    QTest::newRow("normal-0") << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14))
 
513
                              << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14));
 
514
 
 
515
    QTest::newRow("normal-1") << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1))
 
516
                              << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1));
 
517
    QTest::newRow("normal-2") << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23))
 
518
                              << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23));
 
519
    QTest::newRow("normal-3") << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23))
 
520
                              << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23));
 
521
    QTest::newRow("normal-4") << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1))
 
522
                              << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1));
 
523
    QTest::newRow("invalid-0") << QDateTime() << QDateTime(QDate(1752, 9, 14), QTime(0, 0, 0));
 
524
    QTest::newRow("old") << QDateTime(QDate(1492, 8, 3), QTime(2, 3, 1))
 
525
                         << QDateTime(QDate(1492, 8, 3), QTime(2, 3, 1));
 
526
}
 
527
 
 
528
void tst_QDateTimeEdit::minimumDateTime()
 
529
{
 
530
    QFETCH(QDateTime, minimumDateTime);
 
531
    QFETCH(QDateTime, expectedMinDateTime);
 
532
 
 
533
    testWidget->setMinimumDateTime(minimumDateTime);
 
534
    QCOMPARE(testWidget->minimumDateTime(), expectedMinDateTime);
 
535
}
 
536
 
 
537
void tst_QDateTimeEdit::maximumDateTime_data()
 
538
{
 
539
    QTest::addColumn<QDateTime>("maximumDateTime");
 
540
    QTest::addColumn<QDateTime>("expectedMinDateTime");
 
541
 
 
542
    QTest::newRow("normal-0") << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14))
 
543
                              << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14));
 
544
 
 
545
    QTest::newRow("normal-1") << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1))
 
546
                              << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1));
 
547
    QTest::newRow("normal-2") << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23))
 
548
                              << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23));
 
549
    QTest::newRow("normal-3") << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23))
 
550
                              << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23));
 
551
    QTest::newRow("normal-4") << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1))
 
552
                              << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1));
 
553
    QTest::newRow("invalid-0") << QDateTime() << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
 
554
}
 
555
 
 
556
void tst_QDateTimeEdit::maximumDateTime()
 
557
{
 
558
    QFETCH(QDateTime, maximumDateTime);
 
559
    QFETCH(QDateTime, expectedMinDateTime);
 
560
 
 
561
    testWidget->setMaximumDateTime(maximumDateTime);
 
562
    QCOMPARE(testWidget->maximumDateTime(), expectedMinDateTime);
 
563
}
 
564
 
 
565
void tst_QDateTimeEdit::maximumDate_data()
 
566
{
 
567
    QTest::addColumn<QDate>("maximumDate");
 
568
    QTest::addColumn<QDate>("expectedMaxDate");
 
569
 
 
570
    QTest::newRow("normal-0") << QDate(2004, 05, 10) << QDate(2004, 5, 10);
 
571
    QTest::newRow("normal-1") << QDate(2002, 03, 15) << QDate(2002, 3, 15);
 
572
    QTest::newRow("normal-2") << QDate(7999, 12, 31) << QDate(7999, 12, 31);
 
573
    QTest::newRow("normal-3") << QDate(1753, 1, 1) << QDate(1753, 1, 1);
 
574
    QTest::newRow("invalid-0") << QDate(0, 0, 0) << QDate(7999, 12, 31);
 
575
}
 
576
 
 
577
void tst_QDateTimeEdit::maximumDate()
 
578
{
 
579
    QFETCH(QDate, maximumDate);
 
580
    QFETCH(QDate, expectedMaxDate);
 
581
 
 
582
    testWidget->setMaximumDate(maximumDate);
 
583
    QCOMPARE(testWidget->maximumDate(), expectedMaxDate);
 
584
}
 
585
 
 
586
void tst_QDateTimeEdit::clearMinimumDate_data()
 
587
{
 
588
    QTest::addColumn<QDate>("minimumDate");
 
589
    QTest::addColumn<bool>("valid");
 
590
    QTest::addColumn<QDate>("expectedMinDateAfterClear");
 
591
 
 
592
    QTest::newRow("normal-0") << QDate(2004, 05, 10) << true << QDate(1752, 9, 14);
 
593
    QTest::newRow("normal-1") << QDate(2002, 3, 15) << true << QDate(1752, 9, 14);
 
594
    QTest::newRow("normal-2") << QDate(7999, 12, 31) << true << QDate(1752, 9, 14);
 
595
    QTest::newRow("normal-3") << QDate(1753, 1, 1) << true << QDate(1752, 9, 14);
 
596
    QTest::newRow("invalid-0") << QDate(0, 0, 0) << false << QDate(1752, 9, 14);
 
597
}
 
598
 
 
599
void tst_QDateTimeEdit::clearMinimumDate()
 
600
{
 
601
    QFETCH(QDate, minimumDate);
 
602
    QFETCH(bool, valid);
 
603
    QFETCH(QDate, expectedMinDateAfterClear);
 
604
 
 
605
    testWidget->setMinimumDate(minimumDate);
 
606
    if (valid)
 
607
        QCOMPARE(testWidget->minimumDate(), minimumDate);
 
608
    testWidget->clearMinimumDate();
 
609
    QCOMPARE(testWidget->minimumDate(), expectedMinDateAfterClear);
 
610
}
 
611
 
 
612
void tst_QDateTimeEdit::clearMinimumDateTime_data()
 
613
{
 
614
    QTest::addColumn<QDateTime>("minimumDateTime");
 
615
    QTest::addColumn<bool>("valid");
 
616
    QTest::addColumn<QDateTime>("expectedMinDateTimeAfterClear");
 
617
 
 
618
    QTest::newRow("normal-0") << QDateTime(QDate(2004, 05, 10), QTime(12, 12, 12))
 
619
                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
 
620
    QTest::newRow("normal-1") << QDateTime(QDate(2002, 3, 15), QTime(13, 13, 13))
 
621
                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
 
622
    QTest::newRow("normal-2") << QDateTime(QDate(7999, 12, 31), QTime(14, 14, 14))
 
623
                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
 
624
    QTest::newRow("normal-3") << QDateTime(QDate(1753, 1, 1), QTime(15, 15, 15))
 
625
                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
 
626
    QTest::newRow("invalid-0") << QDateTime() << false << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
 
627
    QTest::newRow("old") << QDateTime(QDate(1492, 8, 3), QTime(2, 3, 1)) << true
 
628
                         << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
 
629
}
 
630
 
 
631
void tst_QDateTimeEdit::clearMinimumDateTime()
 
632
{
 
633
    QFETCH(QDateTime, minimumDateTime);
 
634
    QFETCH(bool, valid);
 
635
    QFETCH(QDateTime, expectedMinDateTimeAfterClear);
 
636
 
 
637
    testWidget->setMinimumDateTime(minimumDateTime);
 
638
    if (valid)
 
639
        QCOMPARE(testWidget->minimumDateTime(), minimumDateTime);
 
640
    testWidget->clearMinimumDateTime();
 
641
    QCOMPARE(testWidget->minimumDateTime(), expectedMinDateTimeAfterClear);
 
642
}
 
643
 
 
644
void tst_QDateTimeEdit::clearMaximumDateTime_data()
 
645
{
 
646
    QTest::addColumn<QDateTime>("maximumDateTime");
 
647
    QTest::addColumn<bool>("valid");
 
648
    QTest::addColumn<QDateTime>("expectedMinDateTimeAfterClear");
 
649
 
 
650
    QTest::newRow("normal-0") << QDateTime(QDate(2004, 05, 10), QTime(12, 12, 12))
 
651
                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
 
652
    QTest::newRow("normal-1") << QDateTime(QDate(2002, 3, 15), QTime(13, 13, 13))
 
653
                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
 
654
    QTest::newRow("normal-2") << QDateTime(QDate(7999, 12, 31), QTime(14, 14, 14))
 
655
                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
 
656
    QTest::newRow("normal-3") << QDateTime(QDate(1753, 1, 1), QTime(15, 15, 15))
 
657
                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
 
658
    QTest::newRow("invalid-0") << QDateTime()
 
659
                               << false << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
 
660
}
 
661
 
 
662
void tst_QDateTimeEdit::clearMaximumDateTime()
 
663
{
 
664
    QFETCH(QDateTime, maximumDateTime);
 
665
    QFETCH(bool, valid);
 
666
    QFETCH(QDateTime, expectedMinDateTimeAfterClear);
 
667
 
 
668
    testWidget->setMaximumDateTime(maximumDateTime);
 
669
    if (valid)
 
670
        QCOMPARE(testWidget->maximumDateTime(), maximumDateTime);
 
671
    testWidget->clearMaximumDateTime();
 
672
    QCOMPARE(testWidget->maximumDateTime(), expectedMinDateTimeAfterClear);
 
673
}
 
674
 
 
675
void tst_QDateTimeEdit::clearMaximumDate_data()
 
676
{
 
677
    QTest::addColumn<QDate>("maximumDate");
 
678
    QTest::addColumn<bool>("valid");
 
679
    QTest::addColumn<QDate>("expectedMaxDateAfterClear");
 
680
 
 
681
    QTest::newRow("normal-0") << QDate(2004, 05, 10) << true << QDate(7999, 12, 31);
 
682
    QTest::newRow("normal-1") << QDate(2002, 03, 15) << true << QDate(7999, 12, 31);
 
683
    QTest::newRow("normal-2") << QDate(7999, 12, 31) << true << QDate(7999, 12, 31);
 
684
    QTest::newRow("normal-3") << QDate(2000, 1, 1) << true << QDate(7999, 12, 31);
 
685
    QTest::newRow("invalid-0") << QDate(0, 0, 0) << false << QDate(7999, 12, 31);
 
686
}
 
687
 
 
688
void tst_QDateTimeEdit::clearMaximumDate()
 
689
{
 
690
    QFETCH(QDate, maximumDate);
 
691
    QFETCH(bool, valid);
 
692
    QFETCH(QDate, expectedMaxDateAfterClear);
 
693
 
 
694
    testWidget->setMaximumDate(maximumDate);
 
695
    if (valid)
 
696
        QCOMPARE(testWidget->maximumDate(), maximumDate);
 
697
    testWidget->clearMaximumDate();
 
698
    QCOMPARE(testWidget->maximumDate(), expectedMaxDateAfterClear);
 
699
}
 
700
 
 
701
void tst_QDateTimeEdit::displayFormat_data()
 
702
{
 
703
    QTest::addColumn<QString>("format");
 
704
    QTest::addColumn<bool>("valid");
 
705
    QTest::addColumn<QString>("text");
 
706
    QTest::addColumn<QDateTime>("date");
 
707
 
 
708
    const QDateTime dt(QDate(2999, 12, 31), QTime(3, 59, 59, 999));
 
709
 
 
710
    QTest::newRow("valid-0") << QString("yyyy MM dd") << true << QString("2999 12 31") << dt;
 
711
    QTest::newRow("valid-1") << QString("dd MM yyyy::ss:mm:hh") << true
 
712
                             << QString("31 12 2999::59:59:03") << dt;
 
713
    QTest::newRow("valid-2") << QString("hh-dd-mm-MM-yy") << true << QString("03-31-59-12-99") << dt;
 
714
    QTest::newRow("valid-3") << QString("ddd MM d yyyy::ss:mm:hh") << true
 
715
                             << QDate::shortDayName(2) + " 12 31 2999::59:59:03" << dt;
 
716
    QTest::newRow("valid-4") << QString("hh-dd-mm-MM-yyyy") << true << QString("03-31-59-12-2999") << dt;
 
717
    QTest::newRow("invalid-0") << QString("yyyy.MM.yy") << true << QString("2999.12.99") << dt;
 
718
    QTest::newRow("invalid-1") << QString("y") << false << QString() << dt;
 
719
    QTest::newRow("invalid-2") << QString("") << false << QString() << dt;
 
720
    QTest::newRow("quoted-1") << QString("'Midday is at:' dd") << true << QString("Midday is at: 31") << dt;
 
721
    QTest::newRow("leading1") << QString("h:hh:hhh") << true << QString("3:03:033") << dt;
 
722
    QTest::newRow("H1") << QString("HH:hh:ap") << true << QString("03:03:am") << dt;
 
723
    QTest::newRow("H2") << QString("HH:hh:ap") << true << QString("23:11:pm")
 
724
                        << QDateTime(dt.date(), QTime(23, 0, 0));
 
725
}
 
726
 
 
727
void tst_QDateTimeEdit::displayFormat()
 
728
{
 
729
    QFETCH(QString, format);
 
730
    QFETCH(bool, valid);
 
731
    QFETCH(QString, text);
 
732
    QFETCH(QDateTime, date);
 
733
 
 
734
    testWidget->setDateTime(date);
 
735
 
 
736
    QString compareFormat = format;
 
737
    if (!valid)
 
738
        compareFormat = testWidget->displayFormat();
 
739
    testWidget->setDisplayFormat(format);
 
740
    QCOMPARE(testWidget->displayFormat(), compareFormat);
 
741
    if (valid)
 
742
        QCOMPARE(testWidget->text(), text);
 
743
}
 
744
 
 
745
void tst_QDateTimeEdit::selectAndScrollWithKeys()
 
746
{
 
747
#ifdef Q_OS_MAC
 
748
    QSKIP("QTBUG-23674");
 
749
    return;
 
750
#endif
 
751
 
 
752
    qApp->setActiveWindow(testWidget);
 
753
    testWidget->setDate(QDate(2004, 05, 11));
 
754
    testWidget->setDisplayFormat("dd/MM/yyyy");
 
755
    testWidget->show();
 
756
#ifdef Q_OS_MAC
 
757
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
758
#else
 
759
    QTest::keyClick(testWidget, Qt::Key_Home);
 
760
#endif
 
761
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
762
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("1"));
 
763
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
764
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
765
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
766
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/"));
 
767
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
768
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/0"));
 
769
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
770
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05"));
 
771
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
772
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/"));
 
773
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
774
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2"));
 
775
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
776
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/20"));
 
777
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
778
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/200"));
 
779
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
780
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
 
781
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
782
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
 
783
 
 
784
    // Now the year part should be selected
 
785
    QTest::keyClick(testWidget, Qt::Key_Up);
 
786
    QCOMPARE(testWidget->date(), QDate(2005, 5, 11));
 
787
    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::YearSection);
 
788
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2005"));
 
789
    QTest::keyClick(testWidget, Qt::Key_Down);
 
790
    QCOMPARE(testWidget->date(), QDate(2004, 5, 11));
 
791
    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::YearSection);
 
792
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
 
793
 
 
794
 
 
795
#ifdef Q_OS_MAC
 
796
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
797
#else
 
798
    QTest::keyClick(testWidget, Qt::Key_End);
 
799
#endif
 
800
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
801
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("4"));
 
802
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
803
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("04"));
 
804
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
805
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("004"));
 
806
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
807
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
 
808
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
809
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("/2004"));
 
810
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
811
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("5/2004"));
 
812
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
813
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05/2004"));
 
814
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
815
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("/05/2004"));
 
816
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
817
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("1/05/2004"));
 
818
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
819
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
 
820
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
821
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
 
822
#ifdef Q_OS_MAC
 
823
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
824
#else
 
825
    QTest::keyClick(testWidget, Qt::Key_Home);
 
826
#endif
 
827
 
 
828
    // Now the day part should be selected
 
829
    QTest::keyClick(testWidget, Qt::Key_Up);
 
830
    QCOMPARE(testWidget->date(), QDate(2004, 5, 12));
 
831
    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::DaySection);
 
832
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("12"));
 
833
    QTest::keyClick(testWidget, Qt::Key_Down);
 
834
    QCOMPARE(testWidget->date(), QDate(2004, 5, 11));
 
835
    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::DaySection);
 
836
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
837
 
 
838
#ifdef Q_OS_MAC
 
839
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
840
#else
 
841
    QTest::keyClick(testWidget, Qt::Key_Home);
 
842
#endif
 
843
 
 
844
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
845
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
 
846
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
847
    // Now the day part should be selected
 
848
    QTest::keyClick(testWidget, Qt::Key_Up);
 
849
    QCOMPARE(testWidget->date(), QDate(2004, 05, 12));
 
850
}
 
851
 
 
852
void tst_QDateTimeEdit::backspaceKey()
 
853
{
 
854
    qApp->setActiveWindow(testWidget);
 
855
    testWidget->setDate(QDate(2004, 05, 11));
 
856
    testWidget->setDisplayFormat("d/MM/yyyy");
 
857
    testWidget->show();
 
858
#ifdef Q_OS_MAC
 
859
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
860
#else
 
861
    QTest::keyClick(testWidget, Qt::Key_End);
 
862
#endif
 
863
    QCOMPARE(testWidget->text(), QString("11/05/2004"));
 
864
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
865
#ifdef Q_OS_MAC
 
866
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
867
#endif
 
868
    QCOMPARE(testWidget->text(), QString("11/05/200"));
 
869
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
870
    QCOMPARE(testWidget->text(), QString("11/05/20"));
 
871
    // Check that moving into another field reverts it
 
872
    for (int i=0;i<3;i++)
 
873
        QTest::keyClick(testWidget, Qt::Key_Left);
 
874
    QCOMPARE(testWidget->text(), QString("11/05/2004"));
 
875
#ifdef Q_OS_MAC
 
876
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
877
#else
 
878
    QTest::keyClick(testWidget, Qt::Key_End);
 
879
#endif
 
880
    for (int i=0;i<4;i++)
 
881
        QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
 
882
 
 
883
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
884
    QCOMPARE(testWidget->text(), QString("11/05/"));
 
885
    QTest::keyClick(testWidget, Qt::Key_Left);
 
886
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
887
    QCOMPARE(testWidget->text(), QString("11/0/2004"));
 
888
    testWidget->interpretText();
 
889
#ifdef Q_OS_MAC
 
890
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
891
#else
 
892
    QTest::keyClick(testWidget, Qt::Key_End);
 
893
#endif
 
894
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
895
    QCOMPARE(testWidget->text(), QString("11/05/200"));
 
896
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
897
    QCOMPARE(testWidget->text(), QString("11/05/20"));
 
898
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
899
    QCOMPARE(testWidget->text(), QString("11/05/2"));
 
900
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
901
    QCOMPARE(testWidget->text(), QString("11/05/"));
 
902
    QTest::keyClick(testWidget, Qt::Key_Left);
 
903
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
904
    QCOMPARE(testWidget->text(), QString("11/0/2004"));
 
905
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
906
    QCOMPARE(testWidget->text(), QString("11//2004"));
 
907
    QTest::keyClick(testWidget, Qt::Key_Left);
 
908
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
909
    QCOMPARE(testWidget->text(), QString("1/05/2004"));
 
910
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
911
    QCOMPARE(testWidget->text(), QString("/05/2004"));
 
912
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
913
    QCOMPARE(testWidget->text(), QString("/05/2004"));
 
914
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
915
    QCOMPARE(testWidget->text(), QString("1/05/2004"));
 
916
}
 
917
 
 
918
void tst_QDateTimeEdit::deleteKey()
 
919
{
 
920
    qApp->setActiveWindow(testWidget);
 
921
    testWidget->setDate(QDate(2004, 05, 11));
 
922
    testWidget->setDisplayFormat("d/MM/yyyy");
 
923
#ifdef Q_OS_MAC
 
924
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
925
#else
 
926
    QTest::keyClick(testWidget, Qt::Key_Home);
 
927
#endif
 
928
    QTest::keyClick(testWidget, Qt::Key_Delete);
 
929
    QCOMPARE(testWidget->text(), QString("1/05/2004"));
 
930
    QTest::keyClick(testWidget, Qt::Key_Delete);
 
931
    QCOMPARE(testWidget->text(), QString("/05/2004"));
 
932
    QTest::keyClick(testWidget, Qt::Key_Right);
 
933
    QTest::keyClick(testWidget, Qt::Key_Right);
 
934
    QCOMPARE(testWidget->text(), QString("1/05/2004"));
 
935
}
 
936
 
 
937
void tst_QDateTimeEdit::tabKeyNavigation()
 
938
{
 
939
    qApp->setActiveWindow(testWidget);
 
940
    testWidget->setDate(QDate(2004, 05, 11));
 
941
    testWidget->setDisplayFormat("dd/MM/yyyy");
 
942
    testWidget->show();
 
943
    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
 
944
 
 
945
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
946
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
 
947
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
948
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
 
949
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
950
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
 
951
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
952
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
953
}
 
954
 
 
955
void tst_QDateTimeEdit::tabKeyNavigationWithPrefix()
 
956
{
 
957
    qApp->setActiveWindow(testWidget);
 
958
    testWidget->setDate(QDate(2004, 05, 11));
 
959
    testWidget->setDisplayFormat("prefix dd/MM/yyyy");
 
960
 
 
961
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
962
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
963
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
964
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
 
965
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
966
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
 
967
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
968
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
 
969
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
970
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
971
}
 
972
 
 
973
void tst_QDateTimeEdit::tabKeyNavigationWithSuffix()
 
974
{
 
975
    qApp->setActiveWindow(testWidget);
 
976
    testWidget->setDate(QDate(2004, 05, 11));
 
977
    testWidget->setDisplayFormat("dd/MM/yyyy 'suffix'");
 
978
 
 
979
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
980
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
 
981
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
982
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
 
983
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
984
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
 
985
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
986
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
987
}
 
988
 
 
989
void tst_QDateTimeEdit::enterKey()
 
990
{
 
991
    qApp->setActiveWindow(testWidget);
 
992
    testWidget->setDate(QDate(2004, 5, 11));
 
993
    testWidget->setDisplayFormat("prefix d/MM/yyyy 'suffix'");
 
994
    testWidget->lineEdit()->setFocus();
 
995
 
 
996
#ifdef Q_OS_MAC
 
997
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
998
#else
 
999
    QTest::keyClick(testWidget, Qt::Key_Home);
 
1000
#endif
 
1001
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1002
#ifdef Q_OS_MAC
 
1003
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
1004
#endif
 
1005
    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
 
1006
#ifdef Q_OS_MAC
 
1007
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
1008
#else
 
1009
    QTest::keyClick(testWidget, Qt::Key_End);
 
1010
#endif
 
1011
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1012
    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
 
1013
#ifdef Q_OS_MAC
 
1014
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
1015
#else
 
1016
    QTest::keyClick(testWidget, Qt::Key_Home);
 
1017
#endif
 
1018
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
1019
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1020
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
1021
    QTest::keyClick(testWidget, Qt::Key_1);
 
1022
    QTest::keyClick(testWidget, Qt::Key_5);
 
1023
 
 
1024
    QTest::keyClick(testWidget, Qt::Key_Left);
 
1025
    QTest::keyClick(testWidget, Qt::Key_Left);
 
1026
 
 
1027
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1028
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("15"));
 
1029
    QCOMPARE(testWidget->date(), QDate(2004, 5, 15));
 
1030
 
 
1031
    QTest::keyClick(testWidget, Qt::Key_9);
 
1032
    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
 
1033
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1034
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("9"));
 
1035
    QCOMPARE(testWidget->date(), QDate(2004, 5, 9));
 
1036
 
 
1037
    QTest::keyClick(testWidget, Qt::Key_0);
 
1038
    QTest::keyClick(testWidget, Qt::Key_0);
 
1039
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1040
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("9"));
 
1041
    QCOMPARE(testWidget->date(), QDate(2004, 5, 9));
 
1042
 
 
1043
    // Current behaviour is that pressing the Enter key in a QDateTimeEdit
 
1044
    // causes the dateChanged() signal to be emitted, even if the date
 
1045
    // wasn't actually changed.  While this behaviour is questionable,
 
1046
    // we include this test so a change to the behaviour can't go unnoticed.
 
1047
    QSignalSpy enterSpy(testWidget, SIGNAL(dateChanged(QDate)));
 
1048
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1049
    QCOMPARE(enterSpy.count(), 1);
 
1050
    QVariantList list = enterSpy.takeFirst();
 
1051
    QCOMPARE(list.at(0).toDate(), QDate(2004, 5, 9));
 
1052
}
 
1053
 
 
1054
void tst_QDateTimeEdit::specialValueText()
 
1055
{
 
1056
    testWidget->setDisplayFormat("dd/MM/yyyy");
 
1057
    testWidget->setDateRange(QDate(2000, 1, 1), QDate(2001, 1, 1));
 
1058
    testWidget->setDate(QDate(2000, 1, 2));
 
1059
    testWidget->setSpecialValueText("fOo");
 
1060
    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
 
1061
    QCOMPARE(testWidget->date(), QDate(2000, 1, 2));
 
1062
    QCOMPARE(testWidget->text(), QString("02/01/2000"));
 
1063
    QTest::keyClick(testWidget, Qt::Key_Down);
 
1064
    QCOMPARE(testWidget->date(), QDate(2000, 1, 1));
 
1065
    QCOMPARE(testWidget->text(), QString("fOo"));
 
1066
    QTest::keyClick(testWidget, Qt::Key_Down);
 
1067
    QCOMPARE(testWidget->date(), QDate(2000, 1, 1));
 
1068
    QCOMPARE(testWidget->text(), QString("fOo"));
 
1069
    QTest::keyClick(testWidget, Qt::Key_Up);
 
1070
    QCOMPARE(testWidget->date(), QDate(2000, 1, 2));
 
1071
    QCOMPARE(testWidget->text(), QString("02/01/2000"));
 
1072
    QTest::keyClick(testWidget, Qt::Key_Down);
 
1073
    QCOMPARE(testWidget->date(), QDate(2000, 1, 1));
 
1074
    QCOMPARE(testWidget->text(), QString("fOo"));
 
1075
 
 
1076
#ifdef Q_OS_MAC
 
1077
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
1078
#else
 
1079
    QTest::keyClick(testWidget, Qt::Key_End);
 
1080
#endif
 
1081
    QTest::keyClick(testWidget, Qt::Key_Up);
 
1082
    QCOMPARE(testWidget->date(), QDate(2000, 1, 2));
 
1083
    QCOMPARE(testWidget->text(), QString("02/01/2000"));
 
1084
    QTest::keyClick(testWidget, Qt::Key_Down);
 
1085
    QCOMPARE(testWidget->text(), QString("fOo"));
 
1086
 
 
1087
#ifdef Q_OS_MAC
 
1088
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
1089
#else
 
1090
    QTest::keyClick(testWidget, Qt::Key_End);
 
1091
#endif
 
1092
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
1093
    QCOMPARE(testWidget->text(), QString("fO"));
 
1094
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
1095
    QCOMPARE(testWidget->text(), QString("f"));
 
1096
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
1097
    QCOMPARE(testWidget->text(), QString());
 
1098
    QTest::keyClick(testWidget, Qt::Key_F);
 
1099
    QCOMPARE(testWidget->text(), QString("f"));
 
1100
    QTest::keyClick(testWidget, Qt::Key_O); // will automatically uppercase
 
1101
    QCOMPARE(testWidget->text(), QString("fO"));
 
1102
    QTest::keyClick(testWidget, Qt::Key_O);
 
1103
    QCOMPARE(testWidget->text(), QString("fOo"));
 
1104
}
 
1105
 
 
1106
void tst_QDateTimeEdit::setRange_data()
 
1107
{
 
1108
    QTest::addColumn<QTime>("minTime");
 
1109
    QTest::addColumn<QTime>("maxTime");
 
1110
    QTest::addColumn<QDate>("minDate");
 
1111
    QTest::addColumn<QDate>("maxDate");
 
1112
    QTest::addColumn<QDateTime>("expectedMin");
 
1113
    QTest::addColumn<QDateTime>("expectedMax");
 
1114
 
 
1115
    const QDate cdt = QDate::currentDate();
 
1116
 
 
1117
    QTest::newRow("data0") << QTime(0, 0) << QTime(14, 12, 0)
 
1118
                           << cdt << cdt
 
1119
                           << QDateTime(cdt, QTime(0, 0))
 
1120
                           << QDateTime(cdt, QTime(14, 12, 0));
 
1121
 
 
1122
    QTest::newRow("data1") << QTime(10, 0) << QTime(1, 12, 0) << cdt.addDays(-1)
 
1123
                           << cdt
 
1124
                           << QDateTime(cdt.addDays(-1), QTime(10, 0))
 
1125
                           << QDateTime(cdt, QTime(1, 12, 0));
 
1126
}
 
1127
 
 
1128
void tst_QDateTimeEdit::setRange()
 
1129
{
 
1130
    QFETCH(QTime, minTime);
 
1131
    QFETCH(QTime, maxTime);
 
1132
    QFETCH(QDate, minDate);
 
1133
    QFETCH(QDate, maxDate);
 
1134
    QFETCH(QDateTime, expectedMin);
 
1135
    QFETCH(QDateTime, expectedMax);
 
1136
    testWidget->hide();
 
1137
 
 
1138
    {
 
1139
        QDateTimeEdit dte(0);
 
1140
        dte.setTimeRange(minTime, maxTime);
 
1141
        QCOMPARE(dte.minimumTime(), expectedMin.time());
 
1142
        QCOMPARE(dte.maximumTime(), expectedMax.time());
 
1143
        dte.setDateRange(minDate, maxDate);
 
1144
        QCOMPARE(dte.minimumDate(), expectedMin.date());
 
1145
        QCOMPARE(dte.minimumDateTime(), expectedMin);
 
1146
        QCOMPARE(dte.maximumDate(), expectedMax.date());
 
1147
        QCOMPARE(dte.maximumDateTime(), expectedMax);
 
1148
        QCOMPARE(dte.minimumTime(), expectedMin.time());
 
1149
        QCOMPARE(dte.maximumTime(), expectedMax.time());
 
1150
        dte.setDateTimeRange(QDateTime(minDate, minTime), QDateTime(maxDate, maxTime));
 
1151
        QCOMPARE(dte.minimumDate(), expectedMin.date());
 
1152
        QCOMPARE(dte.minimumDateTime(), expectedMin);
 
1153
        QCOMPARE(dte.maximumDate(), expectedMax.date());
 
1154
        QCOMPARE(dte.maximumDateTime(), expectedMax);
 
1155
        QCOMPARE(dte.minimumTime(), expectedMin.time());
 
1156
        QCOMPARE(dte.maximumTime(), expectedMax.time());
 
1157
    }
 
1158
    {
 
1159
 
 
1160
        QDateTimeEdit dte2(0);
 
1161
        dte2.setDateRange(minDate, maxDate);
 
1162
        dte2.setTimeRange(minTime, maxTime);
 
1163
 
 
1164
        QCOMPARE(dte2.minimumDate(), expectedMin.date());
 
1165
        QCOMPARE(dte2.maximumDate(), expectedMax.date());
 
1166
        QCOMPARE(dte2.minimumTime(), expectedMin.time());
 
1167
        QCOMPARE(dte2.maximumTime(), expectedMax.time());
 
1168
    }
 
1169
 
 
1170
    {
 
1171
        QDateTimeEdit dte3(0);
 
1172
        dte3.setMinimumTime(minTime);
 
1173
        dte3.setMaximumTime(maxTime);
 
1174
        dte3.setMinimumDate(minDate);
 
1175
        dte3.setMaximumDate(maxDate);
 
1176
 
 
1177
        QCOMPARE(dte3.minimumDate(), expectedMin.date());
 
1178
        QCOMPARE(dte3.maximumDate(), expectedMax.date());
 
1179
        QCOMPARE(dte3.minimumTime(), expectedMin.time());
 
1180
        QCOMPARE(dte3.maximumTime(), expectedMax.time());
 
1181
    }
 
1182
 
 
1183
    {
 
1184
        QDateTimeEdit dte4(0);
 
1185
        dte4.setMinimumDate(minDate);
 
1186
        dte4.setMaximumDate(maxDate);
 
1187
        dte4.setMinimumTime(minTime);
 
1188
        dte4.setMaximumTime(maxTime);
 
1189
 
 
1190
        QCOMPARE(dte4.minimumDate(), expectedMin.date());
 
1191
        QCOMPARE(dte4.maximumDate(), expectedMax.date());
 
1192
        QCOMPARE(dte4.minimumTime(), expectedMin.time());
 
1193
        QCOMPARE(dte4.maximumTime(), expectedMax.time());
 
1194
    }
 
1195
}
 
1196
 
 
1197
void tst_QDateTimeEdit::wrappingTime_data()
 
1198
{
 
1199
    QTest::addColumn<bool>("startWithMin");
 
1200
    QTest::addColumn<QTime>("minimumTime");
 
1201
    QTest::addColumn<QTime>("maximumTime");
 
1202
    QTest::addColumn<uint>("section");
 
1203
    QTest::addColumn<QTime>("newTime");
 
1204
 
 
1205
    QTest::newRow("data0") << false << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::HourSection
 
1206
                        << QTime(0,2,2);
 
1207
    QTest::newRow("data1") << true << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::HourSection
 
1208
                        << QTime(2,0,0);
 
1209
    QTest::newRow("data2") << false << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::MinuteSection
 
1210
                        << QTime(2,0,2);
 
1211
    QTest::newRow("data3") << true << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::MinuteSection
 
1212
                        << QTime(0,59,0);
 
1213
    QTest::newRow("data4") << false << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::SecondSection
 
1214
                        << QTime(2,2,0);
 
1215
    QTest::newRow("data5") << true << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::SecondSection
 
1216
                        << QTime(0,0,59);
 
1217
    QTest::newRow("data6") << false << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::HourSection
 
1218
                        << QTime(1,22,22);
 
1219
    QTest::newRow("data7") << true << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::HourSection
 
1220
                        << QTime(22,1,1);
 
1221
    QTest::newRow("data8") << false << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::MinuteSection
 
1222
                        << QTime(22,0,22);
 
1223
    QTest::newRow("data9") << true << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::MinuteSection
 
1224
                        << QTime(1,59,1);
 
1225
    QTest::newRow("data10") << false << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::SecondSection
 
1226
                         << QTime(22,22,0);
 
1227
    QTest::newRow("data11") << true << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::SecondSection
 
1228
                         << QTime(1,1,59);
 
1229
    QTest::newRow("data12") << false << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::HourSection
 
1230
                         << QTime(1,2,1);
 
1231
    QTest::newRow("data13") << true << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::HourSection
 
1232
                         << QTime(1,1,1);
 
1233
    QTest::newRow("data14") << false << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::MinuteSection
 
1234
                         << QTime(1,1,1);
 
1235
    QTest::newRow("data15") << true << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::MinuteSection
 
1236
                         << QTime(1,2,1);
 
1237
    QTest::newRow("data16") << false << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::SecondSection
 
1238
                         << QTime(1,2,0);
 
1239
    QTest::newRow("data17") << true << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::SecondSection
 
1240
                         << QTime(1,1,59);
 
1241
}
 
1242
 
 
1243
void tst_QDateTimeEdit::wrappingTime()
 
1244
{
 
1245
    QFETCH(bool, startWithMin);
 
1246
    QFETCH(QTime, minimumTime);
 
1247
    QFETCH(QTime, maximumTime);
 
1248
    QFETCH(uint, section);
 
1249
    QFETCH(QTime, newTime);
 
1250
 
 
1251
    testWidget->setDisplayFormat("hh:mm:ss");
 
1252
    testWidget->setMinimumTime(minimumTime);
 
1253
    testWidget->setMaximumTime(maximumTime);
 
1254
    testWidget->setWrapping(true);
 
1255
    testWidget->setCurrentSection((QDateTimeEdit::Section)section);
 
1256
    if (startWithMin) {
 
1257
        testWidget->setTime(minimumTime);
 
1258
        QTest::keyClick(testWidget, Qt::Key_Down);
 
1259
    } else {
 
1260
        testWidget->setTime(maximumTime);
 
1261
        QTest::keyClick(testWidget, Qt::Key_Up);
 
1262
    }
 
1263
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1264
    QCOMPARE(testWidget->time(), newTime);
 
1265
}
 
1266
 
 
1267
void tst_QDateTimeEdit::userKeyPress_Time_data()
 
1268
{
 
1269
    QTest::addColumn<bool>("ampm");
 
1270
    QTest::addColumn<QTestEventList>("keys");
 
1271
    QTest::addColumn<QTime>("expected_time");
 
1272
 
 
1273
    // ***************** test the hours ***************
 
1274
 
 
1275
    // use up/down keys to change hour in 12 h mode
 
1276
    {
 
1277
        QTestEventList keys;
 
1278
        keys.addKeyClick( Qt::Key_Down );
 
1279
        QTime expected( 10, 0, 0 );
 
1280
        QTest::newRow( "data0" ) << bool(true) << keys << expected;
 
1281
    }
 
1282
    {
 
1283
        QTestEventList keys;
 
1284
        for (uint i=0; i<5; i++)
 
1285
            keys.addKeyClick( Qt::Key_Down );
 
1286
        QTime expected( 6, 0, 0 );
 
1287
        QTest::newRow( "data1" ) << bool(true) << keys << expected;
 
1288
    }
 
1289
    {
 
1290
        QTestEventList keys;
 
1291
        for (uint i=0; i<10; i++)
 
1292
            keys.addKeyClick( Qt::Key_Down );
 
1293
        QTime expected( 1, 0, 0 );
 
1294
        QTest::newRow( "data2" ) << bool(true) << keys << expected;
 
1295
    }
 
1296
    {
 
1297
        QTestEventList keys;
 
1298
        for (uint i=0; i<12; i++)
 
1299
            keys.addKeyClick( Qt::Key_Down );
 
1300
        QTime expected( 23, 0, 0 );
 
1301
        QTest::newRow( "data3" ) << bool(true) << keys << expected;
 
1302
    }
 
1303
    {
 
1304
        QTestEventList keys;
 
1305
        keys.addKeyClick( Qt::Key_Up );
 
1306
        QTime expected( 12, 0, 0 );
 
1307
        QTest::newRow( "data4" ) << bool(true) << keys << expected;
 
1308
    }
 
1309
    {
 
1310
        QTestEventList keys;
 
1311
        for (uint i=0; i<2; i++)
 
1312
            keys.addKeyClick( Qt::Key_Up );
 
1313
        QTime expected( 13, 0, 0 );
 
1314
        QTest::newRow( "data5" ) << bool(true) << keys << expected;
 
1315
    }
 
1316
 
 
1317
    // use up/down keys to change hour in 24 h mode
 
1318
    {
 
1319
        QTestEventList keys;
 
1320
        keys.addKeyClick( Qt::Key_Down );
 
1321
        QTime expected( 10, 0, 0 );
 
1322
        QTest::newRow( "data6" ) << bool(false) << keys << expected;
 
1323
    }
 
1324
    {
 
1325
        QTestEventList keys;
 
1326
        for (uint i=0; i<5; i++)
 
1327
            keys.addKeyClick( Qt::Key_Down );
 
1328
        QTime expected( 6, 0, 0 );
 
1329
        QTest::newRow( "data7" ) << bool(false) << keys << expected;
 
1330
    }
 
1331
    {
 
1332
        QTestEventList keys;
 
1333
        for (uint i=0; i<10; i++)
 
1334
            keys.addKeyClick( Qt::Key_Down );
 
1335
        QTime expected( 1, 0, 0 );
 
1336
        QTest::newRow( "data8" ) << bool(false) << keys << expected;
 
1337
    }
 
1338
    {
 
1339
        QTestEventList keys;
 
1340
        for (uint i=0; i<12; i++)
 
1341
            keys.addKeyClick( Qt::Key_Down );
 
1342
        QTime expected( 23, 0, 0 );
 
1343
        QTest::newRow( "data9" ) << bool(false) << keys << expected;
 
1344
    }
 
1345
    {
 
1346
        QTestEventList keys;
 
1347
        keys.addKeyClick( Qt::Key_Up );
 
1348
        QTime expected( 12, 0, 0 );
 
1349
        QTest::newRow( "data10" ) << bool(false) << keys << expected;
 
1350
    }
 
1351
    {
 
1352
        QTestEventList keys;
 
1353
        for (uint i=0; i<2; i++)
 
1354
            keys.addKeyClick( Qt::Key_Up );
 
1355
        QTime expected( 13, 0, 0 );
 
1356
        QTest::newRow( "data11" ) << bool(false) << keys << expected;
 
1357
    }
 
1358
 
 
1359
    // enter a one digit valid hour
 
1360
    {
 
1361
        QTestEventList keys;
 
1362
        keys.addKeyClick( '5' );
 
1363
        QTime expected( 5, 0, 0 );
 
1364
        QTest::newRow( "data12" ) << bool(true) << keys << expected;
 
1365
    }
 
1366
 
 
1367
    // entering a two digit valid hour
 
1368
    {
 
1369
        QTestEventList keys;
 
1370
        keys.addKeyClick( '1' );
 
1371
        keys.addKeyClick( '1' );
 
1372
        QTime expected( 11, 0, 0 );
 
1373
        QTest::newRow( "data13" ) << bool(true) << keys << expected;
 
1374
    }
 
1375
 
 
1376
    // entering an invalid hour
 
1377
    {
 
1378
        QTestEventList keys;
 
1379
        keys.addKeyClick( '2' );
 
1380
        // the '5' creates an invalid hour (25) so it must be ignored
 
1381
        keys.addKeyClick( '5' );
 
1382
        QTime expected( 2, 0, 0 );
 
1383
        QTest::newRow( "data14" ) << bool(true) << keys << expected;
 
1384
    }
 
1385
 
 
1386
    // enter a value, in hour which causes a field change
 
1387
    {
 
1388
        QTestEventList keys;
 
1389
        keys.addKeyClick( '0' );
 
1390
        keys.addKeyClick( '2' );
 
1391
        keys.addKeyClick( '1' );
 
1392
        QTime expected( 2, 1, 0 );
 
1393
        QTest::newRow( "data15" ) << bool(true) << keys << expected;
 
1394
    }
 
1395
 
 
1396
    // enter a one digit valid hour in 24 h mode
 
1397
    {
 
1398
        QTestEventList keys;
 
1399
        keys.addKeyClick( '5' );
 
1400
        QTime expected( 5, 0, 0 );
 
1401
        QTest::newRow( "data16" ) << bool(false) << keys << expected;
 
1402
    }
 
1403
 
 
1404
    // enter a two digit valid hour in 24 h mode
 
1405
    {
 
1406
        QTestEventList keys;
 
1407
        keys.addKeyClick( '1' );
 
1408
        keys.addKeyClick( '1' );
 
1409
        QTime expected( 11, 0, 0 );
 
1410
        QTest::newRow( "data17" ) << bool(false) << keys << expected;
 
1411
    }
 
1412
 
 
1413
    // enter a two digit valid hour (>12) in 24 h mode
 
1414
    {
 
1415
        QTestEventList keys;
 
1416
        keys.addKeyClick( '1' );
 
1417
        keys.addKeyClick( '5' );
 
1418
        QTime expected( 15, 0, 0 );
 
1419
        QTest::newRow( "data18" ) << bool(false) << keys << expected;
 
1420
    }
 
1421
 
 
1422
    // enter a two digit valid hour (>20) in 24 h mode
 
1423
    {
 
1424
        QTestEventList keys;
 
1425
        keys.addKeyClick( '2' );
 
1426
        keys.addKeyClick( '1' );
 
1427
        QTime expected( 21, 0, 0 );
 
1428
        QTest::newRow( "data19" ) << bool(false) << keys << expected;
 
1429
    }
 
1430
 
 
1431
    // enter a two digit invalid hour (>23) in 24 h mode
 
1432
    {
 
1433
        QTestEventList keys;
 
1434
        keys.addKeyClick( '2' );
 
1435
        keys.addKeyClick( '4' );
 
1436
        QTime expected( 2, 0, 0 );
 
1437
        QTest::newRow( "data20" ) << bool(false) << keys << expected;
 
1438
    }
 
1439
 
 
1440
    // ***************** test the minutes ***************
 
1441
 
 
1442
    // use up/down keys to change the minutes in 12 hour mode
 
1443
    { // test a valid value
 
1444
        QTestEventList keys;
 
1445
        keys.addKeyClick( Qt::Key_Tab );
 
1446
        for (uint i=0; i<2; i++)
 
1447
            keys.addKeyClick( Qt::Key_Up );
 
1448
        QTime expected( 11, 2, 0 );
 
1449
        QTest::newRow( "data21" ) << bool(true) << keys << expected;
 
1450
    }
 
1451
    { // test a valid value
 
1452
        QTestEventList keys;
 
1453
        keys.addKeyClick( Qt::Key_Tab );
 
1454
        for (uint i=0; i<16; i++)
 
1455
            keys.addKeyClick( Qt::Key_Up );
 
1456
        QTime expected( 11, 16, 0 );
 
1457
        QTest::newRow( "data22" ) << bool(true) << keys << expected;
 
1458
    }
 
1459
    { // test maximum value
 
1460
        QTestEventList keys;
 
1461
        keys.addKeyClick( Qt::Key_Tab );
 
1462
        for (uint i=0; i<59; i++)
 
1463
            keys.addKeyClick( Qt::Key_Up );
 
1464
        QTime expected( 11, 59, 0 );
 
1465
        QTest::newRow( "data23" ) << bool(true) << keys << expected;
 
1466
    }
 
1467
    { // test 'overflow'
 
1468
        QTestEventList keys;
 
1469
        keys.addKeyClick( Qt::Key_Tab );
 
1470
        for (uint i=0; i<60; i++)
 
1471
            keys.addKeyClick( Qt::Key_Up );
 
1472
        QTime expected( 11, 0, 0 );
 
1473
        QTest::newRow( "data24" ) << bool(true) << keys << expected;
 
1474
    }
 
1475
    { // test 'underflow'
 
1476
        QTestEventList keys;
 
1477
        keys.addKeyClick( Qt::Key_Tab );
 
1478
        keys.addKeyClick( Qt::Key_Down );
 
1479
        QTime expected( 11, 59, 0 );
 
1480
        QTest::newRow( "data25" ) << bool(true) << keys << expected;
 
1481
    }
 
1482
    { // test valid value
 
1483
        QTestEventList keys;
 
1484
        keys.addKeyClick( Qt::Key_Tab );
 
1485
        for (uint i=0; i<2; i++)
 
1486
            keys.addKeyClick( Qt::Key_Down );
 
1487
        QTime expected( 11, 58, 0 );
 
1488
        QTest::newRow( "data26" ) << bool(true) << keys << expected;
 
1489
    }
 
1490
 
 
1491
    // use up/down keys to change the minutes in 24 hour mode
 
1492
 
 
1493
    { // test a valid value
 
1494
        QTestEventList keys;
 
1495
        keys.addKeyClick( Qt::Key_Tab );
 
1496
        for (uint i=0; i<2; i++)
 
1497
            keys.addKeyClick( Qt::Key_Up );
 
1498
        QTime expected( 11, 2, 0 );
 
1499
        QTest::newRow( "data27" ) << bool(false) << keys << expected;
 
1500
    }
 
1501
    { // test a valid value
 
1502
        QTestEventList keys;
 
1503
        keys.addKeyClick( Qt::Key_Tab );
 
1504
        for (uint i=0; i<16; i++)
 
1505
            keys.addKeyClick( Qt::Key_Up );
 
1506
        QTime expected( 11, 16, 0 );
 
1507
        QTest::newRow( "data28" ) << bool(false) << keys << expected;
 
1508
    }
 
1509
    { // test maximum value
 
1510
        QTestEventList keys;
 
1511
        keys.addKeyClick( Qt::Key_Tab );
 
1512
        for (uint i=0; i<59; i++)
 
1513
            keys.addKeyClick( Qt::Key_Up );
 
1514
        QTime expected( 11, 59, 0 );
 
1515
        QTest::newRow( "data29" ) << bool(false) << keys << expected;
 
1516
    }
 
1517
    { // test 'overflow'
 
1518
        QTestEventList keys;
 
1519
        keys.addKeyClick( Qt::Key_Tab );
 
1520
        for (uint i=0; i<60; i++)
 
1521
            keys.addKeyClick( Qt::Key_Up );
 
1522
        QTime expected( 11, 0, 0 );
 
1523
        QTest::newRow( "data30" ) << bool(false) << keys << expected;
 
1524
    }
 
1525
    { // test 'underflow'
 
1526
        QTestEventList keys;
 
1527
        keys.addKeyClick( Qt::Key_Tab );
 
1528
        keys.addKeyClick( Qt::Key_Down );
 
1529
        QTime expected( 11, 59, 0 );
 
1530
        QTest::newRow( "data31" ) << bool(false) << keys << expected;
 
1531
    }
 
1532
    { // test valid value
 
1533
        QTestEventList keys;
 
1534
        keys.addKeyClick( Qt::Key_Tab );
 
1535
        for (uint i=0; i<2; i++)
 
1536
            keys.addKeyClick( Qt::Key_Down );
 
1537
        QTime expected( 11, 58, 0 );
 
1538
        QTest::newRow( "data32" ) << bool(false) << keys << expected;
 
1539
    }
 
1540
 
 
1541
    // enter a valid one digit minute in 12 h mode
 
1542
    {
 
1543
        QTestEventList keys;
 
1544
        keys.addKeyClick(Qt::Key_Tab);
 
1545
        keys.addKeyClick( '2' );
 
1546
        QTime expected( 11, 2, 0 );
 
1547
        QTest::newRow( "data33" ) << bool(true) << keys << expected;
 
1548
    }
 
1549
 
 
1550
    // enter a valid two digit minutes in 12 h mode
 
1551
    {
 
1552
        QTestEventList keys;
 
1553
        keys.addKeyClick(Qt::Key_Tab);
 
1554
        keys.addKeyClick( '2' );
 
1555
        keys.addKeyClick( '4' );
 
1556
        QTime expected( 11, 24, 0 );
 
1557
        QTest::newRow( "data34" ) << bool(true) << keys << expected;
 
1558
    }
 
1559
 
 
1560
    // check the lower limit of the minutes in 12 h mode
 
1561
    {
 
1562
        QTestEventList keys;
 
1563
        keys.addKeyClick(Qt::Key_Tab);
 
1564
        keys.addKeyClick( '0' );
 
1565
        QTime expected( 11, 0, 0 );
 
1566
        QTest::newRow( "data35" ) << bool(true) << keys << expected;
 
1567
    }
 
1568
 
 
1569
    // check the upper limit of the minutes in 12 h mode
 
1570
    {
 
1571
        QTestEventList keys;
 
1572
        keys.addKeyClick(Qt::Key_Tab);
 
1573
        keys.addKeyClick( '5' );
 
1574
        keys.addKeyClick( '9' );
 
1575
        QTime expected( 11, 59, 0 );
 
1576
        QTest::newRow( "data36" ) << bool(true) << keys << expected;
 
1577
    }
 
1578
 
 
1579
    // enter an invalid two digit minutes in 12 h mode
 
1580
    {
 
1581
        QTestEventList keys;
 
1582
        keys.addKeyClick( Qt::Key_Tab );
 
1583
        keys.addKeyClick( '6' );
 
1584
        keys.addKeyClick( '0' );
 
1585
        QTime expected( 11, 6, 0 );
 
1586
        QTest::newRow( "data37" ) << bool(true) << keys << expected;
 
1587
    }
 
1588
 
 
1589
    // test minutes in 24 hour motestWidget-> Behaviour should be exactly the same
 
1590
 
 
1591
    // enter a valid one digit minute in 24 h mode
 
1592
    {
 
1593
        QTestEventList keys;
 
1594
        keys.addKeyClick( Qt::Key_Tab );
 
1595
        keys.addKeyClick( '2' );
 
1596
        QTime expected( 11, 2, 0 );
 
1597
        QTest::newRow( "data38" ) << bool(false) << keys << expected;
 
1598
    }
 
1599
 
 
1600
    // enter a valid two digit minutes in 24 h mode
 
1601
    {
 
1602
        QTestEventList keys;
 
1603
        keys.addKeyClick( Qt::Key_Tab );
 
1604
        keys.addKeyClick( '2' );
 
1605
        keys.addKeyClick( '4' );
 
1606
        QTime expected( 11, 24, 0 );
 
1607
        QTest::newRow( "data39" ) << bool(false) << keys << expected;
 
1608
    }
 
1609
 
 
1610
    // check the lower limit of the minutes in 24 h mode
 
1611
    {
 
1612
        QTestEventList keys;
 
1613
        keys.addKeyClick( Qt::Key_Tab );
 
1614
        keys.addKeyClick( '0' );
 
1615
        QTime expected( 11, 0, 0 );
 
1616
        QTest::newRow( "data40" ) << bool(false) << keys << expected;
 
1617
    }
 
1618
 
 
1619
    // check the upper limit of the minutes in 24 h mode
 
1620
    {
 
1621
        QTestEventList keys;
 
1622
        keys.addKeyClick( Qt::Key_Tab );
 
1623
        keys.addKeyClick( '5' );
 
1624
        keys.addKeyClick( '9' );
 
1625
        QTime expected( 11, 59, 0 );
 
1626
        QTest::newRow( "data41" ) << bool(false) << keys << expected;
 
1627
    }
 
1628
 
 
1629
    // enter an invalid two digit minutes in 24 h mode
 
1630
    {
 
1631
        QTestEventList keys;
 
1632
        keys.addKeyClick( Qt::Key_Tab );
 
1633
        keys.addKeyClick( '6' );
 
1634
        keys.addKeyClick( '0' );
 
1635
        QTime expected( 11, 6, 0 );
 
1636
        QTest::newRow( "data42" ) << bool(false) << keys << expected;
 
1637
    }
 
1638
 
 
1639
    // ***************** test the seconds ***************
 
1640
 
 
1641
    // use up/down to edit the seconds...
 
1642
 
 
1643
    // use up/down keys to change the seconds in 12 hour mode
 
1644
    { // test a valid value
 
1645
        QTestEventList keys;
 
1646
        keys.addKeyClick( Qt::Key_Tab );
 
1647
        keys.addKeyClick( Qt::Key_Tab );
 
1648
        for (uint i=0; i<2; i++)
 
1649
            keys.addKeyClick( Qt::Key_Up );
 
1650
        QTime expected( 11, 0, 2 );
 
1651
        QTest::newRow( "data43" ) << bool(true) << keys << expected;
 
1652
    }
 
1653
    { // test a valid value
 
1654
        QTestEventList keys;
 
1655
        keys.addKeyClick( Qt::Key_Tab );
 
1656
        keys.addKeyClick( Qt::Key_Tab );
 
1657
        for (uint i=0; i<16; i++)
 
1658
            keys.addKeyClick( Qt::Key_Up );
 
1659
        QTime expected( 11, 0, 16 );
 
1660
        QTest::newRow( "data44" ) << bool(true) << keys << expected;
 
1661
    }
 
1662
    { // test maximum value
 
1663
        QTestEventList keys;
 
1664
        keys.addKeyClick( Qt::Key_Tab );
 
1665
        keys.addKeyClick( Qt::Key_Tab );
 
1666
        for (uint i=0; i<59; i++)
 
1667
            keys.addKeyClick( Qt::Key_Up );
 
1668
        QTime expected( 11, 0, 59 );
 
1669
        QTest::newRow( "data45" ) << bool(true) << keys << expected;
 
1670
    }
 
1671
    { // test 'overflow'
 
1672
        QTestEventList keys;
 
1673
        keys.addKeyClick( Qt::Key_Tab );
 
1674
        keys.addKeyClick( Qt::Key_Tab );
 
1675
        for (uint i=0; i<60; i++)
 
1676
            keys.addKeyClick( Qt::Key_Up );
 
1677
        QTime expected( 11, 0, 0 );
 
1678
        QTest::newRow( "data46" ) << bool(true) << keys << expected;
 
1679
    }
 
1680
    { // test 'underflow'
 
1681
        QTestEventList keys;
 
1682
        keys.addKeyClick( Qt::Key_Tab );
 
1683
        keys.addKeyClick( Qt::Key_Tab );
 
1684
        keys.addKeyClick( Qt::Key_Down );
 
1685
        QTime expected( 11, 0, 59 );
 
1686
        QTest::newRow( "data47" ) << bool(true) << keys << expected;
 
1687
    }
 
1688
    { // test valid value
 
1689
        QTestEventList keys;
 
1690
        keys.addKeyClick( Qt::Key_Tab );
 
1691
        keys.addKeyClick( Qt::Key_Tab );
 
1692
        for (uint i=0; i<2; i++)
 
1693
            keys.addKeyClick( Qt::Key_Down );
 
1694
        QTime expected( 11, 0, 58 );
 
1695
        QTest::newRow( "data48" ) << bool(true) << keys << expected;
 
1696
    }
 
1697
 
 
1698
    // use up/down keys to change the seconds in 24 hour mode
 
1699
 
 
1700
    { // test a valid value
 
1701
        QTestEventList keys;
 
1702
        keys.addKeyClick( Qt::Key_Tab );
 
1703
        keys.addKeyClick( Qt::Key_Tab );
 
1704
        for (uint i=0; i<2; i++)
 
1705
            keys.addKeyClick( Qt::Key_Up );
 
1706
        QTime expected( 11, 0, 2 );
 
1707
        QTest::newRow( "data49" ) << bool(false) << keys << expected;
 
1708
    }
 
1709
    { // test a valid value
 
1710
        QTestEventList keys;
 
1711
        keys.addKeyClick( Qt::Key_Tab );
 
1712
        keys.addKeyClick( Qt::Key_Tab );
 
1713
        for (uint i=0; i<16; i++)
 
1714
            keys.addKeyClick( Qt::Key_Up );
 
1715
        QTime expected( 11, 0, 16 );
 
1716
        QTest::newRow( "data50" ) << bool(false) << keys << expected;
 
1717
    }
 
1718
    { // test maximum value
 
1719
        QTestEventList keys;
 
1720
        keys.addKeyClick( Qt::Key_Tab );
 
1721
        keys.addKeyClick( Qt::Key_Tab );
 
1722
        for (uint i=0; i<59; i++)
 
1723
            keys.addKeyClick( Qt::Key_Up );
 
1724
        QTime expected( 11, 0, 59 );
 
1725
        QTest::newRow( "data51" ) << bool(false) << keys << expected;
 
1726
    }
 
1727
    { // test 'overflow'
 
1728
        QTestEventList keys;
 
1729
        keys.addKeyClick( Qt::Key_Tab );
 
1730
        keys.addKeyClick( Qt::Key_Tab );
 
1731
        for (uint i=0; i<60; i++)
 
1732
            keys.addKeyClick( Qt::Key_Up );
 
1733
        QTime expected( 11, 0, 0 );
 
1734
        QTest::newRow( "data52" ) << bool(false) << keys << expected;
 
1735
    }
 
1736
    { // test 'underflow'
 
1737
        QTestEventList keys;
 
1738
        keys.addKeyClick( Qt::Key_Tab );
 
1739
        keys.addKeyClick( Qt::Key_Tab );
 
1740
        keys.addKeyClick( Qt::Key_Down );
 
1741
        QTime expected( 11, 0, 59 );
 
1742
        QTest::newRow( "data53" ) << bool(false) << keys << expected;
 
1743
    }
 
1744
    { // test valid value
 
1745
        QTestEventList keys;
 
1746
        keys.addKeyClick( Qt::Key_Tab );
 
1747
        keys.addKeyClick( Qt::Key_Tab );
 
1748
        for (uint i=0; i<2; i++)
 
1749
            keys.addKeyClick( Qt::Key_Down );
 
1750
        QTime expected( 11, 0, 58 );
 
1751
        QTest::newRow( "data54" ) << bool(false) << keys << expected;
 
1752
    }
 
1753
 
 
1754
    // enter a valid one digit second in 12 h mode
 
1755
    {
 
1756
        QTestEventList keys;
 
1757
        keys.addKeyClick( Qt::Key_Tab );
 
1758
        keys.addKeyClick( Qt::Key_Tab );
 
1759
        keys.addKeyClick( '2' );
 
1760
        QTime expected( 11, 0, 2 );
 
1761
        QTest::newRow( "data55" ) << bool(true) << keys << expected;
 
1762
    }
 
1763
 
 
1764
    // enter a valid two digit seconds in 12 h mode
 
1765
    {
 
1766
        QTestEventList keys;
 
1767
        keys.addKeyClick( Qt::Key_Tab );
 
1768
        keys.addKeyClick( Qt::Key_Tab );
 
1769
        keys.addKeyClick( '2' );
 
1770
        keys.addKeyClick( '4' );
 
1771
        QTime expected( 11, 0, 24 );
 
1772
        QTest::newRow( "data56" ) << bool(true) << keys << expected;
 
1773
    }
 
1774
 
 
1775
    // check the lower limit of the seconds in 12 h mode
 
1776
    {
 
1777
        QTestEventList keys;
 
1778
        keys.addKeyClick( Qt::Key_Tab );
 
1779
        keys.addKeyClick( Qt::Key_Tab );
 
1780
        keys.addKeyClick( '0' );
 
1781
        QTime expected( 11, 0, 0 );
 
1782
        QTest::newRow( "data57" ) << bool(true) << keys << expected;
 
1783
    }
 
1784
 
 
1785
    // check the upper limit of the seconds in 12 h mode
 
1786
    {
 
1787
        QTestEventList keys;
 
1788
        keys.addKeyClick( Qt::Key_Tab );
 
1789
        keys.addKeyClick( Qt::Key_Tab );
 
1790
        keys.addKeyClick( '5' );
 
1791
        keys.addKeyClick( '9' );
 
1792
        QTime expected( 11, 0, 59 );
 
1793
        QTest::newRow( "data58" ) << bool(true) << keys << expected;
 
1794
    }
 
1795
 
 
1796
    // enter an invalid two digit seconds in 12 h mode
 
1797
    {
 
1798
        QTestEventList keys;
 
1799
        keys.addKeyClick( Qt::Key_Tab );
 
1800
        keys.addKeyClick( Qt::Key_Tab );
 
1801
        keys.addKeyClick( '6' );
 
1802
        keys.addKeyClick( '0' );
 
1803
        QTime expected( 11, 0, 6 );
 
1804
        QTest::newRow( "data59" ) << bool(true) << keys << expected;
 
1805
    }
 
1806
 
 
1807
    // test seconds in 24 hour mode. Behaviour should be exactly the same
 
1808
 
 
1809
    // enter a valid one digit minute in 24 h mode
 
1810
    {
 
1811
        QTestEventList keys;
 
1812
        keys.addKeyClick( Qt::Key_Tab );
 
1813
        keys.addKeyClick( Qt::Key_Tab );
 
1814
        keys.addKeyClick( '2' );
 
1815
        QTime expected( 11, 0, 2 );
 
1816
        QTest::newRow( "data60" ) << bool(false) << keys << expected;
 
1817
    }
 
1818
 
 
1819
    // enter a valid two digit seconds in 24 h mode
 
1820
    {
 
1821
        QTestEventList keys;
 
1822
        keys.addKeyClick( Qt::Key_Tab );
 
1823
        keys.addKeyClick( Qt::Key_Tab );
 
1824
        keys.addKeyClick( '2' );
 
1825
        keys.addKeyClick( '4' );
 
1826
        QTime expected( 11, 0, 24 );
 
1827
        QTest::newRow( "data61" ) << bool(false) << keys << expected;
 
1828
    }
 
1829
 
 
1830
    // check the lower limit of the seconds in 24 h mode
 
1831
    {
 
1832
        QTestEventList keys;
 
1833
        keys.addKeyClick( Qt::Key_Tab );
 
1834
        keys.addKeyClick( Qt::Key_Tab );
 
1835
        keys.addKeyClick( '0' );
 
1836
        QTime expected( 11, 0, 0 );
 
1837
        QTest::newRow( "data62" ) << bool(false) << keys << expected;
 
1838
    }
 
1839
 
 
1840
    // check the upper limit of the seconds in 24 h mode
 
1841
    {
 
1842
        QTestEventList keys;
 
1843
        keys.addKeyClick( Qt::Key_Tab );
 
1844
        keys.addKeyClick( Qt::Key_Tab );
 
1845
        keys.addKeyClick( '5' );
 
1846
        keys.addKeyClick( '9' );
 
1847
        QTime expected( 11, 0, 59 );
 
1848
        QTest::newRow( "data63" ) << bool(false) << keys << expected;
 
1849
    }
 
1850
 
 
1851
    // enter an invalid two digit seconds in 24 h mode
 
1852
    {
 
1853
        QTestEventList keys;
 
1854
        keys.addKeyClick( Qt::Key_Tab );
 
1855
        keys.addKeyClick( Qt::Key_Tab );
 
1856
        keys.addKeyClick( '6' );
 
1857
        keys.addKeyClick( '0' );
 
1858
        QTime expected( 11, 0, 6 );
 
1859
        QTest::newRow( "data64" ) << bool(false) << keys << expected;
 
1860
    }
 
1861
 
 
1862
    // Test the AMPM indicator
 
1863
    {
 
1864
        QTestEventList keys;
 
1865
        keys.addKeyClick( Qt::Key_Tab );
 
1866
        keys.addKeyClick( Qt::Key_Tab );
 
1867
        keys.addKeyClick( Qt::Key_Tab );
 
1868
        keys.addKeyClick( Qt::Key_Up );
 
1869
        QTime expected( 23, 0, 0 );
 
1870
        QTest::newRow( "data65" ) << bool(true) << keys << expected;
 
1871
    }
 
1872
    // Test the AMPM indicator
 
1873
    {
 
1874
        QTestEventList keys;
 
1875
        keys.addKeyClick( Qt::Key_Tab );
 
1876
        keys.addKeyClick( Qt::Key_Tab );
 
1877
        keys.addKeyClick( Qt::Key_Tab );
 
1878
        keys.addKeyClick( Qt::Key_Down );
 
1879
        QTime expected( 23, 0, 0 );
 
1880
        QTest::newRow( "data66" ) << bool(true) << keys << expected;
 
1881
    }
 
1882
    // Test the AMPM indicator
 
1883
    {
 
1884
        QTestEventList keys;
 
1885
        keys.addKeyClick( Qt::Key_Tab );
 
1886
        keys.addKeyClick( Qt::Key_Tab );
 
1887
        keys.addKeyClick( Qt::Key_Tab );
 
1888
        keys.addKeyClick( Qt::Key_Down );
 
1889
        keys.addKeyClick( Qt::Key_Down );
 
1890
        QTime expected( 11, 0, 0 );
 
1891
        QTest::newRow( "data67" ) << bool(true) << keys << expected;
 
1892
    }
 
1893
    // Test the AMPM indicator
 
1894
    {
 
1895
        QTestEventList keys;
 
1896
        keys.addKeyClick( Qt::Key_Tab );
 
1897
        keys.addKeyClick( Qt::Key_Tab );
 
1898
        keys.addKeyClick( Qt::Key_Tab );
 
1899
        keys.addKeyClick( Qt::Key_Up );
 
1900
        keys.addKeyClick( Qt::Key_Down );
 
1901
        QTime expected( 11, 0, 0 );
 
1902
        QTest::newRow( "data68" ) << bool(true) << keys << expected;
 
1903
    }
 
1904
}
 
1905
 
 
1906
void tst_QDateTimeEdit::userKeyPress_Time()
 
1907
{
 
1908
    QFETCH(bool, ampm);
 
1909
    QFETCH(QTestEventList, keys);
 
1910
    QFETCH(QTime, expected_time);
 
1911
 
 
1912
    if (ampm)
 
1913
        testWidget->setDisplayFormat("hh:mm:ss ap");
 
1914
    else
 
1915
        testWidget->setDisplayFormat("hh:mm:ss");
 
1916
 
 
1917
    testWidget->setTime(QTime(11, 0, 0));
 
1918
    testWidget->setFocus();
 
1919
 
 
1920
    testWidget->setWrapping(true);
 
1921
 
 
1922
    QTest::keyClick(testWidget, Qt::Key_Enter); // Make sure the first section is now focused
 
1923
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
 
1924
    keys.simulate(testWidget);
 
1925
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
1926
 
 
1927
    QCOMPARE(testWidget->time(), expected_time);
 
1928
}
 
1929
 
 
1930
void tst_QDateTimeEdit::wrappingDate_data()
 
1931
{
 
1932
    QTest::addColumn<bool>("startWithMin");
 
1933
    QTest::addColumn<QDate>("minimumDate");
 
1934
    QTest::addColumn<QDate>("maximumDate");
 
1935
    QTest::addColumn<uint>("section");
 
1936
    QTest::addColumn<QDate>("newDate");
 
1937
 
 
1938
    QTest::newRow("data0") << false << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::DaySection
 
1939
                        << QDate(1999, 1, 1);
 
1940
    QTest::newRow("data1") << true << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::DaySection
 
1941
                        << QDate(1999, 1, 31);
 
1942
    QTest::newRow("data2") << false << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::MonthSection
 
1943
                        << QDate(1999, 1, 31);
 
1944
    QTest::newRow("data3") << true << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::MonthSection
 
1945
                        << QDate(1999, 1, 1);
 
1946
    QTest::newRow("data4") << false << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::YearSection
 
1947
                        << QDate(1999, 1, 31);
 
1948
    QTest::newRow("data5") << true << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::YearSection
 
1949
                        << QDate(1999, 1, 1);
 
1950
    QTest::newRow("data6") << false << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::DaySection
 
1951
                        << QDate(2000, 1, 1);
 
1952
    QTest::newRow("data7") << true << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::DaySection
 
1953
                        << QDate(1999, 1, 31);
 
1954
    QTest::newRow("data8") << false << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::MonthSection
 
1955
                        << QDate(2000, 1, 31);
 
1956
    QTest::newRow("data9") << true << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::MonthSection
 
1957
                        << QDate(1999, 12, 1);
 
1958
    QTest::newRow("data10") << false << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::YearSection
 
1959
                         << QDate(1999, 1, 31);
 
1960
    QTest::newRow("data11") << true << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::YearSection
 
1961
                         << QDate(2000, 1, 1);
 
1962
}
 
1963
 
 
1964
void tst_QDateTimeEdit::wrappingDate()
 
1965
{
 
1966
    QFETCH(bool, startWithMin);
 
1967
    QFETCH(QDate, minimumDate);
 
1968
    QFETCH(QDate, maximumDate);
 
1969
    QFETCH(uint, section);
 
1970
    QFETCH(QDate, newDate);
 
1971
 
 
1972
    testWidget->setDisplayFormat("dd/MM/yyyy");
 
1973
    testWidget->setMinimumDate(minimumDate);
 
1974
    testWidget->setMaximumDate(maximumDate);
 
1975
    testWidget->setWrapping(true);
 
1976
    testWidget->setCurrentSection((QDateTimeEdit::Section)section);
 
1977
 
 
1978
    if (startWithMin) {
 
1979
        testWidget->setDate(minimumDate);
 
1980
        QTest::keyClick(testWidget, Qt::Key_Down);
 
1981
    } else {
 
1982
        testWidget->setDate(maximumDate);
 
1983
        QTest::keyClick(testWidget, Qt::Key_Up);
 
1984
    }
 
1985
    if (testWidget->currentSection() == QDateTimeEdit::MonthSection)
 
1986
        QCOMPARE(testWidget->date(), newDate);
 
1987
}
 
1988
 
 
1989
void tst_QDateTimeEdit::dateSignalChecking_data()
 
1990
{
 
1991
    QTest::addColumn<QDate>("originalDate");
 
1992
    QTest::addColumn<QDate>("newDate");
 
1993
    QTest::addColumn<int>("timesEmitted");
 
1994
 
 
1995
    QTest::newRow("data0") << QDate(2004, 06, 22) << QDate(2004, 07, 23) << 1;
 
1996
    QTest::newRow("data1") << QDate(2004, 06, 22) << QDate(2004, 06, 22) << 0;
 
1997
}
 
1998
 
 
1999
void tst_QDateTimeEdit::dateSignalChecking()
 
2000
{
 
2001
    QFETCH(QDate, originalDate);
 
2002
    QFETCH(QDate, newDate);
 
2003
    QFETCH(int, timesEmitted);
 
2004
 
 
2005
    testWidget->setDate(originalDate);
 
2006
 
 
2007
    QSignalSpy dateSpy(testWidget, SIGNAL(dateChanged(QDate)));
 
2008
    QSignalSpy dateTimeSpy(testWidget, SIGNAL(dateTimeChanged(QDateTime)));
 
2009
    QSignalSpy timeSpy(testWidget, SIGNAL(timeChanged(QTime)));
 
2010
 
 
2011
    testWidget->setDate(newDate);
 
2012
    QCOMPARE(dateSpy.count(), timesEmitted);
 
2013
 
 
2014
    if (timesEmitted > 0) {
 
2015
        QList<QVariant> list = dateSpy.takeFirst();
 
2016
        QDate d;
 
2017
        d = qvariant_cast<QDate>(list.at(0));
 
2018
        QCOMPARE(d, newDate);
 
2019
    }
 
2020
    QCOMPARE(dateTimeSpy.count(), timesEmitted);
 
2021
    QCOMPARE(timeSpy.count(), 0);
 
2022
}
 
2023
 
 
2024
void tst_QDateTimeEdit::timeSignalChecking_data()
 
2025
{
 
2026
    QTest::addColumn<QTime>("originalTime");
 
2027
    QTest::addColumn<QTime>("newTime");
 
2028
    QTest::addColumn<int>("timesEmitted");
 
2029
 
 
2030
    QTest::newRow("data0") << QTime(15, 55, 00) << QTime(15, 17, 12) << 1;
 
2031
    QTest::newRow("data1") << QTime(15, 55, 00) << QTime(15, 55, 00) << 0;
 
2032
}
 
2033
 
 
2034
void tst_QDateTimeEdit::timeSignalChecking()
 
2035
{
 
2036
    QFETCH(QTime, originalTime);
 
2037
    QFETCH(QTime, newTime);
 
2038
    QFETCH(int, timesEmitted);
 
2039
 
 
2040
    testWidget->setTime(originalTime);
 
2041
 
 
2042
    testWidget->setDisplayFormat("hh:mm:ss");
 
2043
    QSignalSpy dateSpy(testWidget, SIGNAL(dateChanged(QDate)));
 
2044
    QSignalSpy dateTimeSpy(testWidget, SIGNAL(dateTimeChanged(QDateTime)));
 
2045
    QSignalSpy timeSpy(testWidget, SIGNAL(timeChanged(QTime)));
 
2046
 
 
2047
    testWidget->setTime(newTime);
 
2048
    QCOMPARE(timeSpy.count(), timesEmitted);
 
2049
 
 
2050
    if (timesEmitted > 0) {
 
2051
        QList<QVariant> list = timeSpy.takeFirst();
 
2052
        QTime t;
 
2053
        t = qvariant_cast<QTime>(list.at(0));
 
2054
        QCOMPARE(t, newTime);
 
2055
    }
 
2056
    QCOMPARE(dateTimeSpy.count(), timesEmitted);
 
2057
    QCOMPARE(dateSpy.count(), 0);
 
2058
}
 
2059
 
 
2060
void tst_QDateTimeEdit::dateTimeSignalChecking_data()
 
2061
{
 
2062
    QTest::addColumn<QDateTime>("originalDateTime");
 
2063
    QTest::addColumn<QDateTime>("newDateTime");
 
2064
    QTest::addColumn<int>("timesDateEmitted");
 
2065
    QTest::addColumn<int>("timesTimeEmitted");
 
2066
    QTest::addColumn<int>("timesDateTimeEmitted");
 
2067
 
 
2068
    QTest::newRow("data0") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
 
2069
                        << QDateTime(QDate(2004, 7, 23), QTime(15, 17, 12))
 
2070
                        << 1 << 1 << 1;
 
2071
    QTest::newRow("data1") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
 
2072
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 17, 12))
 
2073
                        << 0 << 1 << 1;
 
2074
    QTest::newRow("data2") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
 
2075
                        << QDateTime(QDate(2004, 7, 23), QTime(15, 55, 0))
 
2076
                        << 1 << 0 << 1;
 
2077
    QTest::newRow("data3") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
 
2078
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
 
2079
                        << 0 << 0 << 0;
 
2080
}
 
2081
 
 
2082
void tst_QDateTimeEdit::dateTimeSignalChecking()
 
2083
{
 
2084
    QFETCH(QDateTime, originalDateTime);
 
2085
    QFETCH(QDateTime, newDateTime);
 
2086
    QFETCH(int, timesDateEmitted);
 
2087
    QFETCH(int, timesTimeEmitted);
 
2088
    QFETCH(int, timesDateTimeEmitted);
 
2089
 
 
2090
    testWidget->setDisplayFormat("dd/MM/yyyy hh:mm:ss");
 
2091
    testWidget->setDateTime(originalDateTime);
 
2092
 
 
2093
    QSignalSpy dateSpy(testWidget, SIGNAL(dateChanged(QDate)));
 
2094
    QSignalSpy timeSpy(testWidget, SIGNAL(timeChanged(QTime)));
 
2095
    QSignalSpy dateTimeSpy(testWidget, SIGNAL(dateTimeChanged(QDateTime)));
 
2096
 
 
2097
    testWidget->setDateTime(newDateTime);
 
2098
    QCOMPARE(dateSpy.count(), timesDateEmitted);
 
2099
    if (timesDateEmitted > 0) {
 
2100
        QCOMPARE(timesDateEmitted, 1);
 
2101
        QList<QVariant> list = dateSpy.takeFirst();
 
2102
        QDate d;
 
2103
        d = qvariant_cast<QDate>(list.at(0));
 
2104
        QCOMPARE(d, newDateTime.date());
 
2105
    }
 
2106
    QCOMPARE(timeSpy.count(), timesTimeEmitted);
 
2107
    if (timesTimeEmitted > 0) {
 
2108
        QList<QVariant> list = timeSpy.takeFirst();
 
2109
        QTime t;
 
2110
        t = qvariant_cast<QTime>(list.at(0));
 
2111
        QCOMPARE(t, newDateTime.time());
 
2112
    }
 
2113
    QCOMPARE(dateTimeSpy.count(), timesDateTimeEmitted);
 
2114
    if (timesDateTimeEmitted > 0) {
 
2115
        QList<QVariant> list = dateTimeSpy.takeFirst();
 
2116
        QDateTime dt;
 
2117
        dt = qvariant_cast<QDateTime>(list.at(0));
 
2118
        QCOMPARE(dt, newDateTime);
 
2119
    }
 
2120
}
 
2121
 
 
2122
void tst_QDateTimeEdit::sectionText_data()
 
2123
{
 
2124
    QTest::addColumn<QString>("format");
 
2125
    QTest::addColumn<QDateTime>("dateTime");
 
2126
    QTest::addColumn<uint>("section");
 
2127
    QTest::addColumn<QString>("sectionText");
 
2128
 
 
2129
    QTest::newRow("data0") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2130
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2131
                        << (uint)QDateTimeEdit::NoSection << QString();
 
2132
    QTest::newRow("data1") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2133
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2134
                        << (uint)QDateTimeEdit::AmPmSection << QString("pm");
 
2135
    QTest::newRow("data2") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2136
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2137
                        << (uint)QDateTimeEdit::MSecSection << QString("789");
 
2138
    QTest::newRow("data3") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2139
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2140
                        << (uint)QDateTimeEdit::SecondSection << QString("03");
 
2141
    QTest::newRow("data4") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2142
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2143
                        << (uint)QDateTimeEdit::MinuteSection << QString("55");
 
2144
    QTest::newRow("data5") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2145
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2146
                        << (uint)QDateTimeEdit::HourSection << QString("03");
 
2147
    QTest::newRow("data6") << QString("dd/MM/yyyy hh:mm:ss zzz")
 
2148
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2149
                        << (uint)QDateTimeEdit::HourSection << QString("15");
 
2150
    QTest::newRow("data7") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2151
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2152
                        << (uint)QDateTimeEdit::DaySection << QString("22");
 
2153
    QTest::newRow("data8") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2154
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2155
                        << (uint)QDateTimeEdit::MonthSection << QString("06");
 
2156
    QTest::newRow("data9") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2157
                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2158
                        << (uint)QDateTimeEdit::YearSection << QString("2004");
 
2159
    QTest::newRow("data10") << QString("dd/MM/yyyy hh:mm:ss zzz AP")
 
2160
                         << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2161
                         << (uint)QDateTimeEdit::AmPmSection << QString("PM");
 
2162
    QTest::newRow("data11") << QString("dd/MM/yyyy hh:mm:ss ap")
 
2163
                         << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
 
2164
                         << (uint)QDateTimeEdit::MSecSection << QString();
 
2165
}
 
2166
 
 
2167
void tst_QDateTimeEdit::sectionText()
 
2168
{
 
2169
    QFETCH(QString, format);
 
2170
    QFETCH(QDateTime, dateTime);
 
2171
    QFETCH(uint, section);
 
2172
    QFETCH(QString, sectionText);
 
2173
 
 
2174
    testWidget->setDisplayFormat(format);
 
2175
    testWidget->setDateTime(dateTime);
 
2176
    QCOMPARE(testWidget->sectionText((QDateTimeEdit::Section)section), sectionText);
 
2177
//    QApplication::setLayoutDirection(Qt::RightToLeft);
 
2178
//    testWidget->setDisplayFormat(format);
 
2179
//    QCOMPARE(format, testWidget->displayFormat());
 
2180
//     testWidget->setDateTime(dateTime);
 
2181
//     QCOMPARE(testWidget->sectionText((QDateTimeEdit::Section)section), sectionText);
 
2182
//     QApplication::setLayoutDirection(Qt::LeftToRight);
 
2183
}
 
2184
 
 
2185
void tst_QDateTimeEdit::mousePress()
 
2186
{
 
2187
    testWidget->setDate(QDate(2004, 6, 23));
 
2188
    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
 
2189
    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::YearSection);
 
2190
 
 
2191
    // Ask the SC_SpinBoxUp button location from style
 
2192
    QStyleOptionSpinBox so;
 
2193
    so.rect = testWidget->rect();
 
2194
    QRect rectUp = testWidget->style()->subControlRect(QStyle::CC_SpinBox, &so, QStyle::SC_SpinBoxUp, testWidget);
 
2195
 
 
2196
    // Send mouseClick to center of SC_SpinBoxUp
 
2197
    QTest::mouseClick(testWidget, Qt::LeftButton, 0, rectUp.center());
 
2198
    QCOMPARE(testWidget->date().year(), 2005);
 
2199
}
 
2200
 
 
2201
void tst_QDateTimeEdit::stepHourAMPM_data()
 
2202
{
 
2203
    QTest::addColumn<QString>("format");
 
2204
    QTest::addColumn<KeyList>("keys");
 
2205
    QTest::addColumn<TimeList>("expected");
 
2206
    QTest::addColumn<QTime>("start");
 
2207
    QTest::addColumn<QTime>("min");
 
2208
    QTest::addColumn<QTime>("max");
 
2209
 
 
2210
    {
 
2211
        KeyList keys;
 
2212
        TimeList expected;
 
2213
        keys << Qt::Key_Up;
 
2214
        expected << QTime(1, 0, 0);
 
2215
        keys << Qt::Key_Up;
 
2216
        expected << QTime(2, 0, 0);
 
2217
        keys << Qt::Key_Up;
 
2218
        expected << QTime(3, 0, 0);
 
2219
        keys << Qt::Key_Up;
 
2220
        expected << QTime(4, 0, 0);
 
2221
        keys << Qt::Key_Up;
 
2222
        expected << QTime(5, 0, 0);
 
2223
        keys << Qt::Key_Up;
 
2224
        expected << QTime(6, 0, 0);
 
2225
        keys << Qt::Key_Up;
 
2226
        expected << QTime(7, 0, 0);
 
2227
        keys << Qt::Key_Up;
 
2228
        expected << QTime(8, 0, 0);
 
2229
        keys << Qt::Key_Up;
 
2230
        expected << QTime(9, 0, 0);
 
2231
        keys << Qt::Key_Up;
 
2232
        expected << QTime(10, 0, 0);
 
2233
        keys << Qt::Key_Up;
 
2234
        expected << QTime(11, 0, 0);
 
2235
        keys << Qt::Key_Up;
 
2236
        expected << QTime(12, 0, 0);
 
2237
        keys << Qt::Key_Up;
 
2238
        expected << QTime(13, 0, 0);
 
2239
        keys << Qt::Key_Up;
 
2240
        expected << QTime(14, 0, 0);
 
2241
        keys << Qt::Key_Up;
 
2242
        expected << QTime(15, 0, 0);
 
2243
        keys << Qt::Key_Up;
 
2244
        expected << QTime(16, 0, 0);
 
2245
        keys << Qt::Key_Up;
 
2246
        expected << QTime(17, 0, 0);
 
2247
        keys << Qt::Key_Up;
 
2248
        expected << QTime(18, 0, 0);
 
2249
        keys << Qt::Key_Up;
 
2250
        expected << QTime(19, 0, 0);
 
2251
        keys << Qt::Key_Up;
 
2252
        expected << QTime(20, 0, 0);
 
2253
        keys << Qt::Key_Up;
 
2254
        expected << QTime(21, 0, 0);
 
2255
        keys << Qt::Key_Up;
 
2256
        expected << QTime(22, 0, 0);
 
2257
        keys << Qt::Key_Up;
 
2258
        expected << QTime(23, 0, 0);
 
2259
        keys << Qt::Key_Down;
 
2260
        expected << QTime(22, 0, 0);
 
2261
        keys << Qt::Key_Down;
 
2262
        expected << QTime(21, 0, 0);
 
2263
        keys << Qt::Key_Down;
 
2264
        expected << QTime(20, 0, 0);
 
2265
        keys << Qt::Key_Down;
 
2266
        expected << QTime(19, 0, 0);
 
2267
        keys << Qt::Key_Down;
 
2268
        expected << QTime(18, 0, 0);
 
2269
        keys << Qt::Key_Down;
 
2270
        expected << QTime(17, 0, 0);
 
2271
        keys << Qt::Key_Down;
 
2272
        expected << QTime(16, 0, 0);
 
2273
        keys << Qt::Key_Down;
 
2274
        expected << QTime(15, 0, 0);
 
2275
        keys << Qt::Key_Down;
 
2276
        expected << QTime(14, 0, 0);
 
2277
        keys << Qt::Key_Down;
 
2278
        expected << QTime(13, 0, 0);
 
2279
        keys << Qt::Key_Down;
 
2280
        expected << QTime(12, 0, 0);
 
2281
        keys << Qt::Key_Down;
 
2282
        expected << QTime(11, 0, 0);
 
2283
        keys << Qt::Key_Down;
 
2284
        expected << QTime(10, 0, 0);
 
2285
        keys << Qt::Key_Down;
 
2286
        expected << QTime(9, 0, 0);
 
2287
        keys << Qt::Key_Down;
 
2288
        expected << QTime(8, 0, 0);
 
2289
        keys << Qt::Key_Down;
 
2290
        expected << QTime(7, 0, 0);
 
2291
        keys << Qt::Key_Down;
 
2292
        expected << QTime(6, 0, 0);
 
2293
        keys << Qt::Key_Down;
 
2294
        expected << QTime(5, 0, 0);
 
2295
        keys << Qt::Key_Down;
 
2296
        expected << QTime(4, 0, 0);
 
2297
        keys << Qt::Key_Down;
 
2298
        expected << QTime(3, 0, 0);
 
2299
        keys << Qt::Key_Down;
 
2300
        expected << QTime(2, 0, 0);
 
2301
        keys << Qt::Key_Down;
 
2302
        expected << QTime(1, 0, 0);
 
2303
        keys << Qt::Key_Down;
 
2304
        expected << QTime(0, 0, 0);
 
2305
 
 
2306
        QTest::newRow("hh 1") << QString("hh") << keys << expected << QTime(0, 0)
 
2307
                              << QTime(0, 0) << QTime(23, 59, 59);
 
2308
        QTest::newRow("hh:ap 1") << QString("hh:ap") << keys << expected
 
2309
                                 << QTime(0, 0) << QTime(0, 0)
 
2310
                                 << QTime(23, 59, 59);
 
2311
 
 
2312
        QTest::newRow("HH:ap 2") << QString("HH:ap") << keys << expected
 
2313
                                 << QTime(0, 0) << QTime(0, 0)
 
2314
                                 << QTime(23, 59, 59);
 
2315
    }
 
2316
    {
 
2317
        KeyList keys;
 
2318
        TimeList expected;
 
2319
        keys << Qt::Key_Down;
 
2320
        expected << QTime(2, 0, 0);
 
2321
        QTest::newRow("hh 2") << QString("hh") << keys << expected << QTime(0, 0) << QTime(2, 0, 0) << QTime(23, 59, 59);
 
2322
        QTest::newRow("hh:ap 2") << QString("hh:ap") << keys << expected << QTime(0, 0) << QTime(2, 0, 0) << QTime(23, 59, 59);
 
2323
    }
 
2324
    {
 
2325
        KeyList keys;
 
2326
        TimeList expected;
 
2327
        keys << Qt::Key_Up;
 
2328
        expected << QTime(23, 0, 0);
 
2329
        keys << Qt::Key_Up;
 
2330
        expected << QTime(23, 0, 0);
 
2331
        QTest::newRow("hh 3") << QString("hh") << keys << expected << QTime(0, 0) << QTime(22, 0, 0)
 
2332
                              << QTime(23, 59, 59);
 
2333
        QTest::newRow("hh:ap 3") << QString("hh:ap") << keys << expected << QTime(0, 0)
 
2334
                                 << QTime(22, 0, 0) << QTime(23, 59, 59);
 
2335
    }
 
2336
    {
 
2337
        KeyList keys;
 
2338
        TimeList expected;
 
2339
        keys << Qt::Key_Up;
 
2340
        expected << QTime(15, 31, 0);
 
2341
        QTest::newRow("hh:mm:ap 3") << QString("hh:mm:ap") << keys << expected << QTime(15, 31, 0)
 
2342
                                    << QTime(9, 0, 0) << QTime(16, 0, 0);
 
2343
        QTest::newRow("hh:mm 3") << QString("hh:mm") << keys << expected << QTime(15, 31, 0)
 
2344
                                 << QTime(9, 0, 0) << QTime(16, 0, 0);
 
2345
    }
 
2346
}
 
2347
 
 
2348
void tst_QDateTimeEdit::stepHourAMPM()
 
2349
{
 
2350
    QFETCH(QString, format);
 
2351
    QFETCH(KeyList, keys);
 
2352
    QFETCH(TimeList, expected);
 
2353
    QFETCH(QTime, start);
 
2354
    QFETCH(QTime, min);
 
2355
    QFETCH(QTime, max);
 
2356
 
 
2357
    testWidget->setDisplayFormat(format);
 
2358
    testWidget->setTime(start);
 
2359
    testWidget->setMinimumTime(min);
 
2360
    testWidget->setMaximumTime(max);
 
2361
    if (keys.size() != expected.size()) {
 
2362
        qWarning("%s:%d Test broken", __FILE__, __LINE__);
 
2363
        QCOMPARE(keys.size(), expected.size());
 
2364
    }
 
2365
 
 
2366
    for (int i=0; i<keys.size(); ++i) {
 
2367
        QTest::keyClick(testWidget, keys.at(i));
 
2368
        QCOMPARE(testWidget->time(), expected.at(i));
 
2369
    }
 
2370
}
 
2371
 
 
2372
void tst_QDateTimeEdit::displayedSections_data()
 
2373
{
 
2374
    QTest::addColumn<QString>("format");
 
2375
    QTest::addColumn<uint>("section");
 
2376
 
 
2377
    QTest::newRow("data0") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2378
                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::MonthSection
 
2379
                                  | QDateTimeEdit::YearSection | QDateTimeEdit::HourSection
 
2380
                                  | QDateTimeEdit::MinuteSection | QDateTimeEdit::SecondSection
 
2381
                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
 
2382
    QTest::newRow("data1") << QString("dd/yyyy hh:mm:ss zzz ap")
 
2383
                        << (uint)(QDateTimeEdit::DaySection
 
2384
                                  | QDateTimeEdit::YearSection | QDateTimeEdit::HourSection
 
2385
                                  | QDateTimeEdit::MinuteSection | QDateTimeEdit::SecondSection
 
2386
                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
 
2387
    QTest::newRow("data2") << QString("dd/MM/yyyy mm zzz ap")
 
2388
                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::MonthSection
 
2389
                                  | QDateTimeEdit::YearSection
 
2390
                                  | QDateTimeEdit::MinuteSection
 
2391
                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
 
2392
    QTest::newRow("data3") << QString("dd/MM/yyyy")
 
2393
                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::MonthSection
 
2394
                                  | QDateTimeEdit::YearSection);
 
2395
    QTest::newRow("data4") << QString("hh:mm:ss zzz ap")
 
2396
                        << (uint)(QDateTimeEdit::HourSection
 
2397
                                  | QDateTimeEdit::MinuteSection | QDateTimeEdit::SecondSection
 
2398
                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
 
2399
    QTest::newRow("data5") << QString("dd ap")
 
2400
                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::AmPmSection);
 
2401
    QTest::newRow("data6") << QString("zzz")
 
2402
                        << (uint)QDateTimeEdit::MSecSection;
 
2403
}
 
2404
 
 
2405
void tst_QDateTimeEdit::displayedSections()
 
2406
{
 
2407
    QFETCH(QString, format);
 
2408
    QFETCH(uint, section);
 
2409
 
 
2410
    testWidget->setDisplayFormat(format);
 
2411
    QCOMPARE(QDateTimeEdit::Sections(section), testWidget->displayedSections());
 
2412
}
 
2413
 
 
2414
void tst_QDateTimeEdit::currentSection_data()
 
2415
{
 
2416
    QTest::addColumn<QString>("format");
 
2417
    QTest::addColumn<uint>("section");
 
2418
    QTest::addColumn<uint>("currentSection");
 
2419
 
 
2420
    // First is deliberate, this way we can make sure that it is not reset by specifying no section.
 
2421
    QTest::newRow("data0") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2422
                        << (uint)QDateTimeEdit::NoSection << (uint)QDateTimeEdit::YearSection;
 
2423
    QTest::newRow("data1") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2424
                        << (uint)QDateTimeEdit::AmPmSection << (uint)QDateTimeEdit::AmPmSection;
 
2425
    QTest::newRow("data2") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2426
                        << (uint)QDateTimeEdit::MSecSection << (uint)QDateTimeEdit::MSecSection;
 
2427
    QTest::newRow("data3") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2428
                        << (uint)QDateTimeEdit::SecondSection << (uint)QDateTimeEdit::SecondSection;
 
2429
    QTest::newRow("data4") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2430
                        << (uint)QDateTimeEdit::MinuteSection << (uint)QDateTimeEdit::MinuteSection;
 
2431
    QTest::newRow("data5") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2432
                        << (uint)QDateTimeEdit::HourSection << (uint)QDateTimeEdit::HourSection;
 
2433
    QTest::newRow("data6") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2434
                        << (uint)QDateTimeEdit::DaySection << (uint)QDateTimeEdit::DaySection;
 
2435
    QTest::newRow("data7") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2436
                        << (uint)QDateTimeEdit::MonthSection << (uint)QDateTimeEdit::MonthSection;
 
2437
    QTest::newRow("data8") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
 
2438
                        << (uint)QDateTimeEdit::YearSection << (uint)QDateTimeEdit::YearSection;
 
2439
    QTest::newRow("data9") << QString("dd/MM/yyyy hh:mm:ss zzz AP")
 
2440
                        << (uint)QDateTimeEdit::AmPmSection << (uint)QDateTimeEdit::AmPmSection;
 
2441
    QTest::newRow("data10") << QString("dd/MM/yyyy hh:mm:ss ap")
 
2442
                         << (uint)QDateTimeEdit::MSecSection << (uint)QDateTimeEdit::DaySection;
 
2443
}
 
2444
 
 
2445
void tst_QDateTimeEdit::currentSection()
 
2446
{
 
2447
    QFETCH(QString, format);
 
2448
    QFETCH(uint, section);
 
2449
    QFETCH(uint, currentSection);
 
2450
 
 
2451
    testWidget->setDisplayFormat(format);
 
2452
    if ((QDateTimeEdit::Section)section == QDateTimeEdit::NoSection)
 
2453
        testWidget->setCurrentSection(QDateTimeEdit::YearSection); // Ensure it's not reset (see above)
 
2454
    testWidget->setCurrentSection((QDateTimeEdit::Section)section);
 
2455
    QCOMPARE((QDateTimeEdit::Section)currentSection, testWidget->currentSection());
 
2456
}
 
2457
 
 
2458
void tst_QDateTimeEdit::readOnly()
 
2459
{
 
2460
    testWidget->hide();
 
2461
    QDateTimeEdit dt(QDate(2000, 2, 1));
 
2462
    dt.setDisplayFormat("yyyy.MM.dd");
 
2463
    dt.show();
 
2464
    dt.setCurrentSection(QDateTimeEdit::DaySection);
 
2465
    QTest::keyClick(&dt, Qt::Key_Up);
 
2466
    QCOMPARE(dt.date(), QDate(2000, 2, 2));
 
2467
    dt.setReadOnly(true);
 
2468
    QTest::keyClick(&dt, Qt::Key_Up);
 
2469
    QCOMPARE(dt.date(), QDate(2000, 2, 2));
 
2470
    dt.stepBy(1); // stepBy should still work
 
2471
    QCOMPARE(dt.date(), QDate(2000, 2, 3));
 
2472
    dt.setReadOnly(false);
 
2473
    QTest::keyClick(&dt, Qt::Key_Up);
 
2474
    QCOMPARE(dt.date(), QDate(2000, 2, 4));
 
2475
}
 
2476
 
 
2477
void tst_QDateTimeEdit::weirdCase()
 
2478
{
 
2479
    testWidget->lineEdit()->setCursorPosition(0);
 
2480
    testWidget->setDateRange(QDate(2005, 1, 1), QDate(2010, 12, 31));
 
2481
    testWidget->setDisplayFormat("dd//MM//yyyy");
 
2482
    testWidget->setDate(testWidget->minimumDate());
 
2483
    QTest::keyClick(testWidget, Qt::Key_Left);
 
2484
    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
 
2485
    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 0);
 
2486
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2487
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2488
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2489
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2490
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2491
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2492
    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
 
2493
    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 8);
 
2494
 
 
2495
    QTest::keyClick(testWidget, Qt::Key_Delete);
 
2496
    QCOMPARE(testWidget->text(), QString("01//01//005"));
 
2497
    QTest::keyClick(testWidget, Qt::Key_4);
 
2498
    QCOMPARE(testWidget->text(), QString("01//01//005"));
 
2499
}
 
2500
 
 
2501
void tst_QDateTimeEdit::newCase()
 
2502
{
 
2503
    if (QDate::shortMonthName(6) != "Jun" || QDate::shortMonthName(7) != "Jul" ||
 
2504
        QDate::longMonthName(6) != "June" || QDate::longMonthName(7) != "July")
 
2505
        QSKIP("This test only works in English");
 
2506
 
 
2507
    testWidget->setDisplayFormat("MMMM'a'MbMMMcMM");
 
2508
    testWidget->setDate(QDate(2005, 6, 1));
 
2509
    QCOMPARE(testWidget->text(), QString("Junea6bJunc06"));
 
2510
#ifdef Q_OS_MAC
 
2511
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
2512
#else
 
2513
    QTest::keyClick(testWidget, Qt::Key_Home);
 
2514
#endif
 
2515
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2516
    QCOMPARE(testWidget->text(), QString("Julya7bJulc07"));
 
2517
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("July"));
 
2518
#ifdef Q_OS_MAC
 
2519
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
2520
#else
 
2521
    QTest::keyClick(testWidget, Qt::Key_Home);
 
2522
#endif
 
2523
#ifdef Q_OS_MAC
 
2524
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
2525
#endif
 
2526
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString());
 
2527
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2528
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2529
    QTest::keyClick(testWidget, Qt::Key_Right);
 
2530
    QTest::keyClick(testWidget, Qt::Key_Delete);
 
2531
    QTest::keyClick(testWidget, Qt::Key_Left);
 
2532
 
 
2533
    QCOMPARE(testWidget->text(), QString("Jula7bJulc07"));
 
2534
    QTest::keyClick(testWidget, Qt::Key_Delete);
 
2535
    QCOMPARE(testWidget->text(), QString("Jua7bJulc07"));
 
2536
    QTest::keyClick(testWidget, Qt::Key_N);
 
2537
    QCOMPARE(testWidget->text(), QString("Juna7bJulc07"));
 
2538
    QTest::keyClick(testWidget, Qt::Key_E);
 
2539
    QCOMPARE(testWidget->text(), QString("Junea6bJunc06"));
 
2540
}
 
2541
 
 
2542
void tst_QDateTimeEdit::newCase2()
 
2543
{
 
2544
    testWidget->setDisplayFormat("MMMM yyyy-MM-dd MMMM");
 
2545
    testWidget->setDate(QDate(2005, 8, 8));
 
2546
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2547
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
2548
    QCOMPARE(testWidget->text(), QString(" 2005-08-08 ") + QDate::longMonthName(8));
 
2549
}
 
2550
 
 
2551
void tst_QDateTimeEdit::newCase3()
 
2552
{
 
2553
    if (!QDate::longMonthName(1).startsWith("Januar"))
 
2554
        QSKIP("This test does not work in this locale");
 
2555
 
 
2556
    testWidget->setDisplayFormat("dd MMMM yyyy");
 
2557
    testWidget->setDate(QDate(2000, 1, 1));
 
2558
    testWidget->setGeometry(QRect(QPoint(0, 0), testWidget->sizeHint()));
 
2559
    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
 
2560
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2561
    QTest::keyClick(testWidget, Qt::Key_J);
 
2562
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("01 J 2000"));
 
2563
    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 4);
 
2564
    QTest::keyClick(testWidget, Qt::Key_A);
 
2565
    QTest::keyClick(testWidget, Qt::Key_N);
 
2566
    QTest::keyClick(testWidget, Qt::Key_U);
 
2567
    QTest::keyClick(testWidget, Qt::Key_A);
 
2568
    QTest::keyClick(testWidget, Qt::Key_R);
 
2569
}
 
2570
 
 
2571
void tst_QDateTimeEdit::cursorPos()
 
2572
{
 
2573
    if (QDate::longMonthName(1) != "January")
 
2574
        QSKIP("This test only works in English");
 
2575
 
 
2576
    testWidget->setDisplayFormat("dd MMMM yyyy");
 
2577
    //testWidget->setGeometry(0, 0, 200, 200);
 
2578
    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
 
2579
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2580
    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 10);
 
2581
    QTest::keyClick(testWidget, Qt::Key_J);
 
2582
    QTest::keyClick(testWidget, Qt::Key_A);
 
2583
    QTest::keyClick(testWidget, Qt::Key_N);
 
2584
    QTest::keyClick(testWidget, Qt::Key_U);
 
2585
    QTest::keyClick(testWidget, Qt::Key_A);
 
2586
    QTest::keyClick(testWidget, Qt::Key_R);
 
2587
    //QCursor::setPos(20, 20);
 
2588
    //QEventLoop l;
 
2589
    //l.exec();
 
2590
    QTest::keyClick(testWidget, Qt::Key_Y);
 
2591
    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 11);
 
2592
#ifdef Q_OS_MAC
 
2593
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
2594
#else
 
2595
    QTest::keyClick(testWidget, Qt::Key_Home);
 
2596
#endif
 
2597
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2598
    QTest::keyClick(testWidget, Qt::Key_3);
 
2599
    QTest::keyClick(testWidget, Qt::Key_1);
 
2600
#ifdef Q_OS_MAC
 
2601
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
2602
#endif
 
2603
    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 3);
 
2604
}
 
2605
 
 
2606
void tst_QDateTimeEdit::newCase4()
 
2607
{
 
2608
    testWidget->setDisplayFormat("hh:mm");
 
2609
    testWidget->setMinimumTime(QTime(3, 3, 0));
 
2610
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2611
    QTest::keyClick(testWidget, Qt::Key_0);
 
2612
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("0:03"));
 
2613
    QTest::keyClick(testWidget, Qt::Key_2);
 
2614
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("0:03"));
 
2615
    QTest::keyClick(testWidget, Qt::Key_4);
 
2616
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("04:03"));
 
2617
}
 
2618
 
 
2619
void tst_QDateTimeEdit::newCase5()
 
2620
{
 
2621
    testWidget->setDisplayFormat("yyyy-MM-dd hh:mm:ss zzz 'ms'");
 
2622
    testWidget->setDateTime(QDateTime(QDate(2005, 10, 7), QTime(17, 44, 13, 100)));
 
2623
    testWidget->show();
 
2624
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2005-10-07 17:44:13 100 ms"));
 
2625
#ifdef Q_OS_MAC
 
2626
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
2627
#else
 
2628
    QTest::keyClick(testWidget, Qt::Key_End);
 
2629
#endif
 
2630
    QTest::keyClick(testWidget, Qt::Key_Backtab, Qt::ShiftModifier);
 
2631
 
 
2632
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2633
    QTest::keyClick(testWidget, Qt::Key_1);
 
2634
    QTest::keyClick(testWidget, Qt::Key_2);
 
2635
    QTest::keyClick(testWidget, Qt::Key_4);
 
2636
#ifdef Q_OS_MAC
 
2637
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
2638
#endif
 
2639
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2005-10-07 17:44:13 124 ms"));
 
2640
 
 
2641
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
2642
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2005-10-07 17:44:13 12 ms"));
 
2643
}
 
2644
 
 
2645
void tst_QDateTimeEdit::newCase6()
 
2646
{
 
2647
    testWidget->setDisplayFormat("d-yyyy-MM-dd");
 
2648
    testWidget->setDate(QDate(2005, 10, 7));
 
2649
    testWidget->show();
 
2650
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("7-2005-10-07"));
 
2651
#ifdef Q_OS_MAC
 
2652
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
2653
#else
 
2654
    QTest::keyClick(testWidget, Qt::Key_Home);
 
2655
#endif
 
2656
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2657
    QTest::keyClick(testWidget, Qt::Key_1);
 
2658
    QTest::keyClick(testWidget, Qt::Key_2);
 
2659
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("12-2005-10-12"));
 
2660
}
 
2661
 
 
2662
void tst_QDateTimeEdit::task98554()
 
2663
{
 
2664
    testWidget->setDisplayFormat("mm.ss.zzz(ms)");
 
2665
    testWidget->setTime(QTime(0, 0, 9));
 
2666
    testWidget->setCurrentSection(QDateTimeEdit::SecondSection);
 
2667
    testWidget->show();
 
2668
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00.09.000(09)"));
 
2669
    QCOMPARE(testWidget->time(), QTime(0, 0, 9, 0));
 
2670
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2671
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00.10.000(010)"));
 
2672
    QCOMPARE(testWidget->time(), QTime(0, 0, 10, 0));
 
2673
}
 
2674
 
 
2675
static QList<int> makeList(int val1, int val2, int val3)
 
2676
{
 
2677
    QList<int> ret;
 
2678
    ret << val1 << val2 << val3;
 
2679
    return ret;
 
2680
}
 
2681
 
 
2682
void tst_QDateTimeEdit::setCurrentSection_data()
 
2683
{
 
2684
    QTest::addColumn<QString>("format");
 
2685
    QTest::addColumn<QDateTime>("dateTime");
 
2686
    QTest::addColumn<QList<int> >("setCurrentSections");
 
2687
    QTest::addColumn<QList<int> >("expectedCursorPositions");
 
2688
 
 
2689
    QTest::newRow("Day") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2690
                         << makeList(QDateTimeEdit::DaySection, QDateTimeEdit::DaySection, QDateTimeEdit::DaySection)
 
2691
                         << makeList(24, 0, 24);
 
2692
    QTest::newRow("Month") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2693
                           << makeList(QDateTimeEdit::MonthSection, QDateTimeEdit::MonthSection, QDateTimeEdit::MonthSection)
 
2694
                           << makeList(3, 26, 3);
 
2695
    QTest::newRow("Year") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2696
                          << makeList(QDateTimeEdit::YearSection, QDateTimeEdit::YearSection, QDateTimeEdit::YearSection)
 
2697
                          << makeList(6, 28, 6);
 
2698
    QTest::newRow("Hour") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2699
                          << makeList(QDateTimeEdit::HourSection, QDateTimeEdit::HourSection, QDateTimeEdit::HourSection)
 
2700
                          << makeList(11, 31, 11);
 
2701
    QTest::newRow("Minute") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2702
                            << makeList(QDateTimeEdit::MinuteSection, QDateTimeEdit::MinuteSection, QDateTimeEdit::MinuteSection)
 
2703
                            << makeList(14, 33, 14);
 
2704
    QTest::newRow("Second") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2705
                            << makeList(QDateTimeEdit::SecondSection, QDateTimeEdit::SecondSection, QDateTimeEdit::SecondSection)
 
2706
                            << makeList(17, 35, 17);
 
2707
    QTest::newRow("MSec") << QString("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z") << QDateTime(QDate(2001, 1, 1), QTime(1, 2, 3, 4))
 
2708
                          << makeList(QDateTimeEdit::MSecSection, QDateTimeEdit::MSecSection, QDateTimeEdit::MSecSection)
 
2709
                          << makeList(20, 37, 20);
 
2710
}
 
2711
 
 
2712
void tst_QDateTimeEdit::setCurrentSection()
 
2713
{
 
2714
    QFETCH(QString, format);
 
2715
    QFETCH(QDateTime, dateTime);
 
2716
    QFETCH(QList<int>, setCurrentSections);
 
2717
    QFETCH(QList<int>, expectedCursorPositions);
 
2718
 
 
2719
    QCOMPARE(setCurrentSections.size(), expectedCursorPositions.size());
 
2720
    testWidget->setDisplayFormat(format);
 
2721
    testWidget->setDateTime(dateTime);
 
2722
#ifdef Q_OS_MAC
 
2723
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
2724
#else
 
2725
    QTest::keyClick(testWidget, Qt::Key_Home);
 
2726
#endif
 
2727
 
 
2728
    testWidget->resize(400, 100);
 
2729
    for (int i=0; i<setCurrentSections.size(); ++i) {
 
2730
        testWidget->setCurrentSection((QDateTimeEdit::Section)setCurrentSections.at(i));
 
2731
        QCOMPARE(testWidget->currentSection(), (QDateTimeEdit::Section)setCurrentSections.at(i));
 
2732
        QCOMPARE(testWidget->lineEdit()->cursorPosition(), expectedCursorPositions.at(i));
 
2733
    }
 
2734
}
 
2735
 
 
2736
void tst_QDateTimeEdit::setSelectedSection()
 
2737
{
 
2738
    testWidget->setDisplayFormat("mm.ss.zzz('ms') m");
 
2739
    testWidget->setTime(QTime(0, 0, 9));
 
2740
    testWidget->show();
 
2741
#ifdef Q_OS_MAC
 
2742
    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
 
2743
#else
 
2744
    QTest::keyClick(testWidget, Qt::Key_Home);
 
2745
#endif
 
2746
#ifdef Q_OS_MAC
 
2747
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
2748
#endif
 
2749
    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
 
2750
    testWidget->setSelectedSection(QDateTimeEdit::MinuteSection);
 
2751
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("00"));
 
2752
    testWidget->setCurrentSection(QDateTimeEdit::MinuteSection);
 
2753
    testWidget->setSelectedSection(QDateTimeEdit::MinuteSection);
 
2754
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("0"));
 
2755
    testWidget->setSelectedSection(QDateTimeEdit::SecondSection);
 
2756
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("09"));
 
2757
    testWidget->setSelectedSection(QDateTimeEdit::NoSection);
 
2758
    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
 
2759
}
 
2760
 
 
2761
void tst_QDateTimeEdit::calendarPopup()
 
2762
{
 
2763
    {
 
2764
        QDateEdit edit;
 
2765
        QVERIFY(!edit.calendarWidget());
 
2766
        edit.setCalendarPopup(true);
 
2767
        QVERIFY(edit.calendarWidget());
 
2768
    }
 
2769
 
 
2770
    {
 
2771
        QTimeEdit edit;
 
2772
        QVERIFY(!edit.calendarWidget());
 
2773
        edit.setCalendarPopup(true);
 
2774
        QVERIFY(!edit.calendarWidget());
 
2775
    }
 
2776
 
 
2777
    {
 
2778
        QDateEdit edit;
 
2779
        QVERIFY(!edit.calendarWidget());
 
2780
        QCalendarWidget *cw = new QCalendarWidget;
 
2781
        edit.setCalendarWidget(cw);
 
2782
        QVERIFY(!edit.calendarWidget());
 
2783
        edit.setCalendarPopup(true);
 
2784
        edit.setCalendarWidget(cw);
 
2785
        QCOMPARE(edit.calendarWidget(), cw);
 
2786
        edit.setDateRange(QDate(1980, 1, 5), QDate(1980, 2, 11));
 
2787
        QCOMPARE(cw->minimumDate(), edit.minimumDate());
 
2788
        QCOMPARE(cw->maximumDate(), edit.maximumDate());
 
2789
        edit.setDate(QDate(1980, 1, 31));
 
2790
        QCOMPARE(edit.date(), cw->selectedDate());
 
2791
        cw->setSelectedDate(QDate(1980, 1, 30));
 
2792
        QCOMPARE(edit.date(), cw->selectedDate());
 
2793
    }
 
2794
 
 
2795
    testWidget->setDisplayFormat("dd/MM/yyyy");
 
2796
    testWidget->setDateTime(QDateTime(QDate(2000, 1, 1), QTime(0, 0)));
 
2797
    testWidget->show();
 
2798
    testWidget->setCalendarPopup(true);
 
2799
    QCOMPARE(testWidget->calendarPopup(), true);
 
2800
    QStyle *style = testWidget->style();
 
2801
    QStyleOptionComboBox opt;
 
2802
    opt.initFrom(testWidget);
 
2803
    opt.editable = true;
 
2804
    opt.subControls = QStyle::SC_ComboBoxArrow;
 
2805
    QRect rect = style->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, testWidget);
 
2806
    QTest::mouseClick(testWidget, Qt::LeftButton, 0, QPoint(rect.left()+rect.width()/2, rect.top()+rect.height()/2));
 
2807
    QWidget *wid = testWidget->findChild<QWidget *>("qt_datetimedit_calendar");
 
2808
    QVERIFY(wid != 0);
 
2809
    testWidget->hide();
 
2810
 
 
2811
    QTimeEdit timeEdit;
 
2812
    timeEdit.setCalendarPopup(true);
 
2813
    timeEdit.show();
 
2814
 
 
2815
    opt.initFrom(&timeEdit);
 
2816
    opt.subControls = QStyle::SC_ComboBoxArrow;
 
2817
    rect = style->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, &timeEdit);
 
2818
    QTest::mouseClick(&timeEdit, Qt::LeftButton, 0, QPoint(rect.left()+rect.width()/2, rect.top()+rect.height()/2));
 
2819
    QWidget *wid2 = timeEdit.findChild<QWidget *>("qt_datetimedit_calendar");
 
2820
    QVERIFY(!wid2);
 
2821
    timeEdit.hide();
 
2822
 
 
2823
 
 
2824
    QDateEdit dateEdit;
 
2825
    dateEdit.setCalendarPopup(true);
 
2826
    dateEdit.setReadOnly(true);
 
2827
    dateEdit.show();
 
2828
 
 
2829
    opt.initFrom(&dateEdit);
 
2830
    opt.subControls = QStyle::SC_ComboBoxArrow;
 
2831
    rect = style->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, &dateEdit);
 
2832
    QTest::mouseClick(&dateEdit, Qt::LeftButton, 0, QPoint(rect.left()+rect.width()/2, rect.top()+rect.height()/2));
 
2833
    QWidget *wid3 = dateEdit.findChild<QWidget *>("qt_datetimedit_calendar");
 
2834
    QVERIFY(!wid3);
 
2835
    dateEdit.hide();
 
2836
}
 
2837
 
 
2838
class RestoreLayoutDirectioner
 
2839
{
 
2840
public:
 
2841
    RestoreLayoutDirectioner(Qt::LayoutDirection was)
 
2842
        : old(was)
 
2843
    {}
 
2844
 
 
2845
    ~RestoreLayoutDirectioner()
 
2846
    {
 
2847
        QApplication::setLayoutDirection(old);
 
2848
    }
 
2849
private:
 
2850
    const Qt::LayoutDirection old;
 
2851
};
 
2852
 
 
2853
void tst_QDateTimeEdit::reverseTest()
 
2854
{
 
2855
    const RestoreLayoutDirectioner restorer(QApplication::layoutDirection());
 
2856
    QApplication::setLayoutDirection(Qt::RightToLeft);
 
2857
    testWidget->setDisplayFormat("dd/MM/yyyy");
 
2858
    testWidget->setDate(QDate(2001, 3, 30));
 
2859
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2001/03/30"));
 
2860
#ifdef Q_OS_MAC
 
2861
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
2862
#else
 
2863
    QTest::keyClick(testWidget, Qt::Key_End);
 
2864
#endif
 
2865
#ifdef Q_OS_MAC
 
2866
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
2867
#endif
 
2868
    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::DaySection);
 
2869
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2870
    QCOMPARE(testWidget->date(), QDate(2001, 3, 31));
 
2871
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2001/03/31"));
 
2872
}
 
2873
 
 
2874
void tst_QDateTimeEdit::hour12Test()
 
2875
{
 
2876
    testWidget->setDisplayFormat("hh a");
 
2877
    testWidget->setTime(QTime(0, 0, 0));
 
2878
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("12 am"));
 
2879
    for (int i=0; i<11; ++i) {
 
2880
        QTest::keyClick(testWidget, Qt::Key_Up);
 
2881
    }
 
2882
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 am"));
 
2883
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2884
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("12 pm"));
 
2885
    for (int i=0; i<11; ++i) {
 
2886
        QTest::keyClick(testWidget, Qt::Key_Up);
 
2887
    }
 
2888
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 pm"));
 
2889
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2890
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 pm"));
 
2891
    for (int i=0; i<12; ++i) {
 
2892
        QTest::keyClick(testWidget, Qt::Key_Down);
 
2893
    }
 
2894
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 am"));
 
2895
    QTest::keyClick(testWidget, Qt::Key_1);
 
2896
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("1 am"));
 
2897
    QTest::keyClick(testWidget, Qt::Key_3);
 
2898
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("1 am"));
 
2899
}
 
2900
 
 
2901
void tst_QDateTimeEdit::yyTest()
 
2902
{
 
2903
    testWidget->setDisplayFormat("dd-MMM-yy");
 
2904
    testWidget->setTime(QTime(0, 0, 0));
 
2905
    testWidget->setDateRange(QDate(2005, 1, 1), QDate(2010, 12, 31));
 
2906
    testWidget->setDate(testWidget->minimumDate());
 
2907
    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
 
2908
 
 
2909
    QString jan = QDate::shortMonthName(1);
 
2910
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-05");
 
2911
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2912
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-06");
 
2913
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2914
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-07");
 
2915
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2916
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-08");
 
2917
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2918
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-09");
 
2919
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2920
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-10");
 
2921
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2922
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-10");
 
2923
    testWidget->setWrapping(true);
 
2924
    QTest::keyClick(testWidget, Qt::Key_Up);
 
2925
    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-05");
 
2926
 
 
2927
    testWidget->setDateRange(QDate(100, 1, 1), QDate(8000, 12, 31));
 
2928
    testWidget->setDate(QDate(2000, 1, 1));
 
2929
    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
 
2930
    testWidget->setWrapping(false);
 
2931
    for (int i=0; i<10; ++i) {
 
2932
        for (int j=0; j<50; ++j) {
 
2933
            testWidget->stepBy(-1);
 
2934
        }
 
2935
        testWidget->stepBy(-50);
 
2936
        QCOMPARE(testWidget->sectionText(QDateTimeEdit::YearSection), QString("00"));
 
2937
        QCOMPARE(testWidget->date(), QDate(2000 - ((i + 1) * 100), 1, 1));
 
2938
    }
 
2939
}
 
2940
 
 
2941
void tst_QDateTimeEdit::task108572()
 
2942
{
 
2943
    testWidget->setDisplayFormat("hh:mm:ss.zzz");
 
2944
    testWidget->setTime(QTime(0, 1, 2, 0));
 
2945
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00:01:02.000"));
 
2946
 
 
2947
    testWidget->setCurrentSection(QDateTimeEdit::MSecSection);
 
2948
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2949
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("000"));
 
2950
    QTest::keyClick(testWidget, Qt::Key_2);
 
2951
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00:01:02.2"));
 
2952
    QTest::keyClick(testWidget, Qt::Key_Return);
 
2953
    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00:01:02.200"));
 
2954
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("200"));
 
2955
    QCOMPARE(testWidget->time(), QTime(0, 1, 2, 200));
 
2956
}
 
2957
 
 
2958
void tst_QDateTimeEdit::task149097()
 
2959
{
 
2960
    QSignalSpy dtSpy(testWidget, SIGNAL(dateTimeChanged(QDateTime)));
 
2961
    QSignalSpy dSpy(testWidget, SIGNAL(dateChanged(QDate)));
 
2962
    QSignalSpy tSpy(testWidget, SIGNAL(timeChanged(QTime)));
 
2963
 
 
2964
    testWidget->setDisplayFormat("yyyy/MM/dd hh:mm:ss");
 
2965
    testWidget->setDateTime(QDateTime(QDate(2001, 02, 03), QTime(5, 1, 2)));
 
2966
//    QTest::keyClick(testWidget, Qt::Key_Enter);
 
2967
    QCOMPARE(dtSpy.count(), 1);
 
2968
    QCOMPARE(dSpy.count(), 1);
 
2969
    QCOMPARE(tSpy.count(), 1);
 
2970
    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
 
2971
    testWidget->stepBy(1);
 
2972
 
 
2973
    QCOMPARE(dtSpy.count(), 2);
 
2974
    QCOMPARE(dSpy.count(), 2);
 
2975
    QCOMPARE(tSpy.count(), 1);
 
2976
 
 
2977
    testWidget->setCurrentSection(QDateTimeEdit::MinuteSection);
 
2978
    testWidget->stepBy(1);
 
2979
 
 
2980
    QCOMPARE(dtSpy.count(), 3);
 
2981
    QCOMPARE(dSpy.count(), 2);
 
2982
    QCOMPARE(tSpy.count(), 2);
 
2983
}
 
2984
 
 
2985
void tst_QDateTimeEdit::task148725()
 
2986
{
 
2987
    testWidget->setDisplayFormat("dd/MM");
 
2988
    testWidget->setDate(QDate(2001, 2, 27));
 
2989
    testWidget->stepBy(1);
 
2990
    QCOMPARE(testWidget->date(), QDate(2001, 2, 28));
 
2991
    testWidget->stepBy(1);
 
2992
    QCOMPARE(testWidget->date(), QDate(2001, 2, 28));
 
2993
    testWidget->setWrapping(true);
 
2994
    testWidget->stepBy(1);
 
2995
    QCOMPARE(testWidget->date(), QDate(2001, 2, 1));
 
2996
}
 
2997
 
 
2998
void tst_QDateTimeEdit::task148522()
 
2999
{
 
3000
    QTimeEdit edit;
 
3001
    const QDateTime dt(QDate(2000, 12, 12), QTime(12, 13, 14, 15));
 
3002
    edit.setDateTime(dt);
 
3003
    QCOMPARE(edit.dateTime(), dt);
 
3004
}
 
3005
 
 
3006
void tst_QDateTimeEdit::ddMMMMyyyy()
 
3007
{
 
3008
    testWidget->setDisplayFormat("dd.MMMM.yyyy");
 
3009
    testWidget->setDate(QDate(2000, 1, 1));
 
3010
    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
 
3011
    QTest::keyClick(testWidget, Qt::Key_Enter);
 
3012
    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2000"));
 
3013
#ifdef Q_OS_MAC
 
3014
    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
 
3015
#else
 
3016
    QTest::keyClick(testWidget, Qt::Key_End);
 
3017
#endif
 
3018
    QTest::keyClick(testWidget, Qt::Key_Backspace);
 
3019
#ifdef Q_OS_MAC
 
3020
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
3021
#endif
 
3022
    QCOMPARE(testWidget->lineEdit()->text(), "01." + QDate::longMonthName(1) + ".200");
 
3023
}
 
3024
 
 
3025
#ifndef QT_NO_WHEELEVENT
 
3026
void tst_QDateTimeEdit::wheelEvent()
 
3027
{
 
3028
    testWidget->setDisplayFormat("dddd/MM");
 
3029
    testWidget->setDate(QDate(2000, 2, 21));
 
3030
    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
 
3031
    QWheelEvent w(testWidget->lineEdit()->geometry().center(), 120, 0, 0);
 
3032
    qApp->sendEvent(testWidget, &w);
 
3033
    QCOMPARE(testWidget->date(), QDate(2000, 2, 22));
 
3034
    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
 
3035
    qApp->sendEvent(testWidget, &w);
 
3036
    QCOMPARE(testWidget->date(), QDate(2000, 3, 22));
 
3037
}
 
3038
#endif // !QT_NO_WHEELEVENT
 
3039
 
 
3040
void tst_QDateTimeEdit::specialValueCornerCase()
 
3041
{
 
3042
    // if you set minimum to value it won't update since value won't
 
3043
    // be bounded to anything. If you have a specialValueText it needs
 
3044
    // to call updateEdit to make sure the text is changed
 
3045
 
 
3046
    QDateTimeEdit edit;
 
3047
    edit.setSpecialValueText("foobar");
 
3048
    edit.setMinimumDate(edit.date());
 
3049
    QCOMPARE(edit.minimumDate(), edit.date());
 
3050
    QCOMPARE(edit.text(), QString("foobar"));
 
3051
}
 
3052
 
 
3053
void tst_QDateTimeEdit::cursorPositionOnInit()
 
3054
{
 
3055
    {
 
3056
        EditorDateEdit edit;
 
3057
        edit.setDisplayFormat("dd/MM");
 
3058
        edit.show();
 
3059
        QCOMPARE(edit.lineEdit()->cursorPosition(), 0);
 
3060
    }
 
3061
 
 
3062
    {
 
3063
        EditorDateEdit edit;
 
3064
        edit.setDisplayFormat("dd/MM");
 
3065
        edit.setSpecialValueText("special");
 
3066
        edit.setMinimumDate(edit.date());
 
3067
        edit.show();
 
3068
        QCOMPARE(edit.lineEdit()->cursorPosition(), 7);
 
3069
        // ### legacy behavior. Keep it like this rather than changing
 
3070
        // ### but add a test none-the-less
 
3071
    }
 
3072
}
 
3073
 
 
3074
void tst_QDateTimeEdit::task118867()
 
3075
{
 
3076
    EditorDateEdit edit;
 
3077
    edit.setDisplayFormat("hh:mm");
 
3078
    edit.setMinimumTime(QTime(5, 30));
 
3079
    edit.setMaximumTime(QTime(6, 30));
 
3080
    QCOMPARE(edit.text(), QString("05:30"));
 
3081
    edit.lineEdit()->setCursorPosition(5);
 
3082
    QTest::keyClick(&edit, Qt::Key_Backspace);
 
3083
    QCOMPARE(edit.text(), QString("05:3"));
 
3084
    QTest::keyClick(&edit, Qt::Key_Backspace);
 
3085
    QCOMPARE(edit.text(), QString("05:"));
 
3086
    QTest::keyClick(&edit, Qt::Key_1);
 
3087
    QCOMPARE(edit.text(), QString("05:"));
 
3088
    QTest::keyClick(&edit, Qt::Key_2);
 
3089
    QCOMPARE(edit.text(), QString("05:"));
 
3090
    QTest::keyClick(&edit, Qt::Key_3);
 
3091
    QCOMPARE(edit.text(), QString("05:3"));
 
3092
    QTest::keyClick(&edit, Qt::Key_3);
 
3093
    QCOMPARE(edit.text(), QString("05:33"));
 
3094
}
 
3095
 
 
3096
void tst_QDateTimeEdit::nextPrevSection_data()
 
3097
{
 
3098
    QTest::addColumn<Qt::Key>("key");
 
3099
    QTest::addColumn<Qt::KeyboardModifiers>("modifiers");
 
3100
    QTest::addColumn<QString>("selectedText");
 
3101
 
 
3102
    QTest::newRow("tab") << Qt::Key_Tab << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
 
3103
    QTest::newRow("backtab") << Qt::Key_Backtab << (Qt::KeyboardModifiers)Qt::NoModifier << QString("12");
 
3104
    QTest::newRow("shift-tab") << Qt::Key_Tab << (Qt::KeyboardModifiers)Qt::ShiftModifier << QString("12");
 
3105
    QTest::newRow("/") << Qt::Key_Slash << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
 
3106
    QTest::newRow("b") << Qt::Key_B << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
 
3107
    QTest::newRow("c") << Qt::Key_C << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
 
3108
 
 
3109
    // 1. mac doesn't do these,
 
3110
    // 2. some WinCE devices do not have modifiers
 
3111
#if !defined(Q_OS_MAC) && !defined(WINCE_NO_MODIFIER_KEYS)
 
3112
    QTest::newRow("ctrl-right") << Qt::Key_Right << (Qt::KeyboardModifiers)Qt::ControlModifier << QString("56");
 
3113
    QTest::newRow("ctrl-left") << Qt::Key_Left << (Qt::KeyboardModifiers)Qt::ControlModifier << QString("12");
 
3114
#endif
 
3115
}
 
3116
 
 
3117
void tst_QDateTimeEdit::nextPrevSection()
 
3118
{
 
3119
    QFETCH(Qt::Key, key);
 
3120
    QFETCH(Qt::KeyboardModifiers, modifiers);
 
3121
    QFETCH(QString, selectedText);
 
3122
 
 
3123
    EditorDateEdit edit;
 
3124
    edit.setDisplayFormat("hh/mm/bc9ss");
 
3125
    edit.setTime(QTime(12, 34, 56));
 
3126
    edit.show();
 
3127
    edit.setSelectedSection(QDateTimeEdit::MinuteSection);
 
3128
    QCOMPARE(edit.lineEdit()->selectedText(), QString("34")); // selftest
 
3129
    QTest::keyClick(&edit, key, modifiers);
 
3130
    QCOMPARE(edit.lineEdit()->selectedText(), selectedText);
 
3131
}
 
3132
 
 
3133
void tst_QDateTimeEdit::dateEditTimeEditFormats()
 
3134
{
 
3135
    QTimeEdit t;
 
3136
    t.setDisplayFormat("hh yyyy");
 
3137
    QCOMPARE(t.displayedSections(), QDateTimeEdit::HourSection);
 
3138
 
 
3139
    QDateEdit d;
 
3140
    d.setDisplayFormat("hh yyyy");
 
3141
    QCOMPARE(d.displayedSections(), QDateTimeEdit::YearSection);
 
3142
}
 
3143
 
 
3144
void tst_QDateTimeEdit::timeSpec_data()
 
3145
{
 
3146
    QTest::addColumn<bool>("useSetProperty");
 
3147
    QTest::newRow("setProperty") << true;
 
3148
    QTest::newRow("setTimeSpec") << false;
 
3149
}
 
3150
 
 
3151
void tst_QDateTimeEdit::timeSpec()
 
3152
{
 
3153
    QFETCH(bool, useSetProperty);
 
3154
 
 
3155
    QDateTimeEdit edit;
 
3156
    QCOMPARE(edit.dateTime().timeSpec(), edit.timeSpec());
 
3157
    QCOMPARE(edit.minimumDateTime().timeSpec(), edit.timeSpec());
 
3158
    QCOMPARE(edit.maximumDateTime().timeSpec(), edit.timeSpec());
 
3159
    if (useSetProperty) {
 
3160
        edit.setProperty("timeSpec", Qt::UTC);
 
3161
    } else {
 
3162
        edit.setTimeSpec(Qt::UTC);
 
3163
    }
 
3164
    QCOMPARE(edit.minimumDateTime().timeSpec(), edit.timeSpec());
 
3165
    QCOMPARE(edit.maximumDateTime().timeSpec(), edit.timeSpec());
 
3166
    QCOMPARE(edit.dateTime().timeSpec(), edit.timeSpec());
 
3167
    if (useSetProperty) {
 
3168
        edit.setProperty("timeSpec", Qt::LocalTime);
 
3169
    } else {
 
3170
        edit.setTimeSpec(Qt::LocalTime);
 
3171
    }
 
3172
    const QDateTime dt = edit.dateTime();
 
3173
    QCOMPARE(edit.timeSpec(), Qt::LocalTime);
 
3174
    const QDateTime utc = dt.toUTC();
 
3175
    if (dt.time() != utc.time()) {
 
3176
        const QDateTime min(QDate(1999, 1, 1), QTime(1, 0, 0), Qt::LocalTime);
 
3177
        edit.setMinimumDateTime(min);
 
3178
        QCOMPARE(edit.minimumTime(), min.time());
 
3179
        if (useSetProperty) {
 
3180
            edit.setProperty("timeSpec", Qt::UTC);
 
3181
        } else {
 
3182
            edit.setTimeSpec(Qt::UTC);
 
3183
        }
 
3184
        QVERIFY(edit.minimumTime() != min.time());
 
3185
        QVERIFY(edit.minimumDateTime().timeSpec() != min.timeSpec());
 
3186
        QCOMPARE(edit.minimumDateTime().toTime_t(), min.toTime_t());
 
3187
    } else {
 
3188
        QSKIP("Not tested in the GMT timezone");
 
3189
    }
 
3190
}
 
3191
 
 
3192
void tst_QDateTimeEdit::timeSpecBug()
 
3193
{
 
3194
    testWidget->setTimeSpec(Qt::UTC);
 
3195
    testWidget->setDisplayFormat("hh:mm");
 
3196
    testWidget->setTime(QTime(2, 2));
 
3197
    const QString oldText = testWidget->text();
 
3198
    const QDateTime oldDateTime = testWidget->dateTime();
 
3199
    QTest::keyClick(testWidget, Qt::Key_Tab);
 
3200
    QCOMPARE(oldDateTime, testWidget->dateTime());
 
3201
    QCOMPARE(oldText, testWidget->text());
 
3202
}
 
3203
 
 
3204
void tst_QDateTimeEdit::timeSpecInit()
 
3205
{
 
3206
    QDateTime utc(QDate(2000, 1, 1), QTime(12, 0, 0), Qt::UTC);
 
3207
    QDateTimeEdit widget(utc);
 
3208
    QCOMPARE(widget.dateTime(), utc);
 
3209
}
 
3210
 
 
3211
void tst_QDateTimeEdit::cachedDayTest()
 
3212
{
 
3213
    testWidget->setDisplayFormat("MM/dd");
 
3214
    testWidget->setDate(QDate(2007, 1, 30));
 
3215
    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
 
3216
    //QTest::keyClick(testWidget->lineEdit(), Qt::Key_Up); // this doesn't work
 
3217
    //on Mac. Qt Test bug? ###
 
3218
    QTest::keyClick(testWidget, Qt::Key_Up);
 
3219
    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
 
3220
    QTest::keyClick(testWidget, Qt::Key_Up);
 
3221
    QCOMPARE(testWidget->date(), QDate(2007, 2, 28));
 
3222
    QTest::keyClick(testWidget, Qt::Key_Up);
 
3223
    QCOMPARE(testWidget->date(), QDate(2007, 3, 31));
 
3224
    QTest::keyClick(testWidget, Qt::Key_Down);
 
3225
    QCOMPARE(testWidget->date(), QDate(2007, 2, 28));
 
3226
    QTest::keyClick(testWidget, Qt::Key_Down);
 
3227
    QCOMPARE(testWidget->date(), QDate(2007, 1, 31));
 
3228
 
 
3229
    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
 
3230
    QTest::keyClick(testWidget, Qt::Key_Down);
 
3231
    QCOMPARE(testWidget->date(), QDate(2007, 1, 30));
 
3232
    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
 
3233
    QTest::keyClick(testWidget, Qt::Key_Up);
 
3234
    QCOMPARE(testWidget->date(), QDate(2007, 2, 28));
 
3235
    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
 
3236
    QTest::keyClick(testWidget, Qt::Key_Up);
 
3237
    QCOMPARE(testWidget->date(), QDate(2007, 3, 30));
 
3238
}
 
3239
 
 
3240
void tst_QDateTimeEdit::monthEdgeCase()
 
3241
{
 
3242
    EditorDateEdit edit;
 
3243
    edit.setLocale(QLocale("fr_FR"));
 
3244
    edit.setDisplayFormat("MMM d");
 
3245
    edit.setDate(QDate(2000, 1, 1));
 
3246
    QCOMPARE(edit.text(), QString("janv. 1"));
 
3247
    edit.lineEdit()->setCursorPosition(5);
 
3248
    QTest::keyClick(&edit, Qt::Key_Backspace);
 
3249
    QCOMPARE(edit.text(), QString("janv 1"));
 
3250
}
 
3251
 
 
3252
class RestoreLocaler
 
3253
{
 
3254
public:
 
3255
    RestoreLocaler()
 
3256
        : old(QLocale())
 
3257
    {}
 
3258
 
 
3259
    ~RestoreLocaler()
 
3260
    {
 
3261
        QLocale::setDefault(old);
 
3262
    }
 
3263
private:
 
3264
    const QLocale old;
 
3265
};
 
3266
 
 
3267
void tst_QDateTimeEdit::setLocale()
 
3268
{
 
3269
    RestoreLocaler r;
 
3270
    QLocale::setDefault(QLocale("en_US"));
 
3271
    {
 
3272
        EditorDateEdit edit;
 
3273
        edit.setDisplayFormat("MMMM d");
 
3274
        edit.setDate(QDate(2000, 1, 1));
 
3275
        QCOMPARE(edit.text(), QString("January 1"));
 
3276
    }
 
3277
    QLocale::setDefault(QLocale("no_NO"));
 
3278
    {
 
3279
        EditorDateEdit edit;
 
3280
        edit.setDisplayFormat("MMMM d");
 
3281
        edit.setDate(QDate(2000, 1, 1));
 
3282
        QCOMPARE(edit.text().toLower(), QString("januar 1"));
 
3283
        // I get Januar on Mac and januar on linux
 
3284
    }
 
3285
    QLocale::setDefault(QLocale("en_US"));
 
3286
    {
 
3287
        EditorDateEdit edit;
 
3288
        edit.setDisplayFormat("MMMM d");
 
3289
        edit.setDate(QDate(2000, 1, 1));
 
3290
        QCOMPARE(edit.text(), QString("January 1"));
 
3291
        edit.setLocale(QLocale("no_NO"));
 
3292
        QCOMPARE(edit.text().toLower(), QString("januar 1"));
 
3293
        edit.setLocale(QLocale("no_NO"));
 
3294
    }
 
3295
}
 
3296
 
 
3297
void tst_QDateTimeEdit::potentialYYValueBug()
 
3298
{
 
3299
    EditorDateEdit edit;
 
3300
    edit.setDisplayFormat("dd/MM/yy");
 
3301
    QCOMPARE(edit.minimumDate(), QDate(1752, 9, 14));
 
3302
    edit.setDate(edit.minimumDate());
 
3303
    edit.lineEdit()->setFocus();
 
3304
 
 
3305
#ifdef Q_OS_MAC
 
3306
    QTest::keyClick(&edit, Qt::Key_Right, Qt::ControlModifier);
 
3307
#else
 
3308
    QTest::keyClick(&edit, Qt::Key_End);
 
3309
#endif
 
3310
    QTest::keyClick(&edit, Qt::Key_Backspace);
 
3311
#ifdef Q_OS_MAC
 
3312
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
3313
#endif
 
3314
    QCOMPARE(edit.text(), QString("14/09/5"));
 
3315
}
 
3316
 
 
3317
void tst_QDateTimeEdit::textSectionAtEnd()
 
3318
{
 
3319
    EditorDateEdit edit;
 
3320
    edit.setDisplayFormat("MMMM");
 
3321
    edit.setDate(QDate(2000, 1, 1));
 
3322
    edit.lineEdit()->setFocus();
 
3323
#ifdef Q_OS_MAC
 
3324
    QTest::keyClick(&edit, Qt::Key_Right, Qt::ControlModifier);
 
3325
#else
 
3326
    QTest::keyClick(&edit, Qt::Key_End);
 
3327
#endif
 
3328
    QTest::keyClick(&edit, Qt::Key_Backspace);
 
3329
#ifdef Q_OS_MAC
 
3330
    QEXPECT_FAIL("", "QTBUG-23674", Abort);
 
3331
#endif
 
3332
    QCOMPARE(edit.text(), QString("Januar"));
 
3333
}
 
3334
 
 
3335
void tst_QDateTimeEdit::keypadAutoAdvance_data()
 
3336
{
 
3337
    QTest::addColumn<Qt::KeyboardModifiers>("modifiers");
 
3338
    QTest::newRow("None") << (Qt::KeyboardModifiers)Qt::NoModifier;
 
3339
    QTest::newRow("Keypad") << (Qt::KeyboardModifiers)Qt::KeypadModifier;
 
3340
    // QTBUG-7842: Using KeyPad with shift (numlock off)
 
3341
    QTest::newRow("Keypad+Shift") << (Qt::KeyboardModifiers)(Qt::KeypadModifier|Qt::ShiftModifier);
 
3342
}
 
3343
 
 
3344
void tst_QDateTimeEdit::keypadAutoAdvance()
 
3345
{
 
3346
    QFETCH(Qt::KeyboardModifiers, modifiers);
 
3347
 
 
3348
    EditorDateEdit edit;
 
3349
    edit.setDate(QDate(2000, 2, 1));
 
3350
    edit.setDisplayFormat("dd/MM");
 
3351
#ifdef Q_OS_MAC
 
3352
    QTest::keyClick(&edit, Qt::Key_Left, Qt::ControlModifier);
 
3353
#else
 
3354
    QTest::keyClick(&edit, Qt::Key_Home);
 
3355
#endif
 
3356
    QTest::keyClick(&edit, Qt::Key_Return);
 
3357
    QCOMPARE(edit.lineEdit()->selectedText(), QString("01"));
 
3358
    QTest::keyClick(&edit, Qt::Key_1, modifiers);
 
3359
    QTest::keyClick(&edit, Qt::Key_2, modifiers);
 
3360
    QCOMPARE(edit.lineEdit()->selectedText(), QString("02"));
 
3361
}
 
3362
 
 
3363
void tst_QDateTimeEdit::task196924()
 
3364
{
 
3365
    EditorDateEdit edit;
 
3366
    edit.setDisplayFormat("dd/M/yyyy");
 
3367
    edit.setDate(QDate(2345, 6, 17));
 
3368
    QCOMPARE(edit.text(), QString("17/6/2345"));
 
3369
    QTest::keyClick(&edit, Qt::Key_Tab);
 
3370
    QCOMPARE(edit.lineEdit()->selectedText(), QString("6"));
 
3371
    QTest::keyClick(&edit, Qt::Key_3);
 
3372
    QCOMPARE(edit.lineEdit()->selectedText(), QString("2345"));
 
3373
    QCOMPARE(edit.text(), QString("17/3/2345"));
 
3374
 
 
3375
    edit.setDisplayFormat("dd/MM/yyyy");
 
3376
    edit.setDate(QDate(2345, 6, 17));
 
3377
    edit.lineEdit()->setCursorPosition(0);
 
3378
    QCOMPARE(edit.text(), QString("17/06/2345"));
 
3379
    QTest::keyClick(&edit, Qt::Key_Tab);
 
3380
    QCOMPARE(edit.lineEdit()->selectedText(), QString("06"));
 
3381
    QTest::keyClick(&edit, Qt::Key_3);
 
3382
    QCOMPARE(edit.lineEdit()->selectedText(), QString("2345"));
 
3383
    QCOMPARE(edit.text(), QString("17/03/2345"));
 
3384
}
 
3385
 
 
3386
void tst_QDateTimeEdit::focusNextPrevChild()
 
3387
{
 
3388
    EditorDateEdit edit;
 
3389
    edit.setDisplayFormat("dd/MM/yyyy");
 
3390
 
 
3391
    edit.show();
 
3392
    edit.setFocus();
 
3393
    edit.setCurrentSection(QDateTimeEdit::DaySection);
 
3394
 
 
3395
    QCOMPARE(edit.currentSection(), QDateTimeEdit::DaySection);
 
3396
    edit.focusNextPrevChild(true);
 
3397
    QCOMPARE(edit.currentSection(), QDateTimeEdit::MonthSection);
 
3398
}
 
3399
 
 
3400
void tst_QDateTimeEdit::taskQTBUG_12384_timeSpecShowTimeOnly()
 
3401
{
 
3402
    QDateTime time = QDateTime::fromString("20100723 04:02:40", "yyyyMMdd hh:mm:ss");
 
3403
    time.setTimeSpec(Qt::UTC);
 
3404
 
 
3405
    EditorDateEdit edit;
 
3406
    edit.setDisplayFormat("hh:mm:ss");
 
3407
    edit.setTimeSpec(Qt::UTC);
 
3408
    edit.setDateTime(time);
 
3409
 
 
3410
    QCOMPARE(edit.minimumTime(), QTime(0, 0, 0, 0));
 
3411
    QCOMPARE(edit.maximumTime(), QTime(23, 59, 59, 999));
 
3412
    QCOMPARE(edit.time(), time.time());
 
3413
}
 
3414
 
 
3415
void tst_QDateTimeEdit::deleteCalendarWidget()
 
3416
{
 
3417
    {
 
3418
        // setup
 
3419
        QCalendarWidget *cw = 0;
 
3420
        QDateEdit edit;
 
3421
        QVERIFY(!edit.calendarWidget());
 
3422
        edit.setCalendarPopup(true);
 
3423
        QVERIFY(edit.calendarWidget());
 
3424
        edit.calendarWidget()->setObjectName("cw1");;
 
3425
 
 
3426
        // delete
 
3427
        cw = edit.calendarWidget();
 
3428
        delete cw;
 
3429
 
 
3430
        // it should create a new widget
 
3431
        QVERIFY(edit.calendarWidget());
 
3432
        QVERIFY(edit.calendarWidget()->objectName() != QLatin1String("cw1"));
 
3433
    }
 
3434
}
 
3435
 
 
3436
#ifdef QT_BUILD_INTERNAL
 
3437
 
 
3438
typedef QPair<Qt::Key, Qt::KeyboardModifier> KeyPair;
 
3439
typedef QList<KeyPair> KeyPairList;
 
3440
 
 
3441
Q_DECLARE_METATYPE(KeyPair)
 
3442
 
 
3443
static inline KeyPair key(Qt::Key key, Qt::KeyboardModifier modifier = Qt::NoModifier) {
 
3444
    return KeyPair(key, modifier);
 
3445
}
 
3446
 
 
3447
/*
 
3448
When a QDateEdit has its display format set to 'yyyy/MM/dd', its day
 
3449
set to 31 and its month set to 2, it will display 291 as the day until
 
3450
the cursor is moved or the focus changed. This is because
 
3451
QDateTimeParser::parse calls sectionSize() for the day section, which
 
3452
returns 1 when it should return 2.
 
3453
 
 
3454
This test verifies that QDateTimeEditPrivate has the correct text,
 
3455
which is the text that is displayed until the cursor is moved or the
 
3456
focus changed.
 
3457
*/
 
3458
 
 
3459
void tst_QDateTimeEdit::dateEditCorrectSectionSize_data()
 
3460
{
 
3461
    QTest::addColumn<QLocale>("locale");
 
3462
    QTest::addColumn<QDate>("defaultDate");
 
3463
    QTest::addColumn<QString>("displayFormat");
 
3464
    QTest::addColumn<KeyPairList>("keyPresses");
 
3465
    QTest::addColumn<QString>("expectedDisplayString");
 
3466
 
 
3467
    const QDate defaultDate(2000, 1, 1);
 
3468
    const QLocale defaultLocale(QLocale::English, QLocale::Australia);
 
3469
 
 
3470
    KeyPairList thirtyUpKeypresses;
 
3471
    thirtyUpKeypresses.reserve(30);
 
3472
    for (int i = 0; i < 30; ++i) {
 
3473
        thirtyUpKeypresses << key(Qt::Key_Up);
 
3474
    }
 
3475
 
 
3476
    // Make day the current section, set day to 31st (invalid for february),
 
3477
    // move to month field, set month to february (2).
 
3478
    KeyPairList threeDigitDayIssueKeypresses;
 
3479
    threeDigitDayIssueKeypresses << key(Qt::Key_Tab) << key(Qt::Key_Tab)
 
3480
        << key(Qt::Key_3) << key(Qt::Key_1) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_2);
 
3481
 
 
3482
    // Same as above, except day-year-month format.
 
3483
    KeyPairList threeDigitDayIssueKeypresses_DayYearMonth;
 
3484
    threeDigitDayIssueKeypresses_DayYearMonth << key(Qt::Key_3) << key(Qt::Key_1) << key(Qt::Key_Tab)
 
3485
        << key(Qt::Key_2);
 
3486
 
 
3487
    // Same as threeDigitDayIssueKeypresses, except doesn't require the day to be corrected.
 
3488
    KeyPairList threeDigitDayIssueKeypresses_Nofixday;
 
3489
    threeDigitDayIssueKeypresses_Nofixday << key(Qt::Key_Tab) << key(Qt::Key_Tab)
 
3490
        << key(Qt::Key_2) << key(Qt::Key_8) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_2);
 
3491
 
 
3492
    // Set day to 31st (invalid for february), set month to february (2).
 
3493
    KeyPairList reverseThreeDigitDayIssueKeypresses;
 
3494
    reverseThreeDigitDayIssueKeypresses
 
3495
        << key(Qt::Key_3) << key(Qt::Key_1) << key(Qt::Key_2);
 
3496
 
 
3497
    // Make day the current section, set day to 31st, move to month field, set month to november (11).
 
3498
    KeyPairList threeDigitDayIssueKeypresses_TwoDigitMonth;
 
3499
    threeDigitDayIssueKeypresses_TwoDigitMonth << key(Qt::Key_Tab) << key(Qt::Key_Tab) << key(Qt::Key_3)
 
3500
        << key(Qt::Key_1) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_1) << key(Qt::Key_1);
 
3501
 
 
3502
    // Make day the current section, set day to 3rd, move to month field, set month to february (2).
 
3503
    KeyPairList threeDigitDayIssueKeypresses_OneDigitDay;
 
3504
    threeDigitDayIssueKeypresses_OneDigitDay << key(Qt::Key_Tab) << key(Qt::Key_Tab)
 
3505
        << key(Qt::Key_3) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_2);
 
3506
 
 
3507
    // Make day the current section, set day to 31st (invalid for february), move to month field,
 
3508
    // set month to february (2).
 
3509
    KeyPairList threeDigitDayIssueKeypresses_ShortMonthName;
 
3510
    threeDigitDayIssueKeypresses_ShortMonthName << key(Qt::Key_Tab) << key(Qt::Key_Tab)
 
3511
        << key(Qt::Key_3) << key(Qt::Key_1) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_Up);
 
3512
 
 
3513
    // Make day the current section, set day to 31st (Monday), move to month field, set month to february (2).
 
3514
    // Will probably never see this display format in a QDateTimeEdit, but it's good to test it anyway.
 
3515
    KeyPairList threeDigitDayIssueKeypresses_DayName;
 
3516
    threeDigitDayIssueKeypresses_DayName << key(Qt::Key_Tab) << key(Qt::Key_Tab) << thirtyUpKeypresses
 
3517
        << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_2);
 
3518
 
 
3519
    KeyPairList threeDigitDayIssueKeypresses_DayName_DayYearMonth;
 
3520
    threeDigitDayIssueKeypresses_DayName_DayYearMonth << thirtyUpKeypresses << key(Qt::Key_Tab)
 
3521
        << key(Qt::Key_Tab) << key(Qt::Key_2);
 
3522
 
 
3523
    KeyPairList threeDigitDayIssueKeypresses_DayName_YearDayMonth;
 
3524
    threeDigitDayIssueKeypresses_DayName_YearDayMonth << key(Qt::Key_Tab) << thirtyUpKeypresses
 
3525
        << key(Qt::Key_Tab) << key(Qt::Key_2);
 
3526
 
 
3527
    KeyPairList threeDigitDayIssueKeypresses_DayName_DayMonthYear;
 
3528
    threeDigitDayIssueKeypresses_DayName_DayMonthYear << thirtyUpKeypresses << key(Qt::Key_Tab)
 
3529
        << key(Qt::Key_2);
 
3530
 
 
3531
    KeyPairList threeDigitDayIssueKeypresses_DayName_MonthDayYear;
 
3532
    threeDigitDayIssueKeypresses_DayName_MonthDayYear << key(Qt::Key_Tab) << thirtyUpKeypresses
 
3533
        << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_2);
 
3534
 
 
3535
    // Make day the current section, set day to 31st (invalid for february), move to month field,
 
3536
    // set month to february (2).
 
3537
    KeyPairList threeDigitDayIssueKeypresses_YearDayMonth;
 
3538
    threeDigitDayIssueKeypresses_YearDayMonth << key(Qt::Key_Tab) << key(Qt::Key_3) << key(Qt::Key_1)
 
3539
        << key(Qt::Key_Tab) << key(Qt::Key_2);
 
3540
 
 
3541
    // Make day the current section, set day to 31st, move to month field, set month to february (2).
 
3542
    KeyPairList threeDigitDayIssueKeypresses_MonthDayYear;
 
3543
    threeDigitDayIssueKeypresses_MonthDayYear << key(Qt::Key_Tab) << key(Qt::Key_3) << key(Qt::Key_1)
 
3544
        << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_2);
 
3545
 
 
3546
    // Same as above, except month-year-day format.
 
3547
    KeyPairList threeDigitDayIssueKeypresses_MonthYearDay;
 
3548
    threeDigitDayIssueKeypresses_MonthYearDay << key(Qt::Key_Tab) << key(Qt::Key_Tab) << key(Qt::Key_3)
 
3549
        << key(Qt::Key_1) << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_Tab, Qt::ShiftModifier)
 
3550
        << key(Qt::Key_2);
 
3551
 
 
3552
    // Same as above, except short month name.
 
3553
    KeyPairList threeDigitDayIssueKeypresses_ShortMonthName_MonthYearDay;
 
3554
    threeDigitDayIssueKeypresses_ShortMonthName_MonthYearDay << key(Qt::Key_Tab) << key(Qt::Key_Tab)
 
3555
        << key(Qt::Key_3) << key(Qt::Key_1) << key(Qt::Key_Tab, Qt::ShiftModifier)
 
3556
        << key(Qt::Key_Tab, Qt::ShiftModifier) << key(Qt::Key_Up);
 
3557
 
 
3558
    KeyPairList shortAndLongNameIssueKeypresses;
 
3559
    shortAndLongNameIssueKeypresses << key(Qt::Key_Tab) << key(Qt::Key_3) << key(Qt::Key_1) << key(Qt::Key_Up);
 
3560
 
 
3561
    QTest::newRow("no fixday, leap, yy/M/dddd") << defaultLocale << defaultDate << QString::fromLatin1("yy/M/dddd")
 
3562
        << threeDigitDayIssueKeypresses_DayName << QString::fromLatin1("00/2/Tuesday");
 
3563
 
 
3564
    QTest::newRow("no fixday, leap, yy/M/ddd") << defaultLocale << defaultDate << QString::fromLatin1("yy/M/ddd")
 
3565
        << threeDigitDayIssueKeypresses_DayName << QString::fromLatin1("00/2/Tue.");
 
3566
 
 
3567
    QTest::newRow("no fixday, leap, yy/MM/dddd") << defaultLocale << defaultDate << QString::fromLatin1("yy/MM/dddd")
 
3568
        << threeDigitDayIssueKeypresses_DayName << QString::fromLatin1("00/02/Tuesday");
 
3569
 
 
3570
    QTest::newRow("fixday, leap, yy/MM/dd") << defaultLocale << defaultDate << QString::fromLatin1("yy/MM/dd")
 
3571
        << threeDigitDayIssueKeypresses << QString::fromLatin1("00/02/29");
 
3572
 
 
3573
    QTest::newRow("fixday, leap, yy/MM/d") << defaultLocale << defaultDate << QString::fromLatin1("yy/MM/d")
 
3574
        << threeDigitDayIssueKeypresses << QString::fromLatin1("00/02/29");
 
3575
 
 
3576
    QTest::newRow("fixday, leap, yyyy/M/d") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/M/d")
 
3577
        << threeDigitDayIssueKeypresses << QString::fromLatin1("2000/2/29");
 
3578
 
 
3579
    QTest::newRow("no fixday, yyyy/M/d") << defaultLocale << defaultDate.addYears(1) << QString::fromLatin1("yyyy/M/d")
 
3580
        << threeDigitDayIssueKeypresses_Nofixday << QString::fromLatin1("2001/2/28");
 
3581
 
 
3582
    QTest::newRow("fixday, leap, 2-digit month, yyyy/M/dd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/M/dd")
 
3583
        << threeDigitDayIssueKeypresses_TwoDigitMonth << QString::fromLatin1("2000/11/30");
 
3584
 
 
3585
    QTest::newRow("no fixday, leap, 1-digit day, yyyy/M/dd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/M/dd")
 
3586
        << threeDigitDayIssueKeypresses_OneDigitDay << QString::fromLatin1("2000/2/03");
 
3587
 
 
3588
    QTest::newRow("fixday, leap, yyyy/MM/dd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/MM/dd")
 
3589
        << threeDigitDayIssueKeypresses << QString::fromLatin1("2000/02/29");
 
3590
 
 
3591
    QTest::newRow("no fixday, yyyy/MM/dd") << defaultLocale << defaultDate.addYears(1) << QString::fromLatin1("yyyy/MM/dd")
 
3592
        << threeDigitDayIssueKeypresses_Nofixday << QString::fromLatin1("2001/02/28");
 
3593
 
 
3594
    QTest::newRow("fixday, leap, 2-digit month, yyyy/MM/dd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/MM/dd")
 
3595
        << threeDigitDayIssueKeypresses_TwoDigitMonth << QString::fromLatin1("2000/11/30");
 
3596
 
 
3597
    QTest::newRow("no fixday, leap, yyyy/M/dddd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/M/dddd")
 
3598
        << threeDigitDayIssueKeypresses_DayName << QString::fromLatin1("2000/2/Tuesday");
 
3599
 
 
3600
    QTest::newRow("no fixday, leap, yyyy/MM/dddd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/MM/dddd")
 
3601
        << threeDigitDayIssueKeypresses_DayName << QString::fromLatin1("2000/02/Tuesday");
 
3602
 
 
3603
    QTest::newRow("fixday, leap, yyyy/dd/MM") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/dd/MM")
 
3604
        << threeDigitDayIssueKeypresses_YearDayMonth << QString::fromLatin1("2000/29/02");
 
3605
 
 
3606
    QTest::newRow("fixday, leap, yyyy/dd/M") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/dd/M")
 
3607
        << threeDigitDayIssueKeypresses_YearDayMonth << QString::fromLatin1("2000/29/2");
 
3608
 
 
3609
    QTest::newRow("fixday, leap, yyyy/d/M") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/d/M")
 
3610
        << threeDigitDayIssueKeypresses_YearDayMonth << QString::fromLatin1("2000/29/2");
 
3611
 
 
3612
    QTest::newRow("fixday, leap, yyyy/MMM/dd") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/MMM/dd")
 
3613
        << threeDigitDayIssueKeypresses_ShortMonthName << QString::fromLatin1("2000/Feb./29");
 
3614
 
 
3615
    QTest::newRow("fixday, leap, yyyy/MMM/d") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/MMM/d")
 
3616
        << threeDigitDayIssueKeypresses_ShortMonthName << QString::fromLatin1("2000/Feb./29");
 
3617
 
 
3618
    QTest::newRow("fixday, leap, yy/MMM/dd") << defaultLocale << defaultDate << QString::fromLatin1("yy/MMM/dd")
 
3619
        << threeDigitDayIssueKeypresses_ShortMonthName << QString::fromLatin1("00/Feb./29");
 
3620
 
 
3621
    QTest::newRow("fixday, leap, yyyy/dddd/M") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/dddd/M")
 
3622
        << threeDigitDayIssueKeypresses_DayName_YearDayMonth << QString::fromLatin1("2000/Tuesday/2");
 
3623
 
 
3624
    QTest::newRow("fixday, leap, yyyy/dddd/MM") << defaultLocale << defaultDate << QString::fromLatin1("yyyy/dddd/MM")
 
3625
        << threeDigitDayIssueKeypresses_DayName_YearDayMonth << QString::fromLatin1("2000/Tuesday/02");
 
3626
 
 
3627
    QTest::newRow("fixday, leap, d/M/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("d/M/yyyy")
 
3628
        << reverseThreeDigitDayIssueKeypresses << QString::fromLatin1("29/2/2000");
 
3629
 
 
3630
    QTest::newRow("fixday, leap, dd/MM/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("dd/MM/yyyy")
 
3631
        << reverseThreeDigitDayIssueKeypresses << QString::fromLatin1("29/02/2000");
 
3632
 
 
3633
    QTest::newRow("fixday, dd/MM/yyyy") << defaultLocale << defaultDate.addYears(1) << QString::fromLatin1("dd/MM/yyyy")
 
3634
        << reverseThreeDigitDayIssueKeypresses << QString::fromLatin1("28/02/2001");
 
3635
 
 
3636
    QTest::newRow("fixday, leap, dddd/MM/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("dddd/MM/yyyy")
 
3637
        << threeDigitDayIssueKeypresses_DayName_DayMonthYear << QString::fromLatin1("Tuesday/02/2000");
 
3638
 
 
3639
    QTest::newRow("fixday, leap, d/yy/M") << defaultLocale << defaultDate << QString::fromLatin1("d/yy/M")
 
3640
        << threeDigitDayIssueKeypresses_DayYearMonth << QString::fromLatin1("29/00/2");
 
3641
 
 
3642
    QTest::newRow("fixday, leap, d/yyyy/M") << defaultLocale << defaultDate << QString::fromLatin1("d/yyyy/M")
 
3643
        << threeDigitDayIssueKeypresses_DayYearMonth << QString::fromLatin1("29/2000/2");
 
3644
 
 
3645
    QTest::newRow("fixday, leap, d/yyyy/MM") << defaultLocale << defaultDate << QString::fromLatin1("d/yyyy/MM")
 
3646
        << threeDigitDayIssueKeypresses_DayYearMonth << QString::fromLatin1("29/2000/02");
 
3647
 
 
3648
    QTest::newRow("fixday, leap, dd/yy/MM") << defaultLocale << defaultDate << QString::fromLatin1("dd/yy/MM")
 
3649
        << threeDigitDayIssueKeypresses_DayYearMonth << QString::fromLatin1("29/00/02");
 
3650
 
 
3651
    QTest::newRow("fixday, leap, dd/yyyy/M") << defaultLocale << defaultDate << QString::fromLatin1("dd/yyyy/M")
 
3652
        << threeDigitDayIssueKeypresses_DayYearMonth << QString::fromLatin1("29/2000/2");
 
3653
 
 
3654
    QTest::newRow("fixday, leap, dd/yyyy/MM") << defaultLocale << defaultDate << QString::fromLatin1("dd/yyyy/MM")
 
3655
        << threeDigitDayIssueKeypresses_DayYearMonth << QString::fromLatin1("29/2000/02");
 
3656
 
 
3657
    QTest::newRow("fixday, leap, dddd/yy/M") << defaultLocale << defaultDate << QString::fromLatin1("dddd/yy/M")
 
3658
        << threeDigitDayIssueKeypresses_DayName_DayYearMonth << QString::fromLatin1("Tuesday/00/2");
 
3659
 
 
3660
    QTest::newRow("fixday, leap, dddd/yy/MM") << defaultLocale << defaultDate << QString::fromLatin1("dddd/yy/MM")
 
3661
        << threeDigitDayIssueKeypresses_DayName_DayYearMonth << QString::fromLatin1("Tuesday/00/02");
 
3662
 
 
3663
    QTest::newRow("fixday, leap, M/d/yy") << defaultLocale << defaultDate << QString::fromLatin1("M/d/yy")
 
3664
        << threeDigitDayIssueKeypresses_MonthDayYear << QString::fromLatin1("2/29/00");
 
3665
 
 
3666
    QTest::newRow("fixday, leap, M/d/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("M/d/yyyy")
 
3667
        << threeDigitDayIssueKeypresses_MonthDayYear << QString::fromLatin1("2/29/2000");
 
3668
 
 
3669
    QTest::newRow("fixday, leap, M/dd/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("M/dd/yyyy")
 
3670
        << threeDigitDayIssueKeypresses_MonthDayYear << QString::fromLatin1("2/29/2000");
 
3671
 
 
3672
    QTest::newRow("fixday, leap, M/dddd/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("M/dddd/yyyy")
 
3673
        << threeDigitDayIssueKeypresses_DayName_MonthDayYear << QString::fromLatin1("2/Tuesday/2000");
 
3674
 
 
3675
    QTest::newRow("fixday, leap, MM/dd/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("MM/dd/yyyy")
 
3676
        << threeDigitDayIssueKeypresses_MonthDayYear << QString::fromLatin1("02/29/2000");
 
3677
 
 
3678
    QTest::newRow("fixday, leap, MM/dddd/yyyy") << defaultLocale << defaultDate << QString::fromLatin1("MM/dddd/yyyy")
 
3679
        << threeDigitDayIssueKeypresses_DayName_MonthDayYear << QString::fromLatin1("02/Tuesday/2000");
 
3680
 
 
3681
    QTest::newRow("fixday, leap, M/yyyy/dd") << defaultLocale << defaultDate << QString::fromLatin1("M/yyyy/dd")
 
3682
        << threeDigitDayIssueKeypresses_MonthYearDay << QString::fromLatin1("2/2000/29");
 
3683
 
 
3684
    QTest::newRow("fixday, leap, M/yy/dd") << defaultLocale << defaultDate << QString::fromLatin1("M/yy/dd")
 
3685
        << threeDigitDayIssueKeypresses_MonthYearDay << QString::fromLatin1("2/00/29");
 
3686
 
 
3687
    QTest::newRow("fixday, leap, M/yy/d") << defaultLocale << defaultDate << QString::fromLatin1("M/yy/d")
 
3688
        << threeDigitDayIssueKeypresses_MonthYearDay << QString::fromLatin1("2/00/29");
 
3689
 
 
3690
    QTest::newRow("fixday, leap, MM/yyyy/dd") << defaultLocale << defaultDate << QString::fromLatin1("MM/yyyy/dd")
 
3691
        << threeDigitDayIssueKeypresses_MonthYearDay << QString::fromLatin1("02/2000/29");
 
3692
 
 
3693
    QTest::newRow("fixday, leap, MMM/yy/d") << defaultLocale << defaultDate << QString::fromLatin1("MMM/yy/d")
 
3694
        << threeDigitDayIssueKeypresses_ShortMonthName_MonthYearDay << QString::fromLatin1("Feb./00/29");
 
3695
 
 
3696
    QTest::newRow("fixday, leap, MMM/yyyy/d") << defaultLocale << defaultDate << QString::fromLatin1("MMM/yyyy/d")
 
3697
        << threeDigitDayIssueKeypresses_ShortMonthName_MonthYearDay << QString::fromLatin1("Feb./2000/29");
 
3698
 
 
3699
    QTest::newRow("fixday, MMM/yyyy/d") << defaultLocale << defaultDate.addYears(1) << QString::fromLatin1("MMM/yyyy/d")
 
3700
        << threeDigitDayIssueKeypresses_ShortMonthName_MonthYearDay << QString::fromLatin1("Feb./2001/28");
 
3701
 
 
3702
    QTest::newRow("fixday, leap, MMM/yyyy/dd") << defaultLocale << defaultDate << QString::fromLatin1("MMM/yyyy/dd")
 
3703
        << threeDigitDayIssueKeypresses_ShortMonthName_MonthYearDay << QString::fromLatin1("Feb./2000/29");
 
3704
 
 
3705
    QTest::newRow("fixday, leap, dddd, dd. MMMM yyyy") << defaultLocale
 
3706
        << defaultDate << QString::fromLatin1("dddd, dd. MMMM yyyy")
 
3707
        << shortAndLongNameIssueKeypresses << QString::fromLatin1("Tuesday, 29. February 2000");
 
3708
 
 
3709
    QTest::newRow("fixday, leap, german, dddd, dd. MMMM yyyy") << QLocale(QLocale::German, QLocale::Germany)
 
3710
        << defaultDate << QString::fromLatin1("dddd, dd. MMMM yyyy")
 
3711
        << shortAndLongNameIssueKeypresses << QString::fromLatin1("Dienstag, 29. Februar 2000");
 
3712
}
 
3713
 
 
3714
void tst_QDateTimeEdit::dateEditCorrectSectionSize()
 
3715
{
 
3716
    QFETCH(QLocale, locale);
 
3717
    QFETCH(QDate, defaultDate);
 
3718
    QFETCH(QString, displayFormat);
 
3719
    QFETCH(KeyPairList, keyPresses);
 
3720
    QFETCH(QString, expectedDisplayString);
 
3721
 
 
3722
    QDateEdit edit;
 
3723
    edit.setLocale(locale);
 
3724
    edit.setDate(defaultDate);
 
3725
    edit.setDisplayFormat(displayFormat);
 
3726
    edit.show();
 
3727
    edit.setFocus();
 
3728
    // For some reason, we need to set the selected section for the dd/MM/yyyy tests,
 
3729
    // otherwise the 3 is inserted at the front of 01/01/2000 (301/01/2000), instead of the
 
3730
    // selected text being replaced. This is not an issue for the yyyy/MM/dd format though...
 
3731
    edit.setSelectedSection(edit.sectionAt(0));
 
3732
 
 
3733
    foreach (const KeyPair &keyPair, keyPresses)
 
3734
        QTest::keyClick(&edit, keyPair.first, keyPair.second);
 
3735
 
 
3736
    QDateTimeEditPrivate* edit_d_ptr(static_cast<QDateTimeEditPrivate*>(qt_widget_private(&edit)));
 
3737
    QCOMPARE(edit_d_ptr->text, expectedDisplayString);
 
3738
}
 
3739
#endif
 
3740
 
 
3741
QTEST_MAIN(tst_QDateTimeEdit)
 
3742
#include "tst_qdatetimeedit.moc"