Long live Qt 4.5!

3 files changed, 3437 insertions, 0 deletions

diff --git a/tests/auto/qdatetimeedit/.gitignore b/tests/auto/qdatetimeedit/.gitignore
new file mode 100644
index 0000000..a68e326
--- /dev/null
+++ b/tests/auto/qdatetimeedit/.gitignore
@@ -0,0 +1 @@
+tst_qdatetimeedit
diff --git a/tests/auto/qdatetimeedit/qdatetimeedit.pro b/tests/auto/qdatetimeedit/qdatetimeedit.pro
new file mode 100644
index 0000000..19e92d0
--- /dev/null
+++ b/tests/auto/qdatetimeedit/qdatetimeedit.pro
@@ -0,0 +1,7 @@
+load(qttest_p4)
+SOURCES  += tst_qdatetimeedit.cpp
+
+wincewm50smart-msvc2005: DEFINES += WINCE_NO_MODIFIER_KEYS
+
+
+
diff --git a/tests/auto/qdatetimeedit/tst_qdatetimeedit.cpp b/tests/auto/qdatetimeedit/tst_qdatetimeedit.cpp
new file mode 100644
index 0000000..b975405
--- /dev/null
+++ b/tests/auto/qdatetimeedit/tst_qdatetimeedit.cpp
@@ -0,0 +1,3429 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <qapplication.h>
+#include <qgroupbox.h>
+#include <qlineedit.h>
+#include <qwindowsstyle.h>
+
+
+
+#include <qdatetimeedit.h>
+#include <qlocale.h>
+#include <qlayout.h>
+#include <qeventloop.h>
+#include <qstyle.h>
+#include <qstyle.h>
+#include <QStyleOptionSpinBox>
+#include <QDate>
+#include <QDateTime>
+#include <QTime>
+#include <QList>
+#include <QDateTimeEdit>
+#include <QCalendarWidget>
+#include <QWidget>
+#include <QLineEdit>
+#include <QObject>
+#include <QLocale>
+#include <QString>
+#include <QVariantList>
+#include <QVariant>
+#include <QApplication>
+#include <QPoint>
+#include <QVBoxLayout>
+#include <QRect>
+#include <QCursor>
+#include <QEventLoop>
+#include <QStyle>
+#include <QStyleOptionComboBox>
+#include <QTimeEdit>
+#include <QMetaType>
+#include <QDebug>
+#include <QWheelEvent>
+#include <QTest>
+#include <QSignalSpy>
+#include <QTestEventList>
+#include <QDateEdit>
+
+#ifdef Q_OS_WIN
+# include <windows.h>
+# undef min
+# undef max
+#endif
+
+
+Q_DECLARE_METATYPE(QDate);
+Q_DECLARE_METATYPE(Qt::Key);
+Q_DECLARE_METATYPE(Qt::KeyboardModifiers);
+Q_DECLARE_METATYPE(Qt::KeyboardModifier);
+Q_DECLARE_METATYPE(QDateTime);
+Q_DECLARE_METATYPE(QTime);
+Q_DECLARE_METATYPE(QList<int>);
+
+#if defined(Q_OS_WINCE)
+bool qt_wince_is_platform(const QString &platformString) {
+    TCHAR tszPlatform[64];
+    if (SystemParametersInfo(SPI_GETPLATFORMTYPE,
+                             sizeof(tszPlatform)/sizeof(*tszPlatform),tszPlatform,0))
+      if (0 == _tcsicmp(reinterpret_cast<const wchar_t *> (platformString.utf16()), tszPlatform))
+            return true;
+    return false;
+}
+bool qt_wince_is_pocket_pc() {
+    return qt_wince_is_platform(QString::fromLatin1("PocketPC"));
+}
+bool qt_wince_is_smartphone() {
+       return qt_wince_is_platform(QString::fromLatin1("Smartphone"));
+}
+bool qt_wince_is_mobile() {
+     return (qt_wince_is_smartphone() || qt_wince_is_pocket_pc());
+}
+#endif
+
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class EditorDateEdit : public QDateTimeEdit
+{
+    Q_OBJECT
+public:
+    EditorDateEdit(QWidget *parent = 0) : QDateTimeEdit(parent) {}
+    QLineEdit *lineEdit() { return QDateTimeEdit::lineEdit(); }
+    friend class tst_QDateTimeEdit;
+};
+
+class tst_QDateTimeEdit : public QObject
+{
+    Q_OBJECT
+public:
+    tst_QDateTimeEdit();
+    virtual ~tst_QDateTimeEdit();
+public slots:
+    void initTestCase();
+    void init();
+    void cleanup();
+    void cleanupTestCase();
+private slots:
+    void cachedDayTest();
+    void getSetCheck();
+    void constructor_qwidget();
+    void constructor_qdatetime_data();
+    void constructor_qdatetime();
+    void constructor_qdate_data();
+    void constructor_qdate();
+    void constructor_qtime_data();
+    void constructor_qtime();
+
+    void sectionText_data();
+    void sectionText();
+    void dateTimeSignalChecking_data();
+    void dateTimeSignalChecking();
+    void mousePress();
+    void stepHourAMPM_data();
+
+    void stepHourAMPM();
+    void displayedSections_data();
+    void displayedSections();
+    void currentSection_data();
+    void currentSection();
+
+    void setCurrentSection();
+    void setCurrentSection_data();
+
+    void minimumDate_data();
+    void minimumDate();
+    void maximumDate_data();
+    void maximumDate();
+    void clearMinimumDate_data();
+    void clearMinimumDate();
+    void clearMaximumDate_data();
+    void clearMaximumDate();
+
+    void minimumDateTime_data();
+    void minimumDateTime();
+    void maximumDateTime_data();
+    void maximumDateTime();
+
+    void clearMinimumDateTime_data();
+    void clearMinimumDateTime();
+    void clearMaximumDateTime_data();
+    void clearMaximumDateTime();
+
+    void displayFormat_data();
+    void displayFormat();
+
+    void specialValueText();
+    void setRange_data();
+    void setRange();
+
+    void selectAndScrollWithKeys();
+    void backspaceKey();
+    void deleteKey();
+    void tabKeyNavigation();
+    void tabKeyNavigationWithPrefix();
+    void tabKeyNavigationWithSuffix();
+    void enterKey();
+
+    void readOnly();
+
+    void wrappingDate_data();
+    void wrappingDate();
+
+    void dateSignalChecking_data();
+    void dateSignalChecking();
+
+    void wrappingTime_data();
+    void wrappingTime();
+
+    void userKeyPress_Time_data();
+    void userKeyPress_Time();
+
+    void timeSignalChecking_data();
+    void timeSignalChecking();
+
+    void weirdCase();
+    void newCase();
+    void newCase2();
+    void newCase3();
+    void newCase4();
+    void newCase5();
+    void newCase6();
+
+    void task98554();
+    void task149097();
+
+    void cursorPos();
+    void calendarPopup();
+
+    void hour12Test();
+    void yyTest();
+    void task108572();
+
+    void task148725();
+    void task148522();
+
+    void setSelectedSection();
+    void reverseTest();
+
+    void ddMMMMyyyy();
+    void wheelEvent();
+
+    void specialValueCornerCase();
+    void cursorPositionOnInit();
+
+    void task118867();
+
+    void nextPrevSection_data();
+    void nextPrevSection();
+
+    void dateEditTimeEditFormats();
+    void timeSpec_data();
+    void timeSpec();
+    void timeSpecBug();
+
+    void monthEdgeCase();
+    void setLocale();
+
+    void potentialYYValueBug();
+    void textSectionAtEnd();
+
+    void keypadAutoAdvance_data();
+    void keypadAutoAdvance();
+
+    void task196924();
+    void focusNextPrevChild();
+private:
+    EditorDateEdit* testWidget;
+    QWidget *testFocusWidget;
+};
+
+typedef QList<QTime> TimeList;
+typedef QList<Qt::Key> KeyList;
+
+Q_DECLARE_METATYPE(TimeList)
+Q_DECLARE_METATYPE(KeyList)
+
+// Testing get/set functions
+void tst_QDateTimeEdit::getSetCheck()
+{
+    QDateTimeEdit obj1;
+    obj1.setDisplayFormat("dd/MM/yyyy hh:mm:ss.zzz d/M/yy h:m:s.z AP");
+    // Section QDateTimeEdit::currentSection()
+    // void QDateTimeEdit::setCurrentSection(Section)
+    obj1.setCurrentSection(QDateTimeEdit::NoSection);
+    QVERIFY(obj1.currentSection() != QDateTimeEdit::NoSection);
+    obj1.setCurrentSection(QDateTimeEdit::AmPmSection);
+    QCOMPARE(QDateTimeEdit::AmPmSection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::MSecSection);
+    QCOMPARE(QDateTimeEdit::MSecSection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::SecondSection);
+    QCOMPARE(QDateTimeEdit::SecondSection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::MinuteSection);
+    QCOMPARE(QDateTimeEdit::MinuteSection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::HourSection);
+    QCOMPARE(QDateTimeEdit::HourSection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::DaySection);
+    QCOMPARE(QDateTimeEdit::DaySection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::MonthSection);
+    QCOMPARE(QDateTimeEdit::MonthSection, obj1.currentSection());
+    obj1.setCurrentSection(QDateTimeEdit::YearSection);
+    QCOMPARE(QDateTimeEdit::YearSection, obj1.currentSection());
+}
+
+tst_QDateTimeEdit::tst_QDateTimeEdit()
+{
+    qRegisterMetaType<QDate>("QDate");
+    qRegisterMetaType<QTime>("QTime");
+    qRegisterMetaType<QDateTime>("QDateTime");
+    qRegisterMetaType<QList<int> >("QList<int>");
+}
+
+tst_QDateTimeEdit::~tst_QDateTimeEdit()
+{
+
+}
+
+void tst_QDateTimeEdit::initTestCase()
+{
+    QLocale system = QLocale::system();
+    if (system.language() != QLocale::C && system.language() != QLocale::English)
+        qWarning("Running under locale %s/%s -- this test may generate failures due to language differences",
+                 qPrintable(QLocale::languageToString(system.language())),
+                 qPrintable(QLocale::countryToString(system.country())));
+    testWidget = new EditorDateEdit(0);
+    testFocusWidget = new QWidget(0);
+    testFocusWidget->resize(200, 100);
+    testFocusWidget->show();
+}
+
+void tst_QDateTimeEdit::cleanupTestCase()
+{
+    delete testFocusWidget;
+    testFocusWidget = 0;
+    delete testWidget;
+    testWidget = 0;
+}
+
+
+void tst_QDateTimeEdit::init()
+{
+    QLocale::setDefault(QLocale(QLocale::C));
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+    SetThreadLocale(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT));
+#endif
+    testWidget->setDisplayFormat("dd/MM/yyyy"); // Nice default to have
+    testWidget->setDateTime(QDateTime(QDate(2000, 1, 1), QTime(0, 0)));
+    testWidget->show();
+    testFocusWidget->move(-1000, -1000);
+}
+
+void tst_QDateTimeEdit::cleanup()
+{
+    testWidget->clearMinimumDateTime();
+    testWidget->clearMaximumDateTime();
+    testWidget->setTimeSpec(Qt::LocalTime);
+    testWidget->setSpecialValueText(QString());
+    testWidget->setWrapping(false);
+}
+
+void tst_QDateTimeEdit::constructor_qwidget()
+{
+    testWidget->hide();
+    QDateTimeEdit dte(0);
+    dte.show();
+    QCOMPARE(dte.dateTime(), QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0)));
+    QCOMPARE(dte.minimumDate(), QDate(1752, 9, 14));
+    QCOMPARE(dte.minimumTime(), QTime(0, 0, 0, 0));
+    QCOMPARE(dte.maximumDate(), QDate(7999, 12, 31));
+    QCOMPARE(dte.maximumTime(), QTime(23, 59, 59, 999));
+}
+
+void tst_QDateTimeEdit::constructor_qdatetime_data()
+{
+    QTest::addColumn<QDateTime>("parameter");
+    QTest::addColumn<QDateTime>("displayDateTime");
+    QTest::addColumn<QDate>("minimumDate");
+    QTest::addColumn<QTime>("minimumTime");
+    QTest::addColumn<QDate>("maximumDate");
+    QTest::addColumn<QTime>("maximumTime");
+
+    QTest::newRow("normal") << QDateTime(QDate(2004, 6, 16), QTime(13, 46, 32, 764))
+			 << QDateTime(QDate(2004, 6, 16), QTime(13, 46, 32, 764))
+			 << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
+			 << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
+
+    QTest::newRow("invalid") << QDateTime(QDate(9999, 99, 99), QTime(13, 46, 32, 764))
+			  << QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0))
+			  << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
+			  << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
+}
+
+
+
+void tst_QDateTimeEdit::constructor_qdatetime()
+{
+    QFETCH(QDateTime, parameter);
+    QFETCH(QDateTime, displayDateTime);
+    QFETCH(QDate, minimumDate);
+    QFETCH(QTime, minimumTime);
+    QFETCH(QDate, maximumDate);
+    QFETCH(QTime, maximumTime);
+
+    testWidget->hide();
+
+    QDateTimeEdit dte(parameter);
+    dte.show();
+    QCOMPARE(dte.dateTime(), displayDateTime);
+    QCOMPARE(dte.minimumDate(), minimumDate);
+    QCOMPARE(dte.minimumTime(), minimumTime);
+    QCOMPARE(dte.maximumDate(), maximumDate);
+    QCOMPARE(dte.maximumTime(), maximumTime);
+}
+
+void tst_QDateTimeEdit::constructor_qdate_data()
+{
+    QTest::addColumn<QDate>("parameter");
+    QTest::addColumn<QDateTime>("displayDateTime");
+    QTest::addColumn<QDate>("minimumDate");
+    QTest::addColumn<QTime>("minimumTime");
+    QTest::addColumn<QDate>("maximumDate");
+    QTest::addColumn<QTime>("maximumTime");
+
+    QTest::newRow("normal") << QDate(2004, 6, 16)
+			 << QDateTime(QDate(2004, 6, 16), QTime(0, 0, 0, 0))
+			 << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
+			 << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
+
+    QTest::newRow("invalid") << QDate(9999, 99, 99)
+			  << QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0))
+			  << QDate(1752, 9, 14) << QTime(0, 0, 0, 0)
+			  << QDate(7999, 12, 31) << QTime(23, 59, 59, 999);
+}
+
+
+
+void tst_QDateTimeEdit::constructor_qdate()
+{
+    QFETCH(QDate, parameter);
+    QFETCH(QDateTime, displayDateTime);
+    QFETCH(QDate, minimumDate);
+    QFETCH(QTime, minimumTime);
+    QFETCH(QDate, maximumDate);
+    QFETCH(QTime, maximumTime);
+
+    testWidget->hide();
+
+    QDateTimeEdit dte(parameter);
+    dte.show();
+    QCOMPARE(dte.dateTime(), displayDateTime);
+    QCOMPARE(dte.minimumDate(), minimumDate);
+    QCOMPARE(dte.minimumTime(), minimumTime);
+    QCOMPARE(dte.maximumDate(), maximumDate);
+    QCOMPARE(dte.maximumTime(), maximumTime);
+}
+
+void tst_QDateTimeEdit::constructor_qtime_data()
+{
+    QTest::addColumn<QTime>("parameter");
+    QTest::addColumn<QDateTime>("displayDateTime");
+    QTest::addColumn<QDate>("minimumDate");
+    QTest::addColumn<QTime>("minimumTime");
+    QTest::addColumn<QDate>("maximumDate");
+    QTest::addColumn<QTime>("maximumTime");
+
+    QTest::newRow("normal") << QTime(13, 46, 32, 764)
+			 << QDateTime(QDate(2000, 1, 1), QTime(13, 46, 32, 764))
+			 << QDate(2000, 1, 1) << QTime(0, 0, 0, 0)
+			 << QDate(2000, 1, 1) << QTime(23, 59, 59, 999);
+
+    QTest::newRow("invalid") << QTime(99, 99, 99, 5000)
+			  << QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0, 0))
+			  << QDate(2000, 1, 1) << QTime(0, 0, 0, 0)
+			  << QDate(2000, 1, 1) << QTime(23, 59, 59, 999);
+}
+
+
+
+void tst_QDateTimeEdit::constructor_qtime()
+{
+    QFETCH(QTime, parameter);
+    QFETCH(QDateTime, displayDateTime);
+    QFETCH(QDate, minimumDate);
+    QFETCH(QTime, minimumTime);
+    QFETCH(QDate, maximumDate);
+    QFETCH(QTime, maximumTime);
+
+    testWidget->hide();
+
+    QDateTimeEdit dte(parameter);
+    dte.show();
+    QCOMPARE(dte.dateTime(), displayDateTime);
+    QCOMPARE(dte.minimumDate(), minimumDate);
+    QCOMPARE(dte.minimumTime(), minimumTime);
+    QCOMPARE(dte.maximumDate(), maximumDate);
+    QCOMPARE(dte.maximumTime(), maximumTime);
+}
+
+void tst_QDateTimeEdit::minimumDate_data()
+{
+    QTest::addColumn<QDate>("minimumDate");
+    QTest::addColumn<QDate>("expectedMinDate");
+
+    QTest::newRow("normal-0") << QDate(2004, 5, 10) << QDate(2004, 5, 10);
+    QTest::newRow("normal-1") << QDate(2002, 3, 15) << QDate(2002, 3, 15);
+    QTest::newRow("normal-2") << QDate(7999, 12, 31) << QDate(7999, 12, 31);
+    QTest::newRow("normal-3") << QDate(1753, 1, 1) << QDate(1753, 1, 1);
+    QTest::newRow("invalid-0") << QDate(0, 0, 0) << QDate(1752, 9, 14);
+    QTest::newRow("old") << QDate(1492, 8, 3) << QDate(1492, 8, 3);
+}
+
+void tst_QDateTimeEdit::minimumDate()
+{
+    QFETCH(QDate, minimumDate);
+    QFETCH(QDate, expectedMinDate);
+
+    testWidget->setMinimumDate(minimumDate);
+    QCOMPARE(testWidget->minimumDate(), expectedMinDate);
+}
+
+void tst_QDateTimeEdit::minimumDateTime_data()
+{
+    QTest::addColumn<QDateTime>("minimumDateTime");
+    QTest::addColumn<QDateTime>("expectedMinDateTime");
+
+    QTest::newRow("normal-0") << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14))
+                              << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14));
+
+    QTest::newRow("normal-1") << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1))
+                              << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1));
+    QTest::newRow("normal-2") << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23))
+                              << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23));
+    QTest::newRow("normal-3") << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23))
+                              << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23));
+    QTest::newRow("normal-4") << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1))
+                              << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1));
+    QTest::newRow("invalid-0") << QDateTime() << QDateTime(QDate(1752, 9, 14), QTime(0, 0, 0));
+    QTest::newRow("old") << QDateTime(QDate(1492, 8, 3), QTime(2, 3, 1))
+                         << QDateTime(QDate(1492, 8, 3), QTime(2, 3, 1));
+}
+
+void tst_QDateTimeEdit::minimumDateTime()
+{
+    QFETCH(QDateTime, minimumDateTime);
+    QFETCH(QDateTime, expectedMinDateTime);
+
+    testWidget->setMinimumDateTime(minimumDateTime);
+    QCOMPARE(testWidget->minimumDateTime(), expectedMinDateTime);
+}
+
+
+void tst_QDateTimeEdit::maximumDateTime_data()
+{
+    QTest::addColumn<QDateTime>("maximumDateTime");
+    QTest::addColumn<QDateTime>("expectedMinDateTime");
+
+    QTest::newRow("normal-0") << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14))
+                              << QDateTime(QDate(2004, 5, 10), QTime(2, 3, 14));
+
+    QTest::newRow("normal-1") << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1))
+                              << QDateTime(QDate(2005, 5, 10), QTime(22, 33, 1));
+    QTest::newRow("normal-2") << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23))
+                              << QDateTime(QDate(2006, 5, 10), QTime(13, 31, 23));
+    QTest::newRow("normal-3") << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23))
+                              << QDateTime(QDate(2007, 5, 10), QTime(22, 23, 23));
+    QTest::newRow("normal-4") << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1))
+                              << QDateTime(QDate(2008, 5, 10), QTime(2, 3, 1));
+    QTest::newRow("invalid-0") << QDateTime() << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
+}
+
+void tst_QDateTimeEdit::maximumDateTime()
+{
+    QFETCH(QDateTime, maximumDateTime);
+    QFETCH(QDateTime, expectedMinDateTime);
+
+    testWidget->setMaximumDateTime(maximumDateTime);
+    QCOMPARE(testWidget->maximumDateTime(), expectedMinDateTime);
+}
+
+void tst_QDateTimeEdit::maximumDate_data()
+{
+    QTest::addColumn<QDate>("maximumDate");
+    QTest::addColumn<QDate>("expectedMaxDate");
+
+    QTest::newRow("normal-0") << QDate(2004, 05, 10) << QDate(2004, 5, 10);
+    QTest::newRow("normal-1") << QDate(2002, 03, 15) << QDate(2002, 3, 15);
+    QTest::newRow("normal-2") << QDate(7999, 12, 31) << QDate(7999, 12, 31);
+    QTest::newRow("normal-3") << QDate(1753, 1, 1) << QDate(1753, 1, 1);
+    QTest::newRow("invalid-0") << QDate(0, 0, 0) << QDate(7999, 12, 31);
+}
+
+void tst_QDateTimeEdit::maximumDate()
+{
+    QFETCH(QDate, maximumDate);
+    QFETCH(QDate, expectedMaxDate);
+
+    testWidget->setMaximumDate(maximumDate);
+    QCOMPARE(testWidget->maximumDate(), expectedMaxDate);
+}
+
+void tst_QDateTimeEdit::clearMinimumDate_data()
+{
+    QTest::addColumn<QDate>("minimumDate");
+    QTest::addColumn<bool>("valid");
+    QTest::addColumn<QDate>("expectedMinDateAfterClear");
+
+    QTest::newRow("normal-0") << QDate(2004, 05, 10) << true << QDate(1752, 9, 14);
+    QTest::newRow("normal-1") << QDate(2002, 3, 15) << true << QDate(1752, 9, 14);
+    QTest::newRow("normal-2") << QDate(7999, 12, 31) << true << QDate(1752, 9, 14);
+    QTest::newRow("normal-3") << QDate(1753, 1, 1) << true << QDate(1752, 9, 14);
+    QTest::newRow("invalid-0") << QDate(0, 0, 0) << false << QDate(1752, 9, 14);
+}
+
+void tst_QDateTimeEdit::clearMinimumDate()
+{
+    QFETCH(QDate, minimumDate);
+    QFETCH(bool, valid);
+    QFETCH(QDate, expectedMinDateAfterClear);
+
+    testWidget->setMinimumDate(minimumDate);
+    if (valid) {
+	QCOMPARE(testWidget->minimumDate(), minimumDate);
+    }
+    testWidget->clearMinimumDate();
+    QCOMPARE(testWidget->minimumDate(), expectedMinDateAfterClear);
+}
+
+void tst_QDateTimeEdit::clearMinimumDateTime_data()
+{
+    QTest::addColumn<QDateTime>("minimumDateTime");
+    QTest::addColumn<bool>("valid");
+    QTest::addColumn<QDateTime>("expectedMinDateTimeAfterClear");
+
+    QTest::newRow("normal-0") << QDateTime(QDate(2004, 05, 10), QTime(12, 12, 12))
+                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
+    QTest::newRow("normal-1") << QDateTime(QDate(2002, 3, 15), QTime(13, 13, 13))
+                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
+    QTest::newRow("normal-2") << QDateTime(QDate(7999, 12, 31), QTime(14, 14, 14))
+                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
+    QTest::newRow("normal-3") << QDateTime(QDate(1753, 1, 1), QTime(15, 15, 15))
+                              << true << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
+    QTest::newRow("invalid-0") << QDateTime() << false << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
+    QTest::newRow("old") << QDateTime(QDate(1492, 8, 3), QTime(2, 3, 1)) << true
+                         << QDateTime(QDate(1752, 9, 14), QTime(0, 0));
+
+}
+
+void tst_QDateTimeEdit::clearMinimumDateTime()
+{
+    QFETCH(QDateTime, minimumDateTime);
+    QFETCH(bool, valid);
+    QFETCH(QDateTime, expectedMinDateTimeAfterClear);
+
+    testWidget->setMinimumDateTime(minimumDateTime);
+    if (valid) {
+	QCOMPARE(testWidget->minimumDateTime(), minimumDateTime);
+    }
+    testWidget->clearMinimumDateTime();
+    QCOMPARE(testWidget->minimumDateTime(), expectedMinDateTimeAfterClear);
+}
+
+
+void tst_QDateTimeEdit::clearMaximumDateTime_data()
+{
+    QTest::addColumn<QDateTime>("maximumDateTime");
+    QTest::addColumn<bool>("valid");
+    QTest::addColumn<QDateTime>("expectedMinDateTimeAfterClear");
+
+    QTest::newRow("normal-0") << QDateTime(QDate(2004, 05, 10), QTime(12, 12, 12))
+                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
+    QTest::newRow("normal-1") << QDateTime(QDate(2002, 3, 15), QTime(13, 13, 13))
+                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
+    QTest::newRow("normal-2") << QDateTime(QDate(7999, 12, 31), QTime(14, 14, 14))
+                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
+    QTest::newRow("normal-3") << QDateTime(QDate(1753, 1, 1), QTime(15, 15, 15))
+                              << true << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
+    QTest::newRow("invalid-0") << QDateTime()
+                               << false << QDateTime(QDate(7999, 12, 31), QTime(23, 59, 59, 999));
+}
+
+void tst_QDateTimeEdit::clearMaximumDateTime()
+{
+    QFETCH(QDateTime, maximumDateTime);
+    QFETCH(bool, valid);
+    QFETCH(QDateTime, expectedMinDateTimeAfterClear);
+
+    testWidget->setMaximumDateTime(maximumDateTime);
+    if (valid) {
+	QCOMPARE(testWidget->maximumDateTime(), maximumDateTime);
+    }
+    testWidget->clearMaximumDateTime();
+    QCOMPARE(testWidget->maximumDateTime(), expectedMinDateTimeAfterClear);
+}
+
+
+void tst_QDateTimeEdit::clearMaximumDate_data()
+{
+    QTest::addColumn<QDate>("maximumDate");
+    QTest::addColumn<bool>("valid");
+    QTest::addColumn<QDate>("expectedMaxDateAfterClear");
+
+    QTest::newRow("normal-0") << QDate(2004, 05, 10) << true << QDate(7999, 12, 31);
+    QTest::newRow("normal-1") << QDate(2002, 03, 15) << true << QDate(7999, 12, 31);
+    QTest::newRow("normal-2") << QDate(7999, 12, 31) << true << QDate(7999, 12, 31);
+    QTest::newRow("normal-3") << QDate(2000, 1, 1) << true << QDate(7999, 12, 31);
+    QTest::newRow("invalid-0") << QDate(0, 0, 0) << false << QDate(7999, 12, 31);
+}
+
+void tst_QDateTimeEdit::clearMaximumDate()
+{
+    QFETCH(QDate, maximumDate);
+    QFETCH(bool, valid);
+    QFETCH(QDate, expectedMaxDateAfterClear);
+
+    testWidget->setMaximumDate(maximumDate);
+    if (valid) {
+	QCOMPARE(testWidget->maximumDate(), maximumDate);
+    }
+    testWidget->clearMaximumDate();
+    QCOMPARE(testWidget->maximumDate(), expectedMaxDateAfterClear);
+}
+
+void tst_QDateTimeEdit::displayFormat_data()
+{
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<bool>("valid");
+    QTest::addColumn<QString>("text");
+    QTest::addColumn<QDateTime>("date");
+
+    const QDateTime dt(QDate(2999, 12, 31), QTime(3, 59, 59, 999));
+
+    QTest::newRow("valid-0") << QString("yyyy MM dd") << true << QString("2999 12 31") << dt;
+    QTest::newRow("valid-1") << QString("dd MM yyyy::ss:mm:hh") << true
+                             << QString("31 12 2999::59:59:03") << dt;
+    QTest::newRow("valid-2") << QString("hh-dd-mm-MM-yy") << true << QString("03-31-59-12-99") << dt;
+    QTest::newRow("valid-3") << QString("ddd MM d yyyy::ss:mm:hh") << true
+                             << QDate::shortDayName(2) + " 12 31 2999::59:59:03" << dt;
+    QTest::newRow("valid-4") << QString("hh-dd-mm-MM-yyyy") << true << QString("03-31-59-12-2999") << dt;
+    QTest::newRow("invalid-0") << QString("yyyy.MM.yy") << true << QString("2999.12.99") << dt;
+    QTest::newRow("invalid-1") << QString("y") << false << QString() << dt;
+    QTest::newRow("invalid-2") << QString("") << false << QString() << dt;
+    QTest::newRow("quoted-1") << QString("'Midday is at:' dd") << true << QString("Midday is at: 31") << dt;
+    QTest::newRow("leading1") << QString("h:hh:hhh") << true << QString("3:03:033") << dt;
+    QTest::newRow("H1") << QString("HH:hh:ap") << true << QString("03:03:am") << dt;
+    QTest::newRow("H2") << QString("HH:hh:ap") << true << QString("23:11:pm")
+                        << QDateTime(dt.date(), QTime(23, 0, 0));
+}
+
+void tst_QDateTimeEdit::displayFormat()
+{
+    QFETCH(QString, format);
+    QFETCH(bool, valid);
+    QFETCH(QString, text);
+    QFETCH(QDateTime, date);
+
+    testWidget->setDateTime(date);
+
+    QString compareFormat = format;
+    if (!valid)
+	compareFormat = testWidget->displayFormat();
+    testWidget->setDisplayFormat(format);
+    QCOMPARE(testWidget->displayFormat(), compareFormat);
+    if (valid)
+        QCOMPARE(testWidget->text(), text);
+}
+
+void tst_QDateTimeEdit::selectAndScrollWithKeys()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 05, 11));
+    testWidget->setDisplayFormat("dd/MM/yyyy");
+    testWidget->show();
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("1"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/0"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/20"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/200"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
+
+    // Now the year part should be selected
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2005, 5, 11));
+    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::YearSection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2005"));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2004, 5, 11));
+    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::YearSection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
+
+
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("4"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("04"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("5/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("1/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11/05/2004"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+
+    // Now the day part should be selected
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2004, 5, 12));
+    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::DaySection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("12"));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2004, 5, 11));
+    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::DaySection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+    // Now the day part should be selected
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2004, 05, 12));
+}
+
+void tst_QDateTimeEdit::backspaceKey()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 05, 11));
+    testWidget->setDisplayFormat("d/MM/yyyy");
+    testWidget->show();
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QCOMPARE(testWidget->text(), QString("11/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/200"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/20"));
+    // Check that moving into another field reverts it
+    for (int i=0;i<3;i++)
+	QTest::keyClick(testWidget, Qt::Key_Left);
+    QCOMPARE(testWidget->text(), QString("11/05/2004"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    for (int i=0;i<4;i++) {
+	QTest::keyClick(testWidget, Qt::Key_Left, Qt::ShiftModifier);
+    }
+
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/"));
+    QTest::keyClick(testWidget, Qt::Key_Left);
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/0/2004"));
+    testWidget->interpretText();
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/200"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/20"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/2"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/05/"));
+    QTest::keyClick(testWidget, Qt::Key_Left);
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11/0/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("11//2004"));
+    QTest::keyClick(testWidget, Qt::Key_Left);
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("1/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->text(), QString("1/05/2004"));
+}
+
+void tst_QDateTimeEdit::deleteKey()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 05, 11));
+    testWidget->setDisplayFormat("d/MM/yyyy");
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Delete);
+    QCOMPARE(testWidget->text(), QString("1/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Delete);
+    QCOMPARE(testWidget->text(), QString("/05/2004"));
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QCOMPARE(testWidget->text(), QString("1/05/2004"));
+}
+
+void tst_QDateTimeEdit::tabKeyNavigation()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 05, 11));
+    testWidget->setDisplayFormat("dd/MM/yyyy");
+    testWidget->show();
+    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
+
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+}
+
+void tst_QDateTimeEdit::tabKeyNavigationWithPrefix()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 05, 11));
+    testWidget->setDisplayFormat("prefix dd/MM/yyyy");
+
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+}
+
+void tst_QDateTimeEdit::tabKeyNavigationWithSuffix()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 05, 11));
+    testWidget->setDisplayFormat("dd/MM/yyyy 'suffix'");
+
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2004"));
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("05"));
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+}
+
+
+void tst_QDateTimeEdit::enterKey()
+{
+    qApp->setActiveWindow(testWidget);
+    testWidget->setDate(QDate(2004, 5, 11));
+    testWidget->setDisplayFormat("prefix d/MM/yyyy 'suffix'");
+    testWidget->lineEdit()->setFocus();
+
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+    QTest::keyClick(testWidget, Qt::Key_1);
+    QTest::keyClick(testWidget, Qt::Key_5);
+
+    QTest::keyClick(testWidget, Qt::Key_Left);
+    QTest::keyClick(testWidget, Qt::Key_Left);
+
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("15"));
+    QCOMPARE(testWidget->date(), QDate(2004, 5, 15));
+
+    QTest::keyClick(testWidget, Qt::Key_9);
+    QTest::keyClick(testWidget, Qt::Key_Tab, Qt::ShiftModifier);
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("9"));
+    QCOMPARE(testWidget->date(), QDate(2004, 5, 9));
+
+    QTest::keyClick(testWidget, Qt::Key_0);
+    QTest::keyClick(testWidget, Qt::Key_0);
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("9"));
+    QCOMPARE(testWidget->date(), QDate(2004, 5, 9));
+
+    QSignalSpy enterSpy(testWidget, SIGNAL(dateChanged(const QDate &)));
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(enterSpy.count(), 1);
+
+#if 0
+    QVariantList list = enterSpy.takeFirst();
+    QCOMPARE(list.at(0).toDate(), QDate(2004, 9, 15));
+#endif
+
+}
+
+void tst_QDateTimeEdit::specialValueText()
+{
+    testWidget->setDisplayFormat("dd/MM/yyyy");
+    testWidget->setDateRange(QDate(2000, 1, 1), QDate(2001, 1, 1));
+    testWidget->setDate(QDate(2000, 1, 2));
+    testWidget->setSpecialValueText("fOo");
+    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
+    QCOMPARE(testWidget->date(), QDate(2000, 1, 2));
+    QCOMPARE(testWidget->text(), QString("02/01/2000"));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2000, 1, 1));
+    QCOMPARE(testWidget->text(), QString("fOo"));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2000, 1, 1));
+    QCOMPARE(testWidget->text(), QString("fOo"));
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2000, 1, 2));
+    QCOMPARE(testWidget->text(), QString("02/01/2000"));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2000, 1, 1));
+    QCOMPARE(testWidget->text(), QString("fOo"));
+
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2000, 1, 2));
+    QCOMPARE(testWidget->text(), QString("02/01/2000"));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->text(), QString("fOo"));
+
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("fO"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString("f"));
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString());
+    QTest::keyClick(testWidget, Qt::Key_F);
+    QCOMPARE(testWidget->text(), QString("f"));
+    QTest::keyClick(testWidget, Qt::Key_O); // will automatically uppercase
+    QCOMPARE(testWidget->text(), QString("fO"));
+    QTest::keyClick(testWidget, Qt::Key_O);
+    QCOMPARE(testWidget->text(), QString("fOo"));
+}
+
+
+void tst_QDateTimeEdit::setRange_data()
+{
+    QTest::addColumn<QTime>("minTime");
+    QTest::addColumn<QTime>("maxTime");
+    QTest::addColumn<QDate>("minDate");
+    QTest::addColumn<QDate>("maxDate");
+    QTest::addColumn<QDateTime>("expectedMin");
+    QTest::addColumn<QDateTime>("expectedMax");
+
+    const QDate cdt = QDate::currentDate();
+
+    QTest::newRow("data0") << QTime(0, 0) << QTime(14, 12, 0)
+                           << cdt << cdt
+                           << QDateTime(cdt, QTime(0, 0))
+                           << QDateTime(cdt, QTime(14, 12, 0));
+
+    QTest::newRow("data1") << QTime(10, 0) << QTime(1, 12, 0) << cdt.addDays(-1)
+                           << cdt
+                           << QDateTime(cdt.addDays(-1), QTime(10, 0))
+                           << QDateTime(cdt, QTime(1, 12, 0));
+}
+
+void tst_QDateTimeEdit::setRange()
+{
+    QFETCH(QTime, minTime);
+    QFETCH(QTime, maxTime);
+    QFETCH(QDate, minDate);
+    QFETCH(QDate, maxDate);
+    QFETCH(QDateTime, expectedMin);
+    QFETCH(QDateTime, expectedMax);
+    testWidget->hide();
+
+    {
+        QDateTimeEdit dte(0);
+        dte.setTimeRange(minTime, maxTime);
+        QCOMPARE(dte.minimumTime(), expectedMin.time());
+        QCOMPARE(dte.maximumTime(), expectedMax.time());
+        dte.setDateRange(minDate, maxDate);
+        QCOMPARE(dte.minimumDate(), expectedMin.date());
+        QCOMPARE(dte.minimumDateTime(), expectedMin);
+        QCOMPARE(dte.maximumDate(), expectedMax.date());
+        QCOMPARE(dte.maximumDateTime(), expectedMax);
+        QCOMPARE(dte.minimumTime(), expectedMin.time());
+        QCOMPARE(dte.maximumTime(), expectedMax.time());
+        dte.setDateTimeRange(QDateTime(minDate, minTime), QDateTime(maxDate, maxTime));
+        QCOMPARE(dte.minimumDate(), expectedMin.date());
+        QCOMPARE(dte.minimumDateTime(), expectedMin);
+        QCOMPARE(dte.maximumDate(), expectedMax.date());
+        QCOMPARE(dte.maximumDateTime(), expectedMax);
+        QCOMPARE(dte.minimumTime(), expectedMin.time());
+        QCOMPARE(dte.maximumTime(), expectedMax.time());
+    }
+    {
+
+        QDateTimeEdit dte2(0);
+        dte2.setDateRange(minDate, maxDate);
+        dte2.setTimeRange(minTime, maxTime);
+
+        QCOMPARE(dte2.minimumDate(), expectedMin.date());
+        QCOMPARE(dte2.maximumDate(), expectedMax.date());
+        QCOMPARE(dte2.minimumTime(), expectedMin.time());
+        QCOMPARE(dte2.maximumTime(), expectedMax.time());
+    }
+
+    {
+        QDateTimeEdit dte3(0);
+        dte3.setMinimumTime(minTime);
+        dte3.setMaximumTime(maxTime);
+        dte3.setMinimumDate(minDate);
+        dte3.setMaximumDate(maxDate);
+
+        QCOMPARE(dte3.minimumDate(), expectedMin.date());
+        QCOMPARE(dte3.maximumDate(), expectedMax.date());
+        QCOMPARE(dte3.minimumTime(), expectedMin.time());
+        QCOMPARE(dte3.maximumTime(), expectedMax.time());
+    }
+
+    {
+        QDateTimeEdit dte4(0);
+        dte4.setMinimumDate(minDate);
+        dte4.setMaximumDate(maxDate);
+        dte4.setMinimumTime(minTime);
+        dte4.setMaximumTime(maxTime);
+
+        QCOMPARE(dte4.minimumDate(), expectedMin.date());
+        QCOMPARE(dte4.maximumDate(), expectedMax.date());
+        QCOMPARE(dte4.minimumTime(), expectedMin.time());
+        QCOMPARE(dte4.maximumTime(), expectedMax.time());
+    }
+}
+
+void tst_QDateTimeEdit::wrappingTime_data()
+{
+    QTest::addColumn<bool>("startWithMin");
+    QTest::addColumn<QTime>("minimumTime");
+    QTest::addColumn<QTime>("maximumTime");
+    QTest::addColumn<uint>("section");
+    QTest::addColumn<QTime>("newTime");
+
+    QTest::newRow("data0") << false << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::HourSection
+                        << QTime(0,2,2);
+    QTest::newRow("data1") << true << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::HourSection
+                        << QTime(2,0,0);
+    QTest::newRow("data2") << false << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::MinuteSection
+                        << QTime(2,0,2);
+    QTest::newRow("data3") << true << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::MinuteSection
+                        << QTime(0,59,0);
+    QTest::newRow("data4") << false << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::SecondSection
+                        << QTime(2,2,0);
+    QTest::newRow("data5") << true << QTime(0,0,0) << QTime(2,2,2) << (uint)QDateTimeEdit::SecondSection
+                        << QTime(0,0,59);
+    QTest::newRow("data6") << false << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::HourSection
+                        << QTime(1,22,22);
+    QTest::newRow("data7") << true << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::HourSection
+                        << QTime(22,1,1);
+    QTest::newRow("data8") << false << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::MinuteSection
+                        << QTime(22,0,22);
+    QTest::newRow("data9") << true << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::MinuteSection
+                        << QTime(1,59,1);
+    QTest::newRow("data10") << false << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::SecondSection
+                         << QTime(22,22,0);
+    QTest::newRow("data11") << true << QTime(1,1,1) << QTime(22,22,22) << (uint)QDateTimeEdit::SecondSection
+                         << QTime(1,1,59);
+    QTest::newRow("data12") << false << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::HourSection
+                         << QTime(1,2,1);
+    QTest::newRow("data13") << true << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::HourSection
+                         << QTime(1,1,1);
+    QTest::newRow("data14") << false << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::MinuteSection
+                         << QTime(1,1,1);
+    QTest::newRow("data15") << true << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::MinuteSection
+                         << QTime(1,2,1);
+    QTest::newRow("data16") << false << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::SecondSection
+                         << QTime(1,2,0);
+    QTest::newRow("data17") << true << QTime(1,1,1) << QTime(1,2,1) << (uint)QDateTimeEdit::SecondSection
+                         << QTime(1,1,59);
+}
+
+
+void tst_QDateTimeEdit::wrappingTime()
+{
+    QFETCH(bool, startWithMin);
+    QFETCH(QTime, minimumTime);
+    QFETCH(QTime, maximumTime);
+    QFETCH(uint, section);
+    QFETCH(QTime, newTime);
+
+    testWidget->setDisplayFormat("hh:mm:ss");
+    testWidget->setMinimumTime(minimumTime);
+    testWidget->setMaximumTime(maximumTime);
+    testWidget->setWrapping(true);
+    testWidget->setCurrentSection((QDateTimeEdit::Section)section);
+    if (startWithMin) {
+        testWidget->setTime(minimumTime);
+        QTest::keyClick(testWidget, Qt::Key_Down);
+    } else {
+        testWidget->setTime(maximumTime);
+        QTest::keyClick(testWidget, Qt::Key_Up);
+    }
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->time(), newTime);
+}
+
+void tst_QDateTimeEdit::userKeyPress_Time_data()
+{
+    QTest::addColumn<bool>("ampm");
+    QTest::addColumn<QTestEventList>("keys");
+    QTest::addColumn<QTime>("expected_time");
+
+    // ***************** test the hours ***************
+
+    // use up/down keys to change hour in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 10, 0, 0 );
+        QTest::newRow( "data0" ) << bool(true) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<5; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 6, 0, 0 );
+        QTest::newRow( "data1" ) << bool(true) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<10; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 1, 0, 0 );
+        QTest::newRow( "data2" ) << bool(true) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<12; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 23, 0, 0 );
+        QTest::newRow( "data3" ) << bool(true) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 12, 0, 0 );
+        QTest::newRow( "data4" ) << bool(true) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 13, 0, 0 );
+        QTest::newRow( "data5" ) << bool(true) << keys << expected;
+    }
+
+    // use up/down keys to change hour in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 10, 0, 0 );
+        QTest::newRow( "data6" ) << bool(false) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<5; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 6, 0, 0 );
+        QTest::newRow( "data7" ) << bool(false) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<10; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 1, 0, 0 );
+        QTest::newRow( "data8" ) << bool(false) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<12; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 23, 0, 0 );
+        QTest::newRow( "data9" ) << bool(false) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 12, 0, 0 );
+        QTest::newRow( "data10" ) << bool(false) << keys << expected;
+    }
+    {
+        QTestEventList keys;
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 13, 0, 0 );
+        QTest::newRow( "data11" ) << bool(false) << keys << expected;
+    }
+
+    // enter a one digit valid hour
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '5' );
+        QTime expected( 5, 0, 0 );
+        QTest::newRow( "data12" ) << bool(true) << keys << expected;
+    }
+
+    // entering a two digit valid hour
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '1' );
+        keys.addKeyClick( '1' );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data13" ) << bool(true) << keys << expected;
+    }
+
+    // entering an invalid hour
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '2' );
+        // the '5' creates an invalid hour (25) so it must be ignored
+        keys.addKeyClick( '5' );
+        QTime expected( 2, 0, 0 );
+        QTest::newRow( "data14" ) << bool(true) << keys << expected;
+    }
+
+    // enter a value, in hour which causes a field change
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '0' );
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '1' );
+        QTime expected( 2, 1, 0 );
+        QTest::newRow( "data15" ) << bool(true) << keys << expected;
+    }
+
+    // enter a one digit valid hour in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '5' );
+        QTime expected( 5, 0, 0 );
+        QTest::newRow( "data16" ) << bool(false) << keys << expected;
+    }
+
+    // enter a two digit valid hour in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '1' );
+        keys.addKeyClick( '1' );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data17" ) << bool(false) << keys << expected;
+    }
+
+    // enter a two digit valid hour (>12) in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '1' );
+        keys.addKeyClick( '5' );
+        QTime expected( 15, 0, 0 );
+        QTest::newRow( "data18" ) << bool(false) << keys << expected;
+    }
+
+    // enter a two digit valid hour (>20) in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '1' );
+        QTime expected( 21, 0, 0 );
+        QTest::newRow( "data19" ) << bool(false) << keys << expected;
+    }
+
+    // enter a two digit invalid hour (>23) in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '4' );
+        QTime expected( 2, 0, 0 );
+        QTest::newRow( "data20" ) << bool(false) << keys << expected;
+    }
+
+    // ***************** test the minutes ***************
+
+    // use up/down keys to change the minutes in 12 hour mode
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 2, 0 );
+        QTest::newRow( "data21" ) << bool(true) << keys << expected;
+    }
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<16; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 16, 0 );
+        QTest::newRow( "data22" ) << bool(true) << keys << expected;
+    }
+    { // test maximum value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<59; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 59, 0 );
+        QTest::newRow( "data23" ) << bool(true) << keys << expected;
+    }
+    { // test 'overflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<60; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data24" ) << bool(true) << keys << expected;
+    }
+    { // test 'underflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 59, 0 );
+        QTest::newRow( "data25" ) << bool(true) << keys << expected;
+    }
+    { // test valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 58, 0 );
+        QTest::newRow( "data26" ) << bool(true) << keys << expected;
+    }
+
+    // use up/down keys to change the minutes in 24 hour mode
+
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 2, 0 );
+        QTest::newRow( "data27" ) << bool(false) << keys << expected;
+    }
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<16; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 16, 0 );
+        QTest::newRow( "data28" ) << bool(false) << keys << expected;
+    }
+    { // test maximum value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<59; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 59, 0 );
+        QTest::newRow( "data29" ) << bool(false) << keys << expected;
+    }
+    { // test 'overflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<60; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data30" ) << bool(false) << keys << expected;
+    }
+    { // test 'underflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 59, 0 );
+        QTest::newRow( "data31" ) << bool(false) << keys << expected;
+    }
+    { // test valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 58, 0 );
+        QTest::newRow( "data32" ) << bool(false) << keys << expected;
+    }
+
+    // enter a valid one digit minute in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick(Qt::Key_Tab);
+        keys.addKeyClick( '2' );
+        QTime expected( 11, 2, 0 );
+        QTest::newRow( "data33" ) << bool(true) << keys << expected;
+    }
+
+    // enter a valid two digit minutes in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick(Qt::Key_Tab);
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '4' );
+        QTime expected( 11, 24, 0 );
+        QTest::newRow( "data34" ) << bool(true) << keys << expected;
+    }
+
+    // check the lower limit of the minutes in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick(Qt::Key_Tab);
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data35" ) << bool(true) << keys << expected;
+    }
+
+    // check the upper limit of the minutes in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick(Qt::Key_Tab);
+        keys.addKeyClick( '5' );
+        keys.addKeyClick( '9' );
+        QTime expected( 11, 59, 0 );
+        QTest::newRow( "data36" ) << bool(true) << keys << expected;
+    }
+
+    // enter an invalid two digit minutes in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '6' );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 6, 0 );
+        QTest::newRow( "data37" ) << bool(true) << keys << expected;
+    }
+
+    // test minutes in 24 hour motestWidget-> Behaviour should be exactly the same
+
+    // enter a valid one digit minute in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '2' );
+        QTime expected( 11, 2, 0 );
+        QTest::newRow( "data38" ) << bool(false) << keys << expected;
+    }
+
+    // enter a valid two digit minutes in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '4' );
+        QTime expected( 11, 24, 0 );
+        QTest::newRow( "data39" ) << bool(false) << keys << expected;
+    }
+
+    // check the lower limit of the minutes in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data40" ) << bool(false) << keys << expected;
+    }
+
+    // check the upper limit of the minutes in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '5' );
+        keys.addKeyClick( '9' );
+        QTime expected( 11, 59, 0 );
+        QTest::newRow( "data41" ) << bool(false) << keys << expected;
+    }
+
+    // enter an invalid two digit minutes in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '6' );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 6, 0 );
+        QTest::newRow( "data42" ) << bool(false) << keys << expected;
+    }
+
+    // ***************** test the seconds ***************
+
+    // use up/down to edit the seconds...
+
+    // use up/down keys to change the seconds in 12 hour mode
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 2 );
+        QTest::newRow( "data43" ) << bool(true) << keys << expected;
+    }
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<16; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 16 );
+        QTest::newRow( "data44" ) << bool(true) << keys << expected;
+    }
+    { // test maximum value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<59; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 59 );
+        QTest::newRow( "data45" ) << bool(true) << keys << expected;
+    }
+    { // test 'overflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<60; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data46" ) << bool(true) << keys << expected;
+    }
+    { // test 'underflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 0, 59 );
+        QTest::newRow( "data47" ) << bool(true) << keys << expected;
+    }
+    { // test valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 0, 58 );
+        QTest::newRow( "data48" ) << bool(true) << keys << expected;
+    }
+
+    // use up/down keys to change the seconds in 24 hour mode
+
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 2 );
+        QTest::newRow( "data49" ) << bool(false) << keys << expected;
+    }
+    { // test a valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<16; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 16 );
+        QTest::newRow( "data50" ) << bool(false) << keys << expected;
+    }
+    { // test maximum value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<59; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 59 );
+        QTest::newRow( "data51" ) << bool(false) << keys << expected;
+    }
+    { // test 'overflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<60; i++)
+            keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data52" ) << bool(false) << keys << expected;
+    }
+    { // test 'underflow'
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 0, 59 );
+        QTest::newRow( "data53" ) << bool(false) << keys << expected;
+    }
+    { // test valid value
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        for (uint i=0; i<2; i++)
+            keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 0, 58 );
+        QTest::newRow( "data54" ) << bool(false) << keys << expected;
+    }
+
+    // enter a valid one digit second in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '2' );
+        QTime expected( 11, 0, 2 );
+        QTest::newRow( "data55" ) << bool(true) << keys << expected;
+    }
+
+    // enter a valid two digit seconds in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '4' );
+        QTime expected( 11, 0, 24 );
+        QTest::newRow( "data56" ) << bool(true) << keys << expected;
+    }
+
+    // check the lower limit of the seconds in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data57" ) << bool(true) << keys << expected;
+    }
+
+    // check the upper limit of the seconds in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '5' );
+        keys.addKeyClick( '9' );
+        QTime expected( 11, 0, 59 );
+        QTest::newRow( "data58" ) << bool(true) << keys << expected;
+    }
+
+    // enter an invalid two digit seconds in 12 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '6' );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 0, 6 );
+        QTest::newRow( "data59" ) << bool(true) << keys << expected;
+    }
+
+    // test seconds in 24 hour mode. Behaviour should be exactly the same
+
+    // enter a valid one digit minute in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '2' );
+        QTime expected( 11, 0, 2 );
+        QTest::newRow( "data60" ) << bool(false) << keys << expected;
+    }
+
+    // enter a valid two digit seconds in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '2' );
+        keys.addKeyClick( '4' );
+        QTime expected( 11, 0, 24 );
+        QTest::newRow( "data61" ) << bool(false) << keys << expected;
+    }
+
+    // check the lower limit of the seconds in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data62" ) << bool(false) << keys << expected;
+    }
+
+    // check the upper limit of the seconds in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '5' );
+        keys.addKeyClick( '9' );
+        QTime expected( 11, 0, 59 );
+        QTest::newRow( "data63" ) << bool(false) << keys << expected;
+    }
+
+    // enter an invalid two digit seconds in 24 h mode
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( '6' );
+        keys.addKeyClick( '0' );
+        QTime expected( 11, 0, 6 );
+        QTest::newRow( "data64" ) << bool(false) << keys << expected;
+    }
+
+    // Test the AMPM indicator
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Up );
+        QTime expected( 23, 0, 0 );
+        QTest::newRow( "data65" ) << bool(true) << keys << expected;
+    }
+    // Test the AMPM indicator
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 23, 0, 0 );
+        QTest::newRow( "data66" ) << bool(true) << keys << expected;
+    }
+    // Test the AMPM indicator
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Down );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data67" ) << bool(true) << keys << expected;
+    }
+    // Test the AMPM indicator
+    {
+        QTestEventList keys;
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Tab );
+        keys.addKeyClick( Qt::Key_Up );
+        keys.addKeyClick( Qt::Key_Down );
+        QTime expected( 11, 0, 0 );
+        QTest::newRow( "data68" ) << bool(true) << keys << expected;
+    }
+}
+
+void tst_QDateTimeEdit::userKeyPress_Time()
+{
+    QFETCH(bool, ampm);
+    QFETCH(QTestEventList, keys);
+    QFETCH(QTime, expected_time);
+
+    if (ampm)
+        testWidget->setDisplayFormat("hh:mm:ss ap");
+    else
+        testWidget->setDisplayFormat("hh:mm:ss");
+
+    testWidget->setTime(QTime(11, 0, 0));
+    testWidget->setFocus();
+
+    testWidget->setWrapping(true);
+
+    QTest::keyClick(testWidget, Qt::Key_Enter); // Make sure the first section is now focused
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("11"));
+    keys.simulate(testWidget);
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+
+    QCOMPARE(testWidget->time(), expected_time);
+}
+
+void tst_QDateTimeEdit::wrappingDate_data()
+{
+    QTest::addColumn<bool>("startWithMin");
+    QTest::addColumn<QDate>("minimumDate");
+    QTest::addColumn<QDate>("maximumDate");
+    QTest::addColumn<uint>("section");
+    QTest::addColumn<QDate>("newDate");
+
+    QTest::newRow("data0") << false << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::DaySection
+                        << QDate(1999, 1, 1);
+    QTest::newRow("data1") << true << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::DaySection
+                        << QDate(1999, 1, 31);
+    QTest::newRow("data2") << false << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::MonthSection
+                        << QDate(1999, 1, 31);
+    QTest::newRow("data3") << true << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::MonthSection
+                        << QDate(1999, 1, 1);
+    QTest::newRow("data4") << false << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::YearSection
+                        << QDate(1999, 1, 31);
+    QTest::newRow("data5") << true << QDate(1999, 1, 1) << QDate(1999, 1, 31) << (uint)QDateTimeEdit::YearSection
+                        << QDate(1999, 1, 1);
+    QTest::newRow("data6") << false << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::DaySection
+                        << QDate(2000, 1, 1);
+    QTest::newRow("data7") << true << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::DaySection
+                        << QDate(1999, 1, 31);
+    QTest::newRow("data8") << false << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::MonthSection
+                        << QDate(2000, 1, 31);
+    QTest::newRow("data9") << true << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::MonthSection
+                        << QDate(1999, 12, 1);
+    QTest::newRow("data10") << false << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::YearSection
+                         << QDate(1999, 1, 31);
+    QTest::newRow("data11") << true << QDate(1999, 1, 1) << QDate(2000, 1, 31) << (uint)QDateTimeEdit::YearSection
+                         << QDate(2000, 1, 1);
+}
+
+
+void tst_QDateTimeEdit::wrappingDate()
+{
+    QFETCH(bool, startWithMin);
+    QFETCH(QDate, minimumDate);
+    QFETCH(QDate, maximumDate);
+    QFETCH(uint, section);
+    QFETCH(QDate, newDate);
+
+    testWidget->setDisplayFormat("dd/MM/yyyy");
+    testWidget->setMinimumDate(minimumDate);
+    testWidget->setMaximumDate(maximumDate);
+    testWidget->setWrapping(true);
+    testWidget->setCurrentSection((QDateTimeEdit::Section)section);
+
+    if (startWithMin) {
+        testWidget->setDate(minimumDate);
+        QTest::keyClick(testWidget, Qt::Key_Down);
+    } else {
+        testWidget->setDate(maximumDate);
+        QTest::keyClick(testWidget, Qt::Key_Up);
+    }
+    if (testWidget->currentSection() == QDateTimeEdit::MonthSection)
+        QCOMPARE(testWidget->date(), newDate);
+}
+
+void tst_QDateTimeEdit::dateSignalChecking_data()
+{
+    QTest::addColumn<QDate>("originalDate");
+    QTest::addColumn<QDate>("newDate");
+    QTest::addColumn<int>("timesEmitted");
+
+    QTest::newRow("data0") << QDate(2004, 06, 22) << QDate(2004, 07, 23) << 1;
+    QTest::newRow("data1") << QDate(2004, 06, 22) << QDate(2004, 06, 22) << 0;
+}
+
+void tst_QDateTimeEdit::dateSignalChecking()
+{
+    QFETCH(QDate, originalDate);
+    QFETCH(QDate, newDate);
+    QFETCH(int, timesEmitted);
+
+    testWidget->setDate(originalDate);
+
+    QSignalSpy dateSpy(testWidget, SIGNAL(dateChanged(const QDate &)));
+    QSignalSpy dateTimeSpy(testWidget, SIGNAL(dateTimeChanged(const QDateTime &)));
+    QSignalSpy timeSpy(testWidget, SIGNAL(timeChanged(const QTime &)));
+
+    testWidget->setDate(newDate);
+    QCOMPARE(dateSpy.count(), timesEmitted);
+
+    if (timesEmitted > 0) {
+        QList<QVariant> list = dateSpy.takeFirst();
+        QDate d;
+        d = qVariantValue<QDate>(list.at(0));
+        QCOMPARE(d, newDate);
+    }
+    QCOMPARE(dateTimeSpy.count(), timesEmitted);
+    QCOMPARE(timeSpy.count(), 0);
+}
+
+void tst_QDateTimeEdit::timeSignalChecking_data()
+{
+    QTest::addColumn<QTime>("originalTime");
+    QTest::addColumn<QTime>("newTime");
+    QTest::addColumn<int>("timesEmitted");
+
+    QTest::newRow("data0") << QTime(15, 55, 00) << QTime(15, 17, 12) << 1;
+    QTest::newRow("data1") << QTime(15, 55, 00) << QTime(15, 55, 00) << 0;
+}
+
+void tst_QDateTimeEdit::timeSignalChecking()
+{
+    QFETCH(QTime, originalTime);
+    QFETCH(QTime, newTime);
+    QFETCH(int, timesEmitted);
+
+    testWidget->setTime(originalTime);
+
+    testWidget->setDisplayFormat("hh:mm:ss");
+    QSignalSpy dateSpy(testWidget, SIGNAL(dateChanged(const QDate &)));
+    QSignalSpy dateTimeSpy(testWidget, SIGNAL(dateTimeChanged(const QDateTime &)));
+    QSignalSpy timeSpy(testWidget, SIGNAL(timeChanged(const QTime &)));
+
+    testWidget->setTime(newTime);
+    QCOMPARE(timeSpy.count(), timesEmitted);
+
+    if (timesEmitted > 0) {
+        QList<QVariant> list = timeSpy.takeFirst();
+        QTime t;
+        t = qVariantValue<QTime>(list.at(0));
+        QCOMPARE(t, newTime);
+    }
+    QCOMPARE(dateTimeSpy.count(), timesEmitted);
+    QCOMPARE(dateSpy.count(), 0);
+}
+
+void tst_QDateTimeEdit::dateTimeSignalChecking_data()
+{
+    QTest::addColumn<QDateTime>("originalDateTime");
+    QTest::addColumn<QDateTime>("newDateTime");
+    QTest::addColumn<int>("timesDateEmitted");
+    QTest::addColumn<int>("timesTimeEmitted");
+    QTest::addColumn<int>("timesDateTimeEmitted");
+
+    QTest::newRow("data0") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
+                        << QDateTime(QDate(2004, 7, 23), QTime(15, 17, 12))
+                        << 1 << 1 << 1;
+    QTest::newRow("data1") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 17, 12))
+                        << 0 << 1 << 1;
+    QTest::newRow("data2") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
+                        << QDateTime(QDate(2004, 7, 23), QTime(15, 55, 0))
+                        << 1 << 0 << 1;
+    QTest::newRow("data3") << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 0))
+                        << 0 << 0 << 0;
+}
+
+void tst_QDateTimeEdit::dateTimeSignalChecking()
+{
+    QFETCH(QDateTime, originalDateTime);
+    QFETCH(QDateTime, newDateTime);
+    QFETCH(int, timesDateEmitted);
+    QFETCH(int, timesTimeEmitted);
+    QFETCH(int, timesDateTimeEmitted);
+
+    testWidget->setDisplayFormat("dd/MM/yyyy hh:mm:ss");
+    testWidget->setDateTime(originalDateTime);
+
+    QSignalSpy dateSpy(testWidget, SIGNAL(dateChanged(const QDate &)));
+    QSignalSpy timeSpy(testWidget, SIGNAL(timeChanged(const QTime &)));
+    QSignalSpy dateTimeSpy(testWidget, SIGNAL(dateTimeChanged(const QDateTime &)));
+
+    testWidget->setDateTime(newDateTime);
+    QCOMPARE(dateSpy.count(), timesDateEmitted);
+    if (timesDateEmitted > 0) {
+        QCOMPARE(timesDateEmitted, 1);
+        QList<QVariant> list = dateSpy.takeFirst();
+        QDate d;
+        d = qVariantValue<QDate>(list.at(0));
+        QCOMPARE(d, newDateTime.date());
+    }
+    QCOMPARE(timeSpy.count(), timesTimeEmitted);
+    if (timesTimeEmitted > 0) {
+        QList<QVariant> list = timeSpy.takeFirst();
+        QTime t;
+        t = qVariantValue<QTime>(list.at(0));
+        QCOMPARE(t, newDateTime.time());
+    }
+    QCOMPARE(dateTimeSpy.count(), timesDateTimeEmitted);
+    if (timesDateTimeEmitted > 0) {
+        QList<QVariant> list = dateTimeSpy.takeFirst();
+        QDateTime dt;
+        dt = qVariantValue<QDateTime>(list.at(0));
+        QCOMPARE(dt, newDateTime);
+    }
+}
+
+
+void tst_QDateTimeEdit::sectionText_data()
+{
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<QDateTime>("dateTime");
+    QTest::addColumn<uint>("section");
+    QTest::addColumn<QString>("sectionText");
+
+    QTest::newRow("data0") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::NoSection << QString();
+    QTest::newRow("data1") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::AmPmSection << QString("pm");
+    QTest::newRow("data2") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::MSecSection << QString("789");
+    QTest::newRow("data3") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::SecondSection << QString("03");
+    QTest::newRow("data4") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::MinuteSection << QString("55");
+    QTest::newRow("data5") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::HourSection << QString("03");
+    QTest::newRow("data6") << QString("dd/MM/yyyy hh:mm:ss zzz")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::HourSection << QString("15");
+    QTest::newRow("data7") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::DaySection << QString("22");
+    QTest::newRow("data8") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::MonthSection << QString("06");
+    QTest::newRow("data9") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                        << (uint)QDateTimeEdit::YearSection << QString("2004");
+    QTest::newRow("data10") << QString("dd/MM/yyyy hh:mm:ss zzz AP")
+                         << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                         << (uint)QDateTimeEdit::AmPmSection << QString("PM");
+    QTest::newRow("data11") << QString("dd/MM/yyyy hh:mm:ss ap")
+                         << QDateTime(QDate(2004, 6, 22), QTime(15, 55, 3, 789))
+                         << (uint)QDateTimeEdit::MSecSection << QString();
+}
+
+void tst_QDateTimeEdit::sectionText()
+{
+    QFETCH(QString, format);
+    QFETCH(QDateTime, dateTime);
+    QFETCH(uint, section);
+    QFETCH(QString, sectionText);
+
+    testWidget->setDisplayFormat(format);
+    testWidget->setDateTime(dateTime);
+    QCOMPARE(testWidget->sectionText((QDateTimeEdit::Section)section), sectionText);
+//    QApplication::setLayoutDirection(Qt::RightToLeft);
+//    testWidget->setDisplayFormat(format);
+//    QCOMPARE(format, testWidget->displayFormat());
+//     testWidget->setDateTime(dateTime);
+//     QCOMPARE(testWidget->sectionText((QDateTimeEdit::Section)section), sectionText);
+//     QApplication::setLayoutDirection(Qt::LeftToRight);
+}
+
+void tst_QDateTimeEdit::mousePress()
+{
+    testWidget->setDate(QDate(2004, 6, 23));
+    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
+    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::YearSection);
+    int offset = 10;
+#if defined(Q_OS_WINCE)
+    offset = 20;
+    if (qt_wince_is_pocket_pc()) {
+        // depending on wether the display is double-pixeld, we need
+        // to click at a different position
+        bool doubledSize = false;
+        int dpi = GetDeviceCaps(GetDC(0), LOGPIXELSX);
+        if ((dpi < 1000) && (dpi > 0))
+            doubledSize = true;
+        offset = doubledSize ? 50 : 25; // On CE buttons are aligned horizontal
+    }
+#endif
+    QTest::mouseClick(testWidget, Qt::LeftButton, 0, QPoint(testWidget->width() - offset, 5));
+    QCOMPARE(testWidget->date().year(), 2005);
+}
+
+void tst_QDateTimeEdit::stepHourAMPM_data()
+{
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<KeyList>("keys");
+    QTest::addColumn<TimeList>("expected");
+    QTest::addColumn<QTime>("start");
+    QTest::addColumn<QTime>("min");
+    QTest::addColumn<QTime>("max");
+
+    {
+        KeyList keys;
+        TimeList expected;
+        keys << Qt::Key_Up;
+        expected << QTime(1, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(2, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(3, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(4, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(5, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(6, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(7, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(8, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(9, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(10, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(11, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(12, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(13, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(14, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(15, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(16, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(17, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(18, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(19, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(20, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(21, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(22, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(23, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(22, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(21, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(20, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(19, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(18, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(17, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(16, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(15, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(14, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(13, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(12, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(11, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(10, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(9, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(8, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(7, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(6, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(5, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(4, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(3, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(2, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(1, 0, 0);
+        keys << Qt::Key_Down;
+        expected << QTime(0, 0, 0);
+
+        QTest::newRow("hh 1") << QString("hh") << keys << expected << QTime(0, 0)
+                              << QTime(0, 0) << QTime(23, 59, 59);
+        QTest::newRow("hh:ap 1") << QString("hh:ap") << keys << expected
+                                 << QTime(0, 0) << QTime(0, 0)
+                                 << QTime(23, 59, 59);
+
+        QTest::newRow("HH:ap 2") << QString("HH:ap") << keys << expected
+                                 << QTime(0, 0) << QTime(0, 0)
+                                 << QTime(23, 59, 59);
+
+    }
+    {
+        KeyList keys;
+        TimeList expected;
+        keys << Qt::Key_Down;
+        expected << QTime(2, 0, 0);
+        QTest::newRow("hh 2") << QString("hh") << keys << expected << QTime(0, 0) << QTime(2, 0, 0) << QTime(23, 59, 59);
+        QTest::newRow("hh:ap 2") << QString("hh:ap") << keys << expected << QTime(0, 0) << QTime(2, 0, 0) << QTime(23, 59, 59);
+    }
+    {
+        KeyList keys;
+        TimeList expected;
+        keys << Qt::Key_Up;
+        expected << QTime(23, 0, 0);
+        keys << Qt::Key_Up;
+        expected << QTime(23, 0, 0);
+        QTest::newRow("hh 3") << QString("hh") << keys << expected << QTime(0, 0) << QTime(22, 0, 0)
+                              << QTime(23, 59, 59);
+        QTest::newRow("hh:ap 3") << QString("hh:ap") << keys << expected << QTime(0, 0)
+                                 << QTime(22, 0, 0) << QTime(23, 59, 59);
+    }
+    {
+        KeyList keys;
+        TimeList expected;
+        keys << Qt::Key_Up;
+        expected << QTime(15, 31, 0);
+        QTest::newRow("hh:mm:ap 3") << QString("hh:mm:ap") << keys << expected << QTime(15, 31, 0)
+                                    << QTime(9, 0, 0) << QTime(16, 0, 0);
+        QTest::newRow("hh:mm 3") << QString("hh:mm") << keys << expected << QTime(15, 31, 0)
+                                 << QTime(9, 0, 0) << QTime(16, 0, 0);
+    }
+}
+
+void tst_QDateTimeEdit::stepHourAMPM()
+{
+    QFETCH(QString, format);
+    QFETCH(KeyList, keys);
+    QFETCH(TimeList, expected);
+    QFETCH(QTime, start);
+    QFETCH(QTime, min);
+    QFETCH(QTime, max);
+
+
+    testWidget->setDisplayFormat(format);
+    testWidget->setTime(start);
+    testWidget->setMinimumTime(min);
+    testWidget->setMaximumTime(max);
+    if (keys.size() != expected.size()) {
+        qWarning("%s:%d Test broken", __FILE__, __LINE__);
+        QCOMPARE(keys.size(), expected.size());
+    }
+
+    for (int i=0; i<keys.size(); ++i) {
+        QTest::keyClick(testWidget, keys.at(i));
+        QCOMPARE(testWidget->time(), expected.at(i));
+    }
+}
+
+
+void tst_QDateTimeEdit::displayedSections_data()
+{
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<uint>("section");
+
+    QTest::newRow("data0") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::MonthSection
+                                  | QDateTimeEdit::YearSection | QDateTimeEdit::HourSection
+                                  | QDateTimeEdit::MinuteSection | QDateTimeEdit::SecondSection
+                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
+    QTest::newRow("data1") << QString("dd/yyyy hh:mm:ss zzz ap")
+                        << (uint)(QDateTimeEdit::DaySection
+                                  | QDateTimeEdit::YearSection | QDateTimeEdit::HourSection
+                                  | QDateTimeEdit::MinuteSection | QDateTimeEdit::SecondSection
+                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
+    QTest::newRow("data2") << QString("dd/MM/yyyy mm zzz ap")
+                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::MonthSection
+                                  | QDateTimeEdit::YearSection
+                                  | QDateTimeEdit::MinuteSection
+                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
+    QTest::newRow("data3") << QString("dd/MM/yyyy")
+                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::MonthSection
+                                  | QDateTimeEdit::YearSection);
+    QTest::newRow("data4") << QString("hh:mm:ss zzz ap")
+                        << (uint)(QDateTimeEdit::HourSection
+                                  | QDateTimeEdit::MinuteSection | QDateTimeEdit::SecondSection
+                                  | QDateTimeEdit::MSecSection | QDateTimeEdit::AmPmSection);
+    QTest::newRow("data5") << QString("dd ap")
+                        << (uint)(QDateTimeEdit::DaySection | QDateTimeEdit::AmPmSection);
+    QTest::newRow("data6") << QString("zzz")
+                        << (uint)QDateTimeEdit::MSecSection;
+}
+
+void tst_QDateTimeEdit::displayedSections()
+{
+    QFETCH(QString, format);
+    QFETCH(uint, section);
+
+    testWidget->setDisplayFormat(format);
+    QVERIFY((QDateTimeEdit::Section)section == testWidget->displayedSections());
+}
+
+void tst_QDateTimeEdit::currentSection_data()
+{
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<uint>("section");
+    QTest::addColumn<uint>("currentSection");
+
+    // First is deliberate, this way we can make sure that it is not reset by specifying no section.
+    QTest::newRow("data0") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::NoSection << (uint)QDateTimeEdit::YearSection;
+    QTest::newRow("data1") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::AmPmSection << (uint)QDateTimeEdit::AmPmSection;
+    QTest::newRow("data2") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::MSecSection << (uint)QDateTimeEdit::MSecSection;
+    QTest::newRow("data3") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::SecondSection << (uint)QDateTimeEdit::SecondSection;
+    QTest::newRow("data4") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::MinuteSection << (uint)QDateTimeEdit::MinuteSection;
+    QTest::newRow("data5") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::HourSection << (uint)QDateTimeEdit::HourSection;
+    QTest::newRow("data6") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::DaySection << (uint)QDateTimeEdit::DaySection;
+    QTest::newRow("data7") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::MonthSection << (uint)QDateTimeEdit::MonthSection;
+    QTest::newRow("data8") << QString("dd/MM/yyyy hh:mm:ss zzz ap")
+                        << (uint)QDateTimeEdit::YearSection << (uint)QDateTimeEdit::YearSection;
+    QTest::newRow("data9") << QString("dd/MM/yyyy hh:mm:ss zzz AP")
+                        << (uint)QDateTimeEdit::AmPmSection << (uint)QDateTimeEdit::AmPmSection;
+    QTest::newRow("data10") << QString("dd/MM/yyyy hh:mm:ss ap")
+                         << (uint)QDateTimeEdit::MSecSection << (uint)QDateTimeEdit::DaySection;
+}
+
+void tst_QDateTimeEdit::currentSection()
+{
+    QFETCH(QString, format);
+    QFETCH(uint, section);
+    QFETCH(uint, currentSection);
+
+    testWidget->setDisplayFormat(format);
+    if ((QDateTimeEdit::Section)section == QDateTimeEdit::NoSection)
+        testWidget->setCurrentSection(QDateTimeEdit::YearSection); // Ensure it's not reset (see above)
+    testWidget->setCurrentSection((QDateTimeEdit::Section)section);
+    QVERIFY((QDateTimeEdit::Section)currentSection == testWidget->currentSection());
+}
+
+void tst_QDateTimeEdit::readOnly()
+{
+    testWidget->hide();
+    QDateTimeEdit dt(QDate(2000, 2, 1));
+    dt.setDisplayFormat("yyyy.MM.dd");
+    dt.show();
+    dt.setCurrentSection(QDateTimeEdit::DaySection);
+    QTest::keyClick(&dt, Qt::Key_Up);
+    QCOMPARE(dt.date(), QDate(2000, 2, 2));
+    dt.setReadOnly(true);
+    QTest::keyClick(&dt, Qt::Key_Up);
+    QCOMPARE(dt.date(), QDate(2000, 2, 2));
+    dt.stepBy(1); // stepBy should still work
+    QCOMPARE(dt.date(), QDate(2000, 2, 3));
+    dt.setReadOnly(false);
+    QTest::keyClick(&dt, Qt::Key_Up);
+    QCOMPARE(dt.date(), QDate(2000, 2, 4));
+}
+
+void tst_QDateTimeEdit::weirdCase()
+{
+    testWidget->lineEdit()->setCursorPosition(0);
+    testWidget->setDateRange(QDate(2005, 1, 1), QDate(2010, 12, 31));
+    testWidget->setDisplayFormat("dd//MM//yyyy");
+    testWidget->setDate(testWidget->minimumDate());
+    QTest::keyClick(testWidget, Qt::Key_Left);
+    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
+    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 0);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
+    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 8);
+
+    QTest::keyClick(testWidget, Qt::Key_Delete);
+    QCOMPARE(testWidget->text(), QString("01//01//005"));
+    QTest::keyClick(testWidget, Qt::Key_4);
+    QCOMPARE(testWidget->text(), QString("01//01//005"));
+}
+
+void tst_QDateTimeEdit::newCase()
+{
+    if (QDate::shortMonthName(6) != "Jun" || QDate::shortMonthName(7) != "Jul" ||
+        QDate::longMonthName(6) != "June" || QDate::longMonthName(7) != "July")
+        QSKIP("This test only works in English", SkipAll);
+
+    testWidget->setDisplayFormat("MMMM'a'MbMMMcMM");
+    testWidget->setDate(QDate(2005, 6, 1));
+    QCOMPARE(testWidget->text(), QString("Junea6bJunc06"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->text(), QString("Julya7bJulc07"));
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("July"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString());
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Right);
+    QTest::keyClick(testWidget, Qt::Key_Delete);
+    QTest::keyClick(testWidget, Qt::Key_Left);
+
+
+    QCOMPARE(testWidget->text(), QString("Jula7bJulc07"));
+    QTest::keyClick(testWidget, Qt::Key_Delete);
+    QCOMPARE(testWidget->text(), QString("Jua7bJulc07"));
+    QTest::keyClick(testWidget, Qt::Key_N);
+    QCOMPARE(testWidget->text(), QString("Juna7bJulc07"));
+    QTest::keyClick(testWidget, Qt::Key_E);
+    QCOMPARE(testWidget->text(), QString("Junea6bJunc06"));
+}
+
+void tst_QDateTimeEdit::newCase2()
+{
+    testWidget->setDisplayFormat("MMMM yyyy-MM-dd MMMM");
+    testWidget->setDate(QDate(2005, 8, 8));
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->text(), QString(" 2005-08-08 ") + QDate::longMonthName(8));
+}
+
+void tst_QDateTimeEdit::newCase3()
+{
+    if (!QDate::longMonthName(1).startsWith("Januar"))
+        QSKIP("This test does not work in this locale", SkipAll);
+
+    testWidget->setDisplayFormat("dd MMMM yyyy");
+    testWidget->setDate(QDate(2000, 1, 1));
+    testWidget->setGeometry(QRect(QPoint(0, 0), testWidget->sizeHint()));
+    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QTest::keyClick(testWidget, Qt::Key_J);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("01 J 2000"));
+    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 4);
+    QTest::keyClick(testWidget, Qt::Key_A);
+    QTest::keyClick(testWidget, Qt::Key_N);
+    QTest::keyClick(testWidget, Qt::Key_U);
+    QTest::keyClick(testWidget, Qt::Key_A);
+    QTest::keyClick(testWidget, Qt::Key_R);
+}
+
+
+void tst_QDateTimeEdit::cursorPos()
+{
+    if (QDate::longMonthName(1) != "January")
+        QSKIP("This test only works in English", SkipAll);
+
+    testWidget->setDisplayFormat("dd MMMM yyyy");
+    //testWidget->setGeometry(0, 0, 200, 200);
+    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 10);
+    QTest::keyClick(testWidget, Qt::Key_J);
+    QTest::keyClick(testWidget, Qt::Key_A);
+    QTest::keyClick(testWidget, Qt::Key_N);
+    QTest::keyClick(testWidget, Qt::Key_U);
+    QTest::keyClick(testWidget, Qt::Key_A);
+    QTest::keyClick(testWidget, Qt::Key_R);
+    //QCursor::setPos(20, 20);
+    //QEventLoop l;
+    //l.exec();
+    QTest::keyClick(testWidget, Qt::Key_Y);
+    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 11);
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QTest::keyClick(testWidget, Qt::Key_3);
+    QTest::keyClick(testWidget, Qt::Key_1);
+    QCOMPARE(testWidget->lineEdit()->cursorPosition(), 3);
+}
+
+void tst_QDateTimeEdit::newCase4()
+{
+    testWidget->setDisplayFormat("hh:mm");
+    testWidget->setMinimumTime(QTime(3, 3, 0));
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QTest::keyClick(testWidget, Qt::Key_0);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("0:03"));
+    QTest::keyClick(testWidget, Qt::Key_2);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("0:03"));
+    QTest::keyClick(testWidget, Qt::Key_4);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("04:03"));
+}
+
+void tst_QDateTimeEdit::newCase5()
+{
+    testWidget->setDisplayFormat("yyyy-MM-dd hh:mm:ss zzz 'ms'");
+    testWidget->setDateTime(QDateTime(QDate(2005, 10, 7), QTime(17, 44, 13, 100)));
+    testWidget->show();
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2005-10-07 17:44:13 100 ms"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Backtab, Qt::ShiftModifier);
+
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QTest::keyClick(testWidget, Qt::Key_1);
+    QTest::keyClick(testWidget, Qt::Key_2);
+    QTest::keyClick(testWidget, Qt::Key_4);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2005-10-07 17:44:13 124 ms"));
+
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2005-10-07 17:44:13 12 ms"));
+}
+
+void tst_QDateTimeEdit::newCase6()
+{
+    testWidget->setDisplayFormat("d-yyyy-MM-dd");
+    testWidget->setDate(QDate(2005, 10, 7));
+    testWidget->show();
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("7-2005-10-07"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QTest::keyClick(testWidget, Qt::Key_1);
+    QTest::keyClick(testWidget, Qt::Key_2);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("12-2005-10-12"));
+}
+
+
+void tst_QDateTimeEdit::task98554()
+{
+    testWidget->setDisplayFormat("mm.ss.zzz(ms)");
+    testWidget->setTime(QTime(0, 0, 9));
+    testWidget->setCurrentSection(QDateTimeEdit::SecondSection);
+    testWidget->show();
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00.09.000(09)"));
+    QCOMPARE(testWidget->time(), QTime(0, 0, 9, 0));
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00.10.000(010)"));
+    QCOMPARE(testWidget->time(), QTime(0, 0, 10, 0));
+}
+
+static QList<int> makeList(int val1, int val2 = -1, int val3 = -1, int val4 = -1, int val5 = -1, int val6 = -1, int val7 = -1)
+{
+    QList<int> ret;
+    Q_ASSERT(val1 >= 0);
+    ret << val1;
+    if (val2 < 0) {return ret;} else {ret << val2;}
+    if (val3 < 0) {return ret;} else {ret << val3;}
+    if (val4 < 0) {return ret;} else {ret << val4;}
+    if (val5 < 0) {return ret;} else {ret << val5;}
+    if (val6 < 0) {return ret;} else {ret << val6;}
+    if (val7 >= 0) {ret << val2;}
+    return ret;
+}
+
+
+void tst_QDateTimeEdit::setCurrentSection_data()
+{
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<QDateTime>("dateTime");
+    QTest::addColumn<QList<int> >("setCurrentSections");
+    QTest::addColumn<QList<int> >("expectedCursorPositions");
+
+    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))
+                         << makeList(QDateTimeEdit::DaySection, QDateTimeEdit::DaySection, QDateTimeEdit::DaySection)
+                         << makeList(24, 0, 24);
+    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))
+                           << makeList(QDateTimeEdit::MonthSection, QDateTimeEdit::MonthSection, QDateTimeEdit::MonthSection)
+                           << makeList(3, 26, 3);
+    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))
+                          << makeList(QDateTimeEdit::YearSection, QDateTimeEdit::YearSection, QDateTimeEdit::YearSection)
+                          << makeList(6, 28, 6);
+    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))
+                          << makeList(QDateTimeEdit::HourSection, QDateTimeEdit::HourSection, QDateTimeEdit::HourSection)
+                          << makeList(11, 31, 11);
+    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))
+                            << makeList(QDateTimeEdit::MinuteSection, QDateTimeEdit::MinuteSection, QDateTimeEdit::MinuteSection)
+                            << makeList(14, 33, 14);
+    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))
+                            << makeList(QDateTimeEdit::SecondSection, QDateTimeEdit::SecondSection, QDateTimeEdit::SecondSection)
+                            << makeList(17, 35, 17);
+    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))
+                          << makeList(QDateTimeEdit::MSecSection, QDateTimeEdit::MSecSection, QDateTimeEdit::MSecSection)
+                          << makeList(20, 37, 20);
+}
+
+void tst_QDateTimeEdit::setCurrentSection()
+{
+    QFETCH(QString, format);
+    QFETCH(QDateTime, dateTime);
+    QFETCH(QList<int>, setCurrentSections);
+    QFETCH(QList<int>, expectedCursorPositions);
+
+    Q_ASSERT(setCurrentSections.size() == expectedCursorPositions.size());
+    testWidget->setDisplayFormat(format);
+    testWidget->setDateTime(dateTime);
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+
+    testWidget->resize(400, 100);
+    for (int i=0; i<setCurrentSections.size(); ++i) {
+        testWidget->setCurrentSection((QDateTimeEdit::Section)setCurrentSections.at(i));
+        QCOMPARE(testWidget->currentSection(), (QDateTimeEdit::Section)setCurrentSections.at(i));
+        QCOMPARE(testWidget->lineEdit()->cursorPosition(), expectedCursorPositions.at(i));
+    }
+}
+
+
+void tst_QDateTimeEdit::setSelectedSection()
+{
+    testWidget->setDisplayFormat("mm.ss.zzz('ms') m");
+    testWidget->setTime(QTime(0, 0, 9));
+    testWidget->show();
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_Home);
+#endif
+    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
+    testWidget->setSelectedSection(QDateTimeEdit::MinuteSection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("00"));
+    testWidget->setCurrentSection(QDateTimeEdit::MinuteSection);
+    testWidget->setSelectedSection(QDateTimeEdit::MinuteSection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("0"));
+    testWidget->setSelectedSection(QDateTimeEdit::SecondSection);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("09"));
+    testWidget->setSelectedSection(QDateTimeEdit::NoSection);
+    QVERIFY(!testWidget->lineEdit()->hasSelectedText());
+}
+
+void tst_QDateTimeEdit::calendarPopup()
+{
+    {
+        QDateEdit edit;
+        QVERIFY(!edit.calendarWidget());
+        edit.setCalendarPopup(true);
+        QVERIFY(edit.calendarWidget());
+    }
+
+    {
+        QTimeEdit edit;
+        QVERIFY(!edit.calendarWidget());
+        edit.setCalendarPopup(true);
+        QVERIFY(!edit.calendarWidget());
+    }
+
+    {
+        QDateEdit edit;
+        QVERIFY(!edit.calendarWidget());
+        QCalendarWidget *cw = new QCalendarWidget;
+        edit.setCalendarWidget(cw);
+        QVERIFY(!edit.calendarWidget());
+        edit.setCalendarPopup(true);
+        edit.setCalendarWidget(cw);
+        QCOMPARE(edit.calendarWidget(), cw);
+        edit.setDateRange(QDate(1980, 1, 5), QDate(1980, 2, 11));
+        QCOMPARE(cw->minimumDate(), edit.minimumDate());
+        QCOMPARE(cw->maximumDate(), edit.maximumDate());
+        edit.setDate(QDate(1980, 1, 31));
+        QCOMPARE(edit.date(), cw->selectedDate());
+        cw->setSelectedDate(QDate(1980, 1, 30));
+        QCOMPARE(edit.date(), cw->selectedDate());
+    }
+
+    testWidget->setDisplayFormat("dd/MM/yyyy");
+    testWidget->setDateTime(QDateTime(QDate(2000, 1, 1), QTime(0, 0)));
+    testWidget->show();
+    testWidget->setCalendarPopup(true);
+    QCOMPARE(testWidget->calendarPopup(), true);
+    QStyle *style = testWidget->style();
+    QStyleOptionComboBox opt;
+    opt.initFrom(testWidget);
+    opt.editable = true;
+    opt.subControls = QStyle::SC_ComboBoxArrow;
+    QRect rect = style->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, testWidget);
+    QTest::mouseClick(testWidget, Qt::LeftButton, 0, QPoint(rect.left()+rect.width()/2, rect.top()+rect.height()/2));
+    QWidget *wid = qFindChild<QWidget *>(testWidget, "qt_datetimedit_calendar");
+    QVERIFY(wid != 0);
+    testWidget->hide();
+
+    QTimeEdit timeEdit;
+    timeEdit.setCalendarPopup(true);
+    timeEdit.show();
+
+    opt.initFrom(&timeEdit);
+    opt.subControls = QStyle::SC_ComboBoxArrow;
+    rect = style->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, &timeEdit);
+    QTest::mouseClick(&timeEdit, Qt::LeftButton, 0, QPoint(rect.left()+rect.width()/2, rect.top()+rect.height()/2));
+    QWidget *wid2 = qFindChild<QWidget *>(&timeEdit, "qt_datetimedit_calendar");
+    QVERIFY(wid2 == 0);
+    timeEdit.hide();
+
+
+    QDateEdit dateEdit;
+    dateEdit.setCalendarPopup(true);
+    dateEdit.setReadOnly(true);
+    dateEdit.show();
+
+    opt.initFrom(&dateEdit);
+    opt.subControls = QStyle::SC_ComboBoxArrow;
+    rect = style->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow, &dateEdit);
+    QTest::mouseClick(&dateEdit, Qt::LeftButton, 0, QPoint(rect.left()+rect.width()/2, rect.top()+rect.height()/2));
+    QWidget *wid3 = qFindChild<QWidget *>(&dateEdit, "qt_datetimedit_calendar");
+    QVERIFY(wid3 == 0);
+    dateEdit.hide();
+
+}
+
+class RestoreLayoutDirectioner
+{
+public:
+    RestoreLayoutDirectioner(Qt::LayoutDirection was)
+        : old(was)
+    {}
+
+    ~RestoreLayoutDirectioner()
+    {
+        QApplication::setLayoutDirection(old);
+    }
+private:
+    const Qt::LayoutDirection old;
+};
+
+void tst_QDateTimeEdit::reverseTest()
+{
+    const RestoreLayoutDirectioner restorer(QApplication::layoutDirection());
+    QApplication::setLayoutDirection(Qt::RightToLeft);
+    testWidget->setDisplayFormat("dd/MM/yyyy");
+    testWidget->setDate(QDate(2001, 3, 30));
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2001/03/30"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QCOMPARE(testWidget->currentSection(), QDateTimeEdit::DaySection);
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2001, 3, 31));
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("2001/03/31"));
+}
+
+
+void tst_QDateTimeEdit::hour12Test()
+{
+    testWidget->setDisplayFormat("hh a");
+    testWidget->setTime(QTime(0, 0, 0));
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("12 am"));
+    for (int i=0; i<11; ++i) {
+        QTest::keyClick(testWidget, Qt::Key_Up);
+    }
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 am"));
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("12 pm"));
+    for (int i=0; i<11; ++i) {
+        QTest::keyClick(testWidget, Qt::Key_Up);
+    }
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 pm"));
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 pm"));
+    for (int i=0; i<12; ++i) {
+        QTest::keyClick(testWidget, Qt::Key_Down);
+    }
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("11 am"));
+    QTest::keyClick(testWidget, Qt::Key_1);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("1 am"));
+    QTest::keyClick(testWidget, Qt::Key_3);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("1 am"));
+}
+
+void tst_QDateTimeEdit::yyTest()
+{
+    testWidget->setDisplayFormat("dd-MMM-yy");
+    testWidget->setTime(QTime(0, 0, 0));
+    testWidget->setDateRange(QDate(2005, 1, 1), QDate(2010, 12, 31));
+    testWidget->setDate(testWidget->minimumDate());
+    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
+
+    QString jan = QDate::shortMonthName(1);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-05");
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-06");
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-07");
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-08");
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-09");
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-10");
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-10");
+    testWidget->setWrapping(true);
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->lineEdit()->displayText(), "01-" + jan + "-05");
+
+    testWidget->setDateRange(QDate(100, 1, 1), QDate(8000, 12, 31));
+    testWidget->setDate(QDate(2000, 1, 1));
+    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
+    testWidget->setWrapping(false);
+    for (int i=0; i<10; ++i) {
+        for (int j=0; j<50; ++j) {
+            testWidget->stepBy(-1);
+        }
+        testWidget->stepBy(-50);
+        QCOMPARE(testWidget->sectionText(QDateTimeEdit::YearSection), QString("00"));
+        QCOMPARE(testWidget->date(), QDate(2000 - ((i + 1) * 100), 1, 1));
+    }
+}
+
+void tst_QDateTimeEdit::task108572()
+{
+    testWidget->setDisplayFormat("hh:mm:ss.zzz");
+    testWidget->setTime(QTime(0, 1, 2, 0));
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00:01:02.000"));
+
+    testWidget->setCurrentSection(QDateTimeEdit::MSecSection);
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("000"));
+    QTest::keyClick(testWidget, Qt::Key_2);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00:01:02.2"));
+    QTest::keyClick(testWidget, Qt::Key_Return);
+    QCOMPARE(testWidget->lineEdit()->displayText(), QString("00:01:02.200"));
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("200"));
+    QCOMPARE(testWidget->time(), QTime(0, 1, 2, 200));
+}
+
+void tst_QDateTimeEdit::task149097()
+{
+    QSignalSpy dtSpy(testWidget, SIGNAL(dateTimeChanged(const QDateTime &)));
+    QSignalSpy dSpy(testWidget, SIGNAL(dateChanged(const QDate &)));
+    QSignalSpy tSpy(testWidget, SIGNAL(timeChanged(const QTime &)));
+
+    testWidget->setDisplayFormat("yyyy/MM/dd hh:mm:ss");
+    testWidget->setDateTime(QDateTime(QDate(2001, 02, 03), QTime(5, 1, 2)));
+//    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(dtSpy.count(), 1);
+    QCOMPARE(dSpy.count(), 1);
+    QCOMPARE(tSpy.count(), 1);
+    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
+    testWidget->stepBy(1);
+
+    QCOMPARE(dtSpy.count(), 2);
+    QCOMPARE(dSpy.count(), 2);
+    QCOMPARE(tSpy.count(), 1);
+
+    testWidget->setCurrentSection(QDateTimeEdit::MinuteSection);
+    testWidget->stepBy(1);
+
+    QCOMPARE(dtSpy.count(), 3);
+    QCOMPARE(dSpy.count(), 2);
+    QCOMPARE(tSpy.count(), 2);
+}
+
+void tst_QDateTimeEdit::task148725()
+{
+    testWidget->setDisplayFormat("dd/MM");
+    testWidget->setDate(QDate(2001, 2, 27));
+    testWidget->stepBy(1);
+    QCOMPARE(testWidget->date(), QDate(2001, 2, 28));
+    testWidget->stepBy(1);
+    QCOMPARE(testWidget->date(), QDate(2001, 2, 28));
+    testWidget->setWrapping(true);
+    testWidget->stepBy(1);
+    QCOMPARE(testWidget->date(), QDate(2001, 2, 1));
+}
+
+void tst_QDateTimeEdit::task148522()
+{
+    QTimeEdit edit;
+    const QDateTime dt(QDate(2000, 12, 12), QTime(12, 13, 14, 15));
+    edit.setDateTime(dt);
+    QCOMPARE(edit.dateTime(), dt);
+}
+
+void tst_QDateTimeEdit::ddMMMMyyyy()
+{
+    testWidget->setDisplayFormat("dd.MMMM.yyyy");
+    testWidget->setDate(QDate(2000, 1, 1));
+    testWidget->setCurrentSection(QDateTimeEdit::YearSection);
+    QTest::keyClick(testWidget, Qt::Key_Enter);
+    QCOMPARE(testWidget->lineEdit()->selectedText(), QString("2000"));
+#ifdef Q_WS_MAC
+    QTest::keyClick(testWidget, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(testWidget, Qt::Key_End);
+#endif
+    QTest::keyClick(testWidget, Qt::Key_Backspace);
+    QCOMPARE(testWidget->lineEdit()->text(), "01." + QDate::longMonthName(1) + ".200");
+}
+
+void tst_QDateTimeEdit::wheelEvent()
+{
+    testWidget->setDisplayFormat("dddd/MM");
+    testWidget->setDate(QDate(2000, 2, 21));
+    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
+    QWheelEvent w(testWidget->lineEdit()->geometry().center(), 120, 0, 0);
+    qApp->sendEvent(testWidget, &w);
+    QCOMPARE(testWidget->date(), QDate(2000, 2, 22));
+    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
+    qApp->sendEvent(testWidget, &w);
+    QCOMPARE(testWidget->date(), QDate(2000, 3, 22));
+}
+
+void tst_QDateTimeEdit::specialValueCornerCase()
+{
+    // if you set minimum to value it won't update since value won't
+    // be bounded to anything. If you have a specialValueText it needs
+    // to call updateEdit to make sure the text is changed
+
+    QDateTimeEdit edit;
+    edit.setSpecialValueText("foobar");
+    edit.setMinimumDate(edit.date());
+    QCOMPARE(edit.minimumDate(), edit.date());
+    QCOMPARE(edit.text(), QString("foobar"));
+}
+
+void tst_QDateTimeEdit::cursorPositionOnInit()
+{
+    {
+        EditorDateEdit edit;
+        edit.setDisplayFormat("dd/MM");
+        edit.show();
+        QCOMPARE(edit.lineEdit()->cursorPosition(), 0);
+    }
+
+    {
+        EditorDateEdit edit;
+        edit.setDisplayFormat("dd/MM");
+        edit.setSpecialValueText("special");
+        edit.setMinimumDate(edit.date());
+        edit.show();
+        QCOMPARE(edit.lineEdit()->cursorPosition(), 7);
+        // ### legacy behavior. Keep it like this rather than changing
+        // ### but add a test none-the-less
+    }
+}
+
+void tst_QDateTimeEdit::task118867()
+{
+    EditorDateEdit edit;
+    edit.setDisplayFormat("hh:mm");
+    edit.setMinimumTime(QTime(5, 30));
+    edit.setMaximumTime(QTime(6, 30));
+    QCOMPARE(edit.text(), QString("05:30"));
+    edit.lineEdit()->setCursorPosition(5);
+    QTest::keyClick(&edit, Qt::Key_Backspace);
+    QCOMPARE(edit.text(), QString("05:3"));
+    QTest::keyClick(&edit, Qt::Key_Backspace);
+    QCOMPARE(edit.text(), QString("05:"));
+    QTest::keyClick(&edit, Qt::Key_1);
+    QCOMPARE(edit.text(), QString("05:"));
+    QTest::keyClick(&edit, Qt::Key_2);
+    QCOMPARE(edit.text(), QString("05:"));
+    QTest::keyClick(&edit, Qt::Key_3);
+    QCOMPARE(edit.text(), QString("05:3"));
+    QTest::keyClick(&edit, Qt::Key_3);
+    QCOMPARE(edit.text(), QString("05:33"));
+}
+
+void tst_QDateTimeEdit::nextPrevSection_data()
+{
+    QTest::addColumn<Qt::Key>("key");
+    QTest::addColumn<Qt::KeyboardModifiers>("modifiers");
+    QTest::addColumn<QString>("selectedText");
+
+    QTest::newRow("tab") << Qt::Key_Tab << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
+    QTest::newRow("backtab") << Qt::Key_Backtab << (Qt::KeyboardModifiers)Qt::NoModifier << QString("12");
+    QTest::newRow("shift-tab") << Qt::Key_Tab << (Qt::KeyboardModifiers)Qt::ShiftModifier << QString("12");
+    QTest::newRow("/") << Qt::Key_Slash << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
+    QTest::newRow("b") << Qt::Key_B << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
+    QTest::newRow("c") << Qt::Key_C << (Qt::KeyboardModifiers)Qt::NoModifier << QString("56");
+
+    // 1. mac doesn't do these,
+    // 2. some WinCE devices do not have modifiers
+#if !defined(Q_OS_MAC) && !defined(WINCE_NO_MODIFIER_KEYS)
+    QTest::newRow("ctrl-right") << Qt::Key_Right << (Qt::KeyboardModifiers)Qt::ControlModifier << QString("56");
+    QTest::newRow("ctrl-left") << Qt::Key_Left << (Qt::KeyboardModifiers)Qt::ControlModifier << QString("12");
+#endif
+}
+
+
+void tst_QDateTimeEdit::nextPrevSection()
+{
+    QFETCH(Qt::Key, key);
+    QFETCH(Qt::KeyboardModifiers, modifiers);
+    QFETCH(QString, selectedText);
+
+    EditorDateEdit edit;
+    edit.setDisplayFormat("hh/mm/bc9ss");
+    edit.setTime(QTime(12, 34, 56));
+    edit.setSelectedSection(QDateTimeEdit::MinuteSection);
+    edit.show();
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("34")); // selftest
+    QTest::keyClick(&edit, key, modifiers);
+    QCOMPARE(edit.lineEdit()->selectedText(), selectedText);
+}
+
+void tst_QDateTimeEdit::dateEditTimeEditFormats()
+{
+    QTimeEdit t;
+    t.setDisplayFormat("hh yyyy");
+    QCOMPARE(t.displayedSections(), QDateTimeEdit::HourSection);
+
+    QDateEdit d;
+    d.setDisplayFormat("hh yyyy");
+    QCOMPARE(d.displayedSections(), QDateTimeEdit::YearSection);
+}
+
+
+void tst_QDateTimeEdit::timeSpec_data()
+{
+    QTest::addColumn<bool>("useSetProperty");
+    QTest::newRow("setProperty") << true;
+    QTest::newRow("setTimeSpec") << false;
+}
+
+
+void tst_QDateTimeEdit::timeSpec()
+{
+    QFETCH(bool, useSetProperty);
+
+    QDateTimeEdit edit;
+    QCOMPARE(edit.dateTime().timeSpec(), edit.timeSpec());
+    QCOMPARE(edit.minimumDateTime().timeSpec(), edit.timeSpec());
+    QCOMPARE(edit.maximumDateTime().timeSpec(), edit.timeSpec());
+    if (useSetProperty) {
+        edit.setProperty("timeSpec", Qt::UTC);
+    } else {
+        edit.setTimeSpec(Qt::UTC);
+    }
+    QCOMPARE(edit.minimumDateTime().timeSpec(), edit.timeSpec());
+    QCOMPARE(edit.maximumDateTime().timeSpec(), edit.timeSpec());
+    QCOMPARE(edit.dateTime().timeSpec(), edit.timeSpec());
+    if (useSetProperty) {
+        edit.setProperty("timeSpec", Qt::LocalTime);
+    } else {
+        edit.setTimeSpec(Qt::LocalTime);
+    }
+    const QDateTime dt = edit.dateTime();
+    QCOMPARE(edit.timeSpec(), Qt::LocalTime);
+    const QDateTime utc = dt.toUTC();
+    if (dt.time() != utc.time()) {
+        const QDateTime min(QDate(1999, 1, 1), QTime(1, 0, 0), Qt::LocalTime);
+        edit.setMinimumDateTime(min);
+        QCOMPARE(edit.minimumTime(), min.time());
+        if (useSetProperty) {
+            edit.setProperty("timeSpec", Qt::UTC);
+        } else {
+            edit.setTimeSpec(Qt::UTC);
+        }
+        QVERIFY(edit.minimumTime() != min.time());
+        QVERIFY(edit.minimumDateTime().timeSpec() != min.timeSpec());
+        QCOMPARE(edit.minimumDateTime().toTime_t(), min.toTime_t());
+    } else {
+        QSKIP("Not tested in the GMT timezone", SkipAll);
+    }
+}
+
+void tst_QDateTimeEdit::timeSpecBug()
+{
+    testWidget->setTimeSpec(Qt::UTC);
+    testWidget->setDisplayFormat("hh:mm");
+    testWidget->setTime(QTime(2, 2));
+    const QString oldText = testWidget->text();
+    const QDateTime oldDateTime = testWidget->dateTime();
+    QTest::keyClick(testWidget, Qt::Key_Tab);
+    QCOMPARE(oldDateTime, testWidget->dateTime());
+    QCOMPARE(oldText, testWidget->text());
+}
+
+
+void tst_QDateTimeEdit::cachedDayTest()
+{
+    testWidget->setDisplayFormat("MM/dd");
+    testWidget->setDate(QDate(2007, 1, 30));
+    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
+    //QTest::keyClick(testWidget->lineEdit(), Qt::Key_Up); // this doesn't work
+    //on Mac. QTestLib bug? ###
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2007, 2, 28));
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2007, 3, 31));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2007, 2, 28));
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2007, 1, 31));
+
+    testWidget->setCurrentSection(QDateTimeEdit::DaySection);
+    QTest::keyClick(testWidget, Qt::Key_Down);
+    QCOMPARE(testWidget->date(), QDate(2007, 1, 30));
+    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2007, 2, 28));
+    testWidget->setCurrentSection(QDateTimeEdit::MonthSection);
+    QTest::keyClick(testWidget, Qt::Key_Up);
+    QCOMPARE(testWidget->date(), QDate(2007, 3, 30));
+
+}
+
+void tst_QDateTimeEdit::monthEdgeCase()
+{
+    EditorDateEdit edit;
+    edit.setLocale(QLocale("fr_FR"));
+    edit.setDisplayFormat("MMM d");
+    edit.setDate(QDate(2000, 1, 1));
+    QCOMPARE(edit.text(), QString("janv. 1"));
+    edit.lineEdit()->setCursorPosition(5);
+    QTest::keyClick(&edit, Qt::Key_Backspace);
+    QCOMPARE(edit.text(), QString("janv 1"));
+}
+
+class RestoreLocaler
+{
+public:
+    RestoreLocaler()
+        : old(QLocale())
+    {}
+
+    ~RestoreLocaler()
+    {
+        QLocale::setDefault(old);
+    }
+private:
+    const QLocale old;
+};
+
+
+
+
+void tst_QDateTimeEdit::setLocale()
+{
+    RestoreLocaler r;
+    QLocale::setDefault(QLocale("en_US"));
+    {
+        EditorDateEdit edit;
+        edit.setDisplayFormat("MMMM d");
+        edit.setDate(QDate(2000, 1, 1));
+        QCOMPARE(edit.text(), QString("January 1"));
+    }
+    QLocale::setDefault(QLocale("no_NO"));
+    {
+        EditorDateEdit edit;
+        edit.setDisplayFormat("MMMM d");
+        edit.setDate(QDate(2000, 1, 1));
+        QCOMPARE(edit.text().toLower(), QString("januar 1"));
+        // I get Januar on Mac and januar on linux
+    }
+    QLocale::setDefault(QLocale("en_US"));
+    {
+        EditorDateEdit edit;
+        edit.setDisplayFormat("MMMM d");
+        edit.setDate(QDate(2000, 1, 1));
+        QCOMPARE(edit.text(), QString("January 1"));
+        edit.setLocale(QLocale("no_NO"));
+        QCOMPARE(edit.text().toLower(), QString("januar 1"));
+        edit.setLocale(QLocale("no_NO"));
+    }
+}
+
+
+void tst_QDateTimeEdit::potentialYYValueBug()
+{
+    EditorDateEdit edit;
+    edit.setDisplayFormat("dd/MM/yy");
+    QCOMPARE(edit.minimumDate(), QDate(1752, 9, 14));
+    edit.setDate(edit.minimumDate());
+    edit.lineEdit()->setFocus();
+
+#ifdef Q_WS_MAC
+    QTest::keyClick(&edit, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(&edit, Qt::Key_End);
+#endif
+    QTest::keyClick(&edit, Qt::Key_Backspace);
+    QCOMPARE(edit.text(), QString("14/09/5"));
+}
+
+void tst_QDateTimeEdit::textSectionAtEnd()
+{
+    EditorDateEdit edit;
+    edit.setDisplayFormat("MMMM");
+    edit.setDate(QDate(2000, 1, 1));
+    edit.lineEdit()->setFocus();
+#ifdef Q_WS_MAC
+    QTest::keyClick(&edit, Qt::Key_Right, Qt::ControlModifier);
+#else
+    QTest::keyClick(&edit, Qt::Key_End);
+#endif
+    QTest::keyClick(&edit, Qt::Key_Backspace);
+    QCOMPARE(edit.text(), QString("Januar"));
+}
+
+void tst_QDateTimeEdit::keypadAutoAdvance_data()
+{
+    QTest::addColumn<Qt::KeyboardModifiers>("modifiers");
+    QTest::newRow("None") << (Qt::KeyboardModifiers)Qt::NoModifier;
+    QTest::newRow("Keypad") << (Qt::KeyboardModifiers)Qt::KeypadModifier;
+}
+
+
+void tst_QDateTimeEdit::keypadAutoAdvance()
+{
+    QFETCH(Qt::KeyboardModifiers, modifiers);
+
+    EditorDateEdit edit;
+    edit.setDate(QDate(2000, 2, 1));
+    edit.setDisplayFormat("dd/MM");
+#ifdef Q_WS_MAC
+    QTest::keyClick(&edit, Qt::Key_Left, Qt::ControlModifier);
+#else
+    QTest::keyClick(&edit, Qt::Key_Home);
+#endif
+    QTest::keyClick(&edit, Qt::Key_Return);
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("01"));
+    QTest::keyClick(&edit, Qt::Key_1, modifiers);
+    QTest::keyClick(&edit, Qt::Key_2, modifiers);
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("02"));
+}
+
+
+void tst_QDateTimeEdit::task196924()
+{
+    EditorDateEdit edit;
+    edit.setDisplayFormat("dd/M/yyyy");
+    edit.setDate(QDate(2345, 6, 17));
+    QCOMPARE(edit.text(), QString("17/6/2345"));
+    QTest::keyClick(&edit, Qt::Key_Tab);
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("6"));
+    QTest::keyClick(&edit, Qt::Key_3);
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("2345"));
+    QCOMPARE(edit.text(), QString("17/3/2345"));
+
+    edit.setDisplayFormat("dd/MM/yyyy");
+    edit.setDate(QDate(2345, 6, 17));
+    edit.lineEdit()->setCursorPosition(0);
+    QCOMPARE(edit.text(), QString("17/06/2345"));
+    QTest::keyClick(&edit, Qt::Key_Tab);
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("06"));
+    QTest::keyClick(&edit, Qt::Key_3);
+    QCOMPARE(edit.lineEdit()->selectedText(), QString("2345"));
+    QCOMPARE(edit.text(), QString("17/03/2345"));
+
+}
+
+void tst_QDateTimeEdit::focusNextPrevChild()
+{
+    EditorDateEdit edit;
+    edit.setDisplayFormat("dd/MM/yyyy");
+
+    edit.show();
+    edit.setFocus();
+    edit.setCurrentSection(QDateTimeEdit::DaySection);
+
+    QCOMPARE(edit.currentSection(), QDateTimeEdit::DaySection);
+    edit.focusNextPrevChild(true);
+    QCOMPARE(edit.currentSection(), QDateTimeEdit::MonthSection);
+}
+
+
+
+QTEST_MAIN(tst_QDateTimeEdit)
+#include "tst_qdatetimeedit.moc"