summaryrefslogtreecommitdiffstats
path: root/tests/auto/q3timeedit
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/q3timeedit')
-rw-r--r--tests/auto/q3timeedit/.gitignore1
-rw-r--r--tests/auto/q3timeedit/q3timeedit.pro6
-rw-r--r--tests/auto/q3timeedit/tst_q3timeedit.cpp939
3 files changed, 946 insertions, 0 deletions
diff --git a/tests/auto/q3timeedit/.gitignore b/tests/auto/q3timeedit/.gitignore
new file mode 100644
index 0000000..8a76046
--- /dev/null
+++ b/tests/auto/q3timeedit/.gitignore
@@ -0,0 +1 @@
+tst_q3timeedit
diff --git a/tests/auto/q3timeedit/q3timeedit.pro b/tests/auto/q3timeedit/q3timeedit.pro
new file mode 100644
index 0000000..17b4a84
--- /dev/null
+++ b/tests/auto/q3timeedit/q3timeedit.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+SOURCES += tst_q3timeedit.cpp
+QT += qt3support
+
+
+
diff --git a/tests/auto/q3timeedit/tst_q3timeedit.cpp b/tests/auto/q3timeedit/tst_q3timeedit.cpp
new file mode 100644
index 0000000..967bb51
--- /dev/null
+++ b/tests/auto/q3timeedit/tst_q3timeedit.cpp
@@ -0,0 +1,939 @@
+/****************************************************************************
+**
+** 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 <q3datetimeedit.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=qt3support/text/q3textedit.h qt3support/text/q3textedit.cpp
+
+class tst_Q3TimeEdit : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_Q3TimeEdit();
+ virtual ~tst_Q3TimeEdit();
+
+
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+ void init();
+ void cleanup();
+private slots:
+ void valueRange_data();
+ void valueRange(); // Need a better name for this function
+
+ void userKeyPress_AMPM_data();
+ void userKeyPress_AMPM();
+
+private:
+ Q3TimeEdit* testWidget;
+};
+
+Q_DECLARE_METATYPE(QTime)
+
+/*
+ NOTE.
+ Q3TimeEdit has a really strange behaviour IMO.
+ This testcase tests that behaviour, which is totally different from what I
+ would expect or what I like.
+
+ In Q3TimeEdit...
+ - the hour, minutes, seconds or AMPM have 'full' focus.
+ - you don't get a blinking cursor.
+ - you can't backspace or delete one digit from the value.
+ - pressing backspace or delete 'resets' the hour to 0 (in 24 hour mode) or to
+ 12 (in 12 hour mode).
+ - pressing backspace or delete 'resets' the minute to 0 (in both modes).
+ - when you fast type two digits these are entered into the field that has the focus:
+ example: entering 1 and then 2 results in '12' being entered into the hour field.
+ - if you fast enter an invalid value, e.g. 2 and the 5 (in the hour field) only the
+ 2 is shown, and the 5 is ignored.
+ - if you enter a 2, then wait for 2 seconds and then enter 5 then first the 2 is shown
+ and then replaced by the 5. The 2 seconds is a timeout value. After that Q3TimeEdit
+ assumes you start a new editing session and apparantly want to replace the contents
+ of the focused field with something new. AGAIN.. this is a totally different behaviour
+ from what I would expect, but it's the behaviour.
+*/
+
+tst_Q3TimeEdit::tst_Q3TimeEdit()
+{
+}
+
+tst_Q3TimeEdit::~tst_Q3TimeEdit()
+{
+
+}
+
+void tst_Q3TimeEdit::initTestCase()
+{
+ testWidget = new Q3TimeEdit(0, "testWidget");
+ testWidget->show();
+ qApp->setActiveWindow(testWidget);
+ qApp->setMainWidget(testWidget);
+ QTest::qWait(100);
+}
+
+void tst_Q3TimeEdit::cleanupTestCase()
+{
+ delete testWidget;
+}
+
+void tst_Q3TimeEdit::init()
+{
+ QTime minimumTime(0, 0, 0);
+ QTime maximumTime(23, 59, 59);
+ testWidget->setMinValue(minimumTime);
+ testWidget->setMaxValue(maximumTime);
+#if QT_VERSION >= 0x030100
+ // We don't want the locale impacting on the test
+ testWidget->setDisplay(Q3TimeEdit::Hours | Q3TimeEdit::Minutes | Q3TimeEdit::Seconds);
+#endif
+ testWidget->setTime(QTime(11, 0, 0));
+
+ // make sure we start with the hour focused
+ QWidget *editBase = qFindChild<QWidget*>(testWidget, "time edit base");
+ QTest::keyClick(editBase, Qt::Key_Left);
+ QTest::keyClick(editBase, Qt::Key_Left);
+ QTest::keyClick(editBase, Qt::Key_Left);
+}
+
+void tst_Q3TimeEdit::cleanup()
+{
+}
+
+void tst_Q3TimeEdit::valueRange_data()
+{
+ QTest::addColumn<int>("minimumHours");
+ QTest::addColumn<int>("minimumMinutes");
+ QTest::addColumn<int>("minimumSeconds");
+ QTest::addColumn<int>("maximumHours");
+ QTest::addColumn<int>("maximumMinutes");
+ QTest::addColumn<int>("maximumSeconds");
+
+ QTest::newRow("data0") << 0 << 0 << 0 << 2 << 2 << 2;
+}
+
+
+void tst_Q3TimeEdit::valueRange()
+{
+ QFETCH(int, minimumHours);
+ QFETCH(int, minimumMinutes);
+ QFETCH(int, minimumSeconds);
+ QFETCH(int, maximumHours);
+ QFETCH(int, maximumMinutes);
+ QFETCH(int, maximumSeconds);
+
+// Q3TimeEdit timeEdit(0);
+ QTime minimumTime(minimumHours, minimumMinutes, minimumSeconds);
+ QTime maximumTime(maximumHours, maximumMinutes, maximumSeconds);
+ testWidget->setMinValue(minimumTime);
+ testWidget->setMaxValue(maximumTime);
+#if QT_VERSION >= 0x030100
+ // We don't want the locale impacting on the test
+ testWidget->setDisplay(Q3TimeEdit::Hours | Q3TimeEdit::Minutes | Q3TimeEdit::Seconds);
+#endif
+
+ // When pressing Key_Up we want to check it goes to the minimum time
+ testWidget->setTime(maximumTime);
+
+ QKeyEvent ke(QEvent::KeyPress, Qt::Key_Up, 0, Qt::NoButton);
+
+ // We need to say focusWidget() because the focus is inside the widget in the Q3TimeEdit which
+ // Q3TimeEdit doesn't allow us to access directly.
+
+ testWidget->setFocus();
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ QCOMPARE(testWidget->time().hour(), minimumHours);
+
+ // When pressing Key_Down we want to check it goes to the maximum time
+ testWidget->setTime(minimumTime);
+
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ QCOMPARE(testWidget->time().hour(), maximumHours);
+
+ // Now we test the minutes
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Right, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ testWidget->setTime(maximumTime);
+
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Up, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ QCOMPARE(testWidget->time().minute(), minimumMinutes);
+
+ testWidget->setTime(minimumTime);
+
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ QCOMPARE(testWidget->time().minute(), maximumMinutes);
+
+ // Now we test the seconds
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Right, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ testWidget->setTime(maximumTime);
+
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Up, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ QCOMPARE(testWidget->time().second(), minimumSeconds);
+
+ testWidget->setTime(minimumTime);
+
+ ke = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, 0, Qt::NoButton);
+ QApplication::sendEvent(qApp->focusWidget(), &ke);
+ QCOMPARE(testWidget->time().second(), maximumSeconds);
+}
+
+void tst_Q3TimeEdit::userKeyPress_AMPM_data()
+{
+ QTest::addColumn<QTime>("start_time");
+ QTest::addColumn<bool>("ampm");
+ QTest::addColumn<QTestEventList>("keys");
+ QTest::addColumn<QTime>("expected_time");
+
+ int time_delay = 4100;
+
+ // ***************** test backspace ***************
+
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Backspace);
+ QTime expected(20, 0, 0);
+ QTest::newRow("backspace sec: hh value: 12") << QTime(12, 0, 0) << bool(true) << keys << expected;
+ }
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Backspace);
+ keys.addKeyClick(Qt::Key_Backspace);
+ QTime expected(0, 0, 0);
+ QTest::newRow("backspace x 2 sec: hh value: 12") << QTime(12, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // ***************** test delete ***************
+
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Delete);
+ QTime expected(1, 0, 0);
+ QTest::newRow("delete sec: hh value: 12") << QTime(12, 0, 0) << bool(true) << keys << expected;
+ }
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Delete);
+ keys.addKeyClick(Qt::Key_Delete);
+ QTime expected(0, 0, 0);
+ QTest::newRow("delete x 2 sec: hh value: 12") << QTime(12, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // ***************** 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("1") << QTime(11, 0, 0) << 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("2") << QTime(11, 0, 0) << 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("3") << QTime(11, 0, 0) << 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("4") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(12, 0, 0);
+ QTest::newRow("5") << QTime(11, 0, 0) << 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("6") << QTime(11, 0, 0) << 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("7") << QTime(11, 0, 0) << 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("8") << QTime(11, 0, 0) << 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("9") << QTime(11, 0, 0) << 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("10") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(12, 0, 0);
+ QTest::newRow("11") << QTime(11, 0, 0) << 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("12") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // enter a one digit valid hour
+ {
+ QTestEventList keys;
+ keys.addKeyClick('5');
+ QTime expected(5, 0, 0);
+ QTest::newRow("13") << QTime(11, 0, 0) << 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("14") << QTime(11, 0, 0) << 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("15") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // enter a value, change your mind and enter a new one
+ {
+ QTestEventList keys;
+ keys.addKeyClick('2');
+ keys.addDelay(time_delay);
+ keys.addKeyClick('1');
+ QTime expected(1, 0, 0);
+ QTest::newRow("16") << QTime(11, 0, 0) << 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("17") << QTime(11, 0, 0) << 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("18") << QTime(11, 0, 0) << 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("19") << QTime(11, 0, 0) << 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("20") << QTime(11, 0, 0) << 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("21") << QTime(11, 0, 0) << 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_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 2, 0);
+ QTest::newRow("22") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test a valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<16; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 16, 0);
+ QTest::newRow("23") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test maximum value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<59; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 59, 0);
+ QTest::newRow("24") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test 'overflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<60; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 0);
+ QTest::newRow("25") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test 'underflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 59, 0);
+ QTest::newRow("26") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 58, 0);
+ QTest::newRow("27") << QTime(11, 0, 0) << 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_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 2, 0);
+ QTest::newRow("28") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test a valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Left);
+ keys.addKeyClick(Qt::Key_Left);
+ keys.addKeyClick(Qt::Key_Left);
+ keys.addKeyClick(Qt::Key_Left);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<16; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 16, 0);
+ QTest::newRow("29") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test maximum value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<59; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 59, 0);
+ QTest::newRow("30") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test 'overflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<60; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 0);
+ QTest::newRow("31") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test 'underflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 59, 0);
+ QTest::newRow("32") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 58, 0);
+ QTest::newRow("33") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // enter a valid one digit minute in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ QTime expected(11, 2, 0);
+ QTest::newRow("34") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // enter a valid two digit minutes in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ keys.addKeyClick('4');
+ QTime expected(11, 24, 0);
+ QTest::newRow("35") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // check the lower limit of the minutes in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("36") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // check the upper limit of the minutes in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('5');
+ keys.addKeyClick('9');
+ QTime expected(11, 59, 0);
+ QTest::newRow("37") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // enter an invalid two digit minutes in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('6');
+ // '60' is invalid, so I would expect the '0' to be ignored...
+ // but the edit is reset to '0'
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("38") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // test minutes 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_Right);
+ keys.addKeyClick('2');
+ QTime expected(11, 2, 0);
+ QTest::newRow("39") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // enter a valid two digit minutes in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ keys.addKeyClick('4');
+ QTime expected(11, 24, 0);
+ QTest::newRow("40") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // check the lower limit of the minutes in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("41") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // check the upper limit of the minutes in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('5');
+ keys.addKeyClick('9');
+ QTime expected(11, 59, 0);
+ QTest::newRow("42") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // enter an invalid two digit minutes in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('6');
+ // '60' is invalid, so I would expect the '0' to be ignored...
+ // but the edit is reset to '0'
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("43") << QTime(11, 0, 0) << 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_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 2);
+ QTest::newRow("44") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test a valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<16; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 16);
+ QTest::newRow("45") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test maximum value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<59; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 59);
+ QTest::newRow("46") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test 'overflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<60; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 0);
+ QTest::newRow("47") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test 'underflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 0, 59);
+ QTest::newRow("48") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ { // test valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 0, 58);
+ QTest::newRow("49") << QTime(11, 0, 0) << 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_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 2);
+ QTest::newRow("50") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test a valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<16; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 16);
+ QTest::newRow("51") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test maximum value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<59; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 59);
+ QTest::newRow("52") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test 'overflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<60; i++)
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(11, 0, 0);
+ QTest::newRow("53") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test 'underflow'
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 0, 59);
+ QTest::newRow("54") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+ { // test valid value
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ for (uint i=0; i<2; i++)
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 0, 58);
+ QTest::newRow("55") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ /////////////////
+ // enter a valid one digit second in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ QTime expected(11, 0, 2);
+ QTest::newRow("56") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // enter a valid two digit seconds in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ keys.addKeyClick('4');
+ QTime expected(11, 0, 24);
+ QTest::newRow("57") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // check the lower limit of the seconds in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("58") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // check the upper limit of the seconds in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('5');
+ keys.addKeyClick('9');
+ QTime expected(11, 0, 59);
+ QTest::newRow("59") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+
+ // enter an invalid two digit seconds in 12 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('6');
+ // '60' is invalid, so I would expect the '0' to be ignored...
+ // but the edit is reset to '0'
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("60") << QTime(11, 0, 0) << 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_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ QTime expected(11, 0, 2);
+ QTest::newRow("61") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // enter a valid two digit seconds in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('2');
+ keys.addKeyClick('4');
+ QTime expected(11, 0, 24);
+ QTest::newRow("62") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // check the lower limit of the seconds in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("63") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // check the upper limit of the seconds in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('5');
+ keys.addKeyClick('9');
+ QTime expected(11, 0, 59);
+ QTest::newRow("64") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // enter an invalid two digit seconds in 24 h mode
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick('6');
+ // '60' is invalid, so I would expect the '0' to be ignored...
+ // but the edit is reset to '0'
+ keys.addKeyClick('0');
+ QTime expected(11, 0, 0);
+ QTest::newRow("65") << QTime(11, 0, 0) << bool(false) << keys << expected;
+ }
+
+ // Test the AMPM indicator
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Up);
+ QTime expected(23, 0, 0);
+ QTest::newRow("66") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ // Test the AMPM indicator
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(23, 0, 0);
+ QTest::newRow("67") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ // Test the AMPM indicator
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Down);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 0, 0);
+ QTest::newRow("68") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+ // Test the AMPM indicator
+ {
+ QTestEventList keys;
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Right);
+ keys.addKeyClick(Qt::Key_Up);
+ keys.addKeyClick(Qt::Key_Down);
+ QTime expected(11, 0, 0);
+ QTest::newRow("69") << QTime(11, 0, 0) << bool(true) << keys << expected;
+ }
+}
+
+void tst_Q3TimeEdit::userKeyPress_AMPM()
+{
+ // READ THE NOTE AT THE TOP FIRST!!!!!
+
+ QFETCH(QTime, start_time);
+ QFETCH(QTestEventList, keys);
+ QFETCH(QTime, expected_time);
+ QFETCH(bool, ampm);
+
+ if (ampm)
+ testWidget->setDisplay(Q3TimeEdit::Hours | Q3TimeEdit::Minutes | Q3TimeEdit::Seconds | Q3TimeEdit::AMPM);
+ else
+ testWidget->setDisplay(Q3TimeEdit::Hours | Q3TimeEdit::Minutes | Q3TimeEdit::Seconds);
+ testWidget->setTime(start_time);
+ keys.simulate(qFindChild<QWidget*>(testWidget, "time edit base"));
+ QCOMPARE(testWidget->time(), expected_time);
+}
+
+
+QTEST_MAIN(tst_Q3TimeEdit)
+#include "tst_q3timeedit.moc"
generated by cgit v0.12 at 2024-12-29 10:12:34 (GMT)