diff options
Diffstat (limited to 'tests/auto/corelib/time')
23 files changed, 4428 insertions, 2630 deletions
diff --git a/tests/auto/corelib/time/CMakeLists.txt b/tests/auto/corelib/time/CMakeLists.txt index b099b32469..1fb95e9245 100644 --- a/tests/auto/corelib/time/CMakeLists.txt +++ b/tests/auto/corelib/time/CMakeLists.txt @@ -1,8 +1,12 @@ -# Generated from time.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause add_subdirectory(qcalendar) add_subdirectory(qdate) add_subdirectory(qdatetime) +if(QT_FEATURE_datetimeparser) + add_subdirectory(qdatetimeparser) +endif() add_subdirectory(qtime) if(QT_FEATURE_timezone) add_subdirectory(qtimezone) diff --git a/tests/auto/corelib/time/qcalendar/CMakeLists.txt b/tests/auto/corelib/time/qcalendar/CMakeLists.txt index 12365467fb..5b1b2dfc2a 100644 --- a/tests/auto/corelib/time/qcalendar/CMakeLists.txt +++ b/tests/auto/corelib/time/qcalendar/CMakeLists.txt @@ -1,10 +1,19 @@ -# Generated from qcalendar.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qcalendar Test: ##################################################################### -qt_add_test(tst_qcalendar +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qcalendar LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qcalendar SOURCES tst_qcalendar.cpp + LIBRARIES + Qt::CorePrivate ) diff --git a/tests/auto/corelib/time/qcalendar/qcalendar.pro b/tests/auto/corelib/time/qcalendar/qcalendar.pro deleted file mode 100644 index 94e8fe8606..0000000000 --- a/tests/auto/corelib/time/qcalendar/qcalendar.pro +++ /dev/null @@ -1,5 +0,0 @@ -CONFIG += testcase -TARGET = tst_qcalendar -QT = core testlib -SOURCES = \ - tst_qcalendar.cpp diff --git a/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp b/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp index 5da69e76a5..61999202d2 100644 --- a/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp +++ b/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp @@ -1,34 +1,10 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include <QtTest/QtTest> +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QTest> #include <QCalendar> +#include <private/qgregoriancalendar_p.h> Q_DECLARE_METATYPE(QCalendar::System) class tst_QCalendar : public QObject @@ -47,8 +23,57 @@ private slots: void specific(); void daily_data() { basic_data(); } void daily(); + void testYearMonthDate(); + void properties_data(); + void properties(); + void aliases(); + + void gregory(); }; +static void checkCenturyResolution(const QCalendar &cal, const QCalendar::YearMonthDay &base) +{ + quint8 weekDayMask = 0; + for (int offset = -7; offset < 8; ++offset) { + const auto probe = QDate(base.year, base.month, base.day, cal).addYears(100 * offset, cal); + const int dow = cal.dayOfWeek(probe); + if (probe.isValid() && dow > 0 && dow < 8) + weekDayMask |= 1 << quint8(dow - 1); + } + for (int j = 1; j < 8; ++j) { + const bool seen = weekDayMask & (1 << quint8(j - 1)); + const QDate check = cal.matchCenturyToWeekday(base, j); + if (check.isValid()) { + const auto parts = cal.partsFromDate(check); + const int dow = cal.dayOfWeek(check); + QCOMPARE(dow, j); + QCOMPARE(parts.day, base.day); + QCOMPARE(parts.month, base.month); + int gap = parts.year - base.year; + if (!cal.hasYearZero() && (parts.year > 0) != (base.year > 0)) + gap += parts.year > 0 ? -1 : +1; + auto report = qScopeGuard([parts, base]() { + qDebug("Wrongly matched year: %d replaced %d", parts.year, base.year); + }); + QCOMPARE(gap % 100, 0); + // We searched 7 centuries each side of base. + if (seen) { + QCOMPARE_LT(gap / 100, 8); + QCOMPARE_GT(gap / 100, -8); + } else { + QVERIFY(gap / 100 >= 8 || gap / 100 <= -8); + } + report.dismiss(); + } else { + auto report = qScopeGuard([j, base]() { + qDebug("Missed dow[%d] for %d/%d/%d", j, base.year, base.month, base.day); + }); + QVERIFY(!seen); + report.dismiss(); + } + } +} + // Support for basic(): void tst_QCalendar::checkYear(const QCalendar &cal, int year, bool normal) { @@ -57,14 +82,17 @@ void tst_QCalendar::checkYear(const QCalendar &cal, int year, bool normal) QVERIFY(moons > 0); QVERIFY(!cal.isDateValid(year, moons + 1, 1)); QVERIFY(!cal.isDateValid(year, 0, 1)); + QVERIFY(!QDate(year, 0, 1, cal).isValid()); QVERIFY(moons <= cal.maximumMonthsInYear()); + QCOMPARE(cal.standaloneMonthName(QLocale::c(), moons + 1, year), QString()); + QCOMPARE(cal.monthName(QLocale::c(), 0, year), QString()); const int days = cal.daysInYear(year); QVERIFY(days > 0); int sum = 0; const int longest = cal.maximumDaysInMonth(); - for (int i = moons; i > 0; i--) { + for (int i = moons; i > 0; --i) { const int last = cal.daysInMonth(i, year); sum += last; // Valid month has some days and no more than max: @@ -77,6 +105,10 @@ void tst_QCalendar::checkYear(const QCalendar &cal, int year, bool normal) QVERIFY(!cal.isDateValid(year, i, last + 1)); if (normal) // Unspecified year gets same daysInMonth(): QCOMPARE(cal.daysInMonth(i), last); + + checkCenturyResolution(cal, {year, i, (last + 1) / 2}); + if (QTest::currentTestFailed()) + return; } // Months add up to the whole year: QCOMPARE(sum, days); @@ -118,6 +150,7 @@ void tst_QCalendar::basic() QCOMPARE(cal.monthsInYear(0), 0); QCOMPARE(cal.daysInYear(0), 0); QVERIFY(!cal.isDateValid(0, 1, 1)); + QVERIFY(!QDate(0, 1, 1, cal).isValid()); } if (cal.isProleptic()) { @@ -177,6 +210,7 @@ void tst_QCalendar::specific_data() { QTest::addColumn<QCalendar::System>("system"); // Date in that system: + QTest::addColumn<QString>("monthName"); QTest::addColumn<int>("sysyear"); QTest::addColumn<int>("sysmonth"); QTest::addColumn<int>("sysday"); @@ -185,26 +219,27 @@ void tst_QCalendar::specific_data() QTest::addColumn<int>("gregmonth"); QTest::addColumn<int>("gregday"); -#define ADDROW(cal, year, month, day, gy, gm, gd) \ - QTest::newRow(#cal) << QCalendar::System::cal << year << month << day << gy << gm << gd +#define ADDROW(cal, monthName, year, month, day, gy, gm, gd) \ + QTest::newRow(#cal) << QCalendar::System::cal << QStringLiteral(monthName) \ + << year << month << day << gy << gm << gd - ADDROW(Gregorian, 1970, 1, 1, 1970, 1, 1); + ADDROW(Gregorian, "January", 1970, 1, 1, 1970, 1, 1); // One known specific date, for each calendar #ifndef QT_BOOTSTRAPPED // Julian 1582-10-4 was followed by Gregorian 1582-10-15 - ADDROW(Julian, 1582, 10, 4, 1582, 10, 14); + ADDROW(Julian, "October", 1582, 10, 4, 1582, 10, 14); // Milankovic matches Gregorian for a few centuries - ADDROW(Milankovic, 1923, 3, 20, 1923, 3, 20); + ADDROW(Milankovic, "March", 1923, 3, 20, 1923, 3, 20); #endif #if QT_CONFIG(jalalicalendar) // Jalali year 1355 started on Gregorian 1976-3-21: - ADDROW(Jalali, 1355, 1, 1, 1976, 3, 21); + ADDROW(Jalali, "Farvardin", 1355, 1, 1, 1976, 3, 21); #endif // jalali #if QT_CONFIG(islamiccivilcalendar) // TODO: confirm this is correct - ADDROW(IslamicCivil, 1, 1, 1, 622, 7, 19); + ADDROW(IslamicCivil, "Muharram", 1, 1, 1, 622, 7, 19); #endif #undef ADDROW @@ -213,6 +248,7 @@ void tst_QCalendar::specific_data() void tst_QCalendar::specific() { QFETCH(QCalendar::System, system); + QFETCH(const QString, monthName); QFETCH(int, sysyear); QFETCH(int, sysmonth); QFETCH(int, sysday); @@ -221,6 +257,7 @@ void tst_QCalendar::specific() QFETCH(int, gregday); const QCalendar cal(system); + QCOMPARE(cal.monthName(QLocale::c(), sysmonth), monthName); const QDate date(sysyear, sysmonth, sysday, cal), gregory(gregyear, gregmonth, gregday); QCOMPARE(date, gregory); QCOMPARE(gregory.year(cal), sysyear); @@ -255,5 +292,163 @@ void tst_QCalendar::daily() } } +void tst_QCalendar::testYearMonthDate() +{ + QCalendar::YearMonthDay defYMD; + QCOMPARE(defYMD.year, QCalendar::Unspecified); + QCOMPARE(defYMD.month, QCalendar::Unspecified); + QCOMPARE(defYMD.day, QCalendar::Unspecified); + + QCalendar::YearMonthDay ymd2020(2020); + QCOMPARE(ymd2020.year, 2020); + QCOMPARE(ymd2020.month, 1); + QCOMPARE(ymd2020.day, 1); + + QVERIFY(!QCalendar::YearMonthDay( + QCalendar::Unspecified, QCalendar::Unspecified, QCalendar::Unspecified).isValid()); + QVERIFY(!QCalendar::YearMonthDay( + QCalendar::Unspecified, QCalendar::Unspecified, 1).isValid()); + QVERIFY(!QCalendar::YearMonthDay( + QCalendar::Unspecified, 1, QCalendar::Unspecified).isValid()); + QVERIFY(QCalendar::YearMonthDay( + QCalendar::Unspecified, 1, 1).isValid()); + QVERIFY(!QCalendar::YearMonthDay( + 2020, QCalendar::Unspecified, QCalendar::Unspecified).isValid()); + QVERIFY(!QCalendar::YearMonthDay( + 2020, QCalendar::Unspecified, 1).isValid()); + QVERIFY(!QCalendar::YearMonthDay( + 2020, 1, QCalendar::Unspecified).isValid()); + QVERIFY(QCalendar::YearMonthDay( + 2020, 1, 1).isValid()); +} + +void tst_QCalendar::properties_data() +{ + QTest::addColumn<QCalendar::System>("system"); + QTest::addColumn<bool>("gregory"); + QTest::addColumn<bool>("lunar"); + QTest::addColumn<bool>("luniSolar"); + QTest::addColumn<bool>("solar"); + QTest::addColumn<bool>("proleptic"); + QTest::addColumn<bool>("yearZero"); + QTest::addColumn<int>("monthMax"); + QTest::addColumn<int>("monthMin"); + QTest::addColumn<int>("yearMax"); + QTest::addColumn<QString>("name"); + + QTest::addRow("Gregorian") + << QCalendar::System::Gregorian << true << false << false << true << true << false + << 31 << 28 << 12 << QStringLiteral("Gregorian"); +#ifndef QT_BOOTSTRAPPED + QTest::addRow("Julian") + << QCalendar::System::Julian << false << false << false << true << true << false + << 31 << 28 << 12 << QStringLiteral("Julian"); + QTest::addRow("Milankovic") + << QCalendar::System::Milankovic << false << false << false << true << true << false + << 31 << 28 << 12 << QStringLiteral("Milankovic"); +#endif + +#if QT_CONFIG(jalalicalendar) + QTest::addRow("Jalali") + << QCalendar::System::Jalali << false << false << false << true << true << false + << 31 << 29 << 12 << QStringLiteral("Jalali"); +#endif +#if QT_CONFIG(islamiccivilcalendar) + QTest::addRow("IslamicCivil") + << QCalendar::System::IslamicCivil << false << true << false << false << true << false + << 30 << 29 << 12 << QStringLiteral("Islamic Civil"); +#endif +} + +void tst_QCalendar::properties() +{ + QFETCH(const QCalendar::System, system); + QFETCH(const bool, gregory); + QFETCH(const bool, lunar); + QFETCH(const bool, luniSolar); + QFETCH(const bool, solar); + QFETCH(const bool, proleptic); + QFETCH(const bool, yearZero); + QFETCH(const int, monthMax); + QFETCH(const int, monthMin); + QFETCH(const int, yearMax); + QFETCH(const QString, name); + + const QCalendar cal(system); + QCOMPARE(cal.isGregorian(), gregory); + QCOMPARE(cal.isLunar(), lunar); + QCOMPARE(cal.isLuniSolar(), luniSolar); + QCOMPARE(cal.isSolar(), solar); + QCOMPARE(cal.isProleptic(), proleptic); + QCOMPARE(cal.hasYearZero(), yearZero); + QCOMPARE(cal.maximumDaysInMonth(), monthMax); + QCOMPARE(cal.minimumDaysInMonth(), monthMin); + QCOMPARE(cal.maximumMonthsInYear(), yearMax); + QCOMPARE(cal.name(), name); +} + +void tst_QCalendar::aliases() +{ + QCOMPARE(QCalendar(u"gregory").name(), u"Gregorian"); +#if QT_CONFIG(jalalicalendar) + QCOMPARE(QCalendar(u"Persian").name(), u"Jalali"); +#endif +#if QT_CONFIG(islamiccivilcalendar) + // Exercise all constructors from name, while we're at it: + QCOMPARE(QCalendar(u"islamic-civil").name(), u"Islamic Civil"); + QCOMPARE(QCalendar(QLatin1String("islamic")).name(), u"Islamic Civil"); + QCOMPARE(QCalendar(QStringLiteral("Islamic")).name(), u"Islamic Civil"); +#endif + + // Invalid is handled gracefully: + QCOMPARE(QCalendar(u"").name(), QString()); + QCOMPARE(QCalendar(QCalendar::System::User).name(), QString()); +} + +void tst_QCalendar::gregory() +{ + // Test QGregorianCalendar's internal-use methods. + + // Julian day number 0 is in 4713; and reach past the end of four-digit years: + for (int year = -4720; year < 12345; ++year) { + // Test yearStartWeekDay() and yearSharingWeekDays() are consistent with + // dateToJulianDay() and weekDayOfJulian(): + if (!year) // No year zero. + continue; + const auto first = QGregorianCalendar::julianFromParts(year, 1, 1); + QVERIFY2(first, "Only year zero should lack a first day"); + QCOMPARE(QGregorianCalendar::yearStartWeekDay(year), + QGregorianCalendar::weekDayOfJulian(*first)); + const auto last = QGregorianCalendar::julianFromParts(year, 12, 31); + QVERIFY2(last, "Only year zero should lack a last day"); + + const int lastTwo = (year + (year < 0 ? 1 : 0)) % 100 + (year < -1 ? 100 : 0); + const QDate probe(year, lastTwo && lastTwo <= 12 ? lastTwo : 8, + lastTwo <= 31 && lastTwo > 12 ? lastTwo : 17); + const int match = QGregorianCalendar::yearSharingWeekDays(probe); + // A post-epoch year, no later than 2400 (implies four-digit): + QVERIFY(match >= 1970); + QVERIFY(match <= 2400); + // Either that's the year we started with or: + if (match != year) { + // Its last two digits can't be mistaken for month or day: + QVERIFY(match % 100 != probe.month()); + QVERIFY(match % 100 != probe.day()); + // If that wasn't in danger of happening, with year positive, they match lastTwo: + if (year > 0 && lastTwo > 31) + QCOMPARE(match % 100, lastTwo); + // Its first and last days of the year match those of year: + auto day = QGregorianCalendar::julianFromParts(match, 1, 1); + QVERIFY(day); + QCOMPARE(QGregorianCalendar::weekDayOfJulian(*day), + QGregorianCalendar::weekDayOfJulian(*first)); + day = QGregorianCalendar::julianFromParts(match, 12, 31); + QVERIFY(day); + QCOMPARE(QGregorianCalendar::weekDayOfJulian(*day), + QGregorianCalendar::weekDayOfJulian(*last)); + } + } +} + QTEST_APPLESS_MAIN(tst_QCalendar) #include "tst_qcalendar.moc" diff --git a/tests/auto/corelib/time/qdate/CMakeLists.txt b/tests/auto/corelib/time/qdate/CMakeLists.txt index 484ea08a7a..4d0f04a967 100644 --- a/tests/auto/corelib/time/qdate/CMakeLists.txt +++ b/tests/auto/corelib/time/qdate/CMakeLists.txt @@ -1,15 +1,23 @@ -# Generated from qdate.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qdate Test: ##################################################################### -qt_add_test(tst_qdate +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qdate LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qdate SOURCES tst_qdate.cpp DEFINES QT_NO_FOREACH QT_NO_KEYWORDS - PUBLIC_LIBRARIES + LIBRARIES Qt::CorePrivate + Qt::TestPrivate ) diff --git a/tests/auto/corelib/time/qdate/qdate.pro b/tests/auto/corelib/time/qdate/qdate.pro deleted file mode 100644 index 087cf8856c..0000000000 --- a/tests/auto/corelib/time/qdate/qdate.pro +++ /dev/null @@ -1,5 +0,0 @@ -CONFIG += testcase -TARGET = tst_qdate -QT = core-private testlib -SOURCES = tst_qdate.cpp -DEFINES += QT_NO_KEYWORDS QT_NO_FOREACH diff --git a/tests/auto/corelib/time/qdate/tst_qdate.cpp b/tests/auto/corelib/time/qdate/tst_qdate.cpp index 30917c8cfd..5b715e8c55 100644 --- a/tests/auto/corelib/time/qdate/tst_qdate.cpp +++ b/tests/auto/corelib/time/qdate/tst_qdate.cpp @@ -1,36 +1,27 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Copyright (C) 2016 Intel Corporation. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2022 The Qt Company Ltd. +// Copyright (C) 2016 Intel Corporation. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QDateTime> +#include <QTest> + +#include <QLocale> +#include <QMap> +#include <QTimeZone> #include <private/qglobal_p.h> // for the icu feature test -#include <QtTest/QtTest> -#include <qdatetime.h> -#include <qlocale.h> +#include <private/qcomparisontesthelper_p.h> +#include <private/qdatetime_p.h> +#if !QT_CONFIG(timezone) +# include <private/qtenvironmentvariables_p.h> // for qTzName() +#endif + +using namespace QtPrivate::DateTimeConstants; +using namespace Qt::StringLiterals; + +#if defined(Q_OS_WIN) && !QT_CONFIG(icu) +# define USING_WIN_TZ +#endif class tst_QDate : public QObject { @@ -55,10 +46,8 @@ private Q_SLOTS: void weekNumber_invalid(); void weekNumber_data(); void weekNumber(); -#if QT_CONFIG(timezone) void startOfDay_endOfDay_data(); void startOfDay_endOfDay(); -#endif void startOfDay_endOfDay_fixed_data(); void startOfDay_endOfDay_fixed(); void startOfDay_endOfDay_bounds(); @@ -70,12 +59,12 @@ private Q_SLOTS: void addYears_data(); void addYears(); void daysTo(); + void orderingCompiles(); void operator_eq_eq_data(); void operator_eq_eq(); - void operator_lt(); - void operator_gt(); - void operator_lt_eq(); - void operator_gt_eq(); + void ordering_data(); + void ordering(); + void ordering_chrono_types(); void operator_insert_extract_data(); void operator_insert_extract(); #if QT_CONFIG(datestring) @@ -101,6 +90,15 @@ private Q_SLOTS: void qdebug() const; private: QDate defDate() const { return QDate(1900, 1, 1); } + + QDate epochDate() const { + using namespace QtPrivate::DateTimeConstants; + Q_ASSERT(JULIAN_DAY_FOR_EPOCH == QDate(1970, 1, 1).toJulianDay()); + return QDate::fromJulianDay(JULIAN_DAY_FOR_EPOCH); + } + + static constexpr qint64 minJd = JulianDayMin; + static constexpr qint64 maxJd = JulianDayMax; QDate invalidDate() const { return QDate(); } }; @@ -111,9 +109,6 @@ void tst_QDate::isNull_data() QTest::addColumn<qint64>("jd"); QTest::addColumn<bool>("null"); - qint64 minJd = Q_INT64_C(-784350574879); - qint64 maxJd = Q_INT64_C( 784354017364); - QTest::newRow("qint64 min") << std::numeric_limits<qint64>::min() << true; QTest::newRow("minJd - 1") << minJd - 1 << true; QTest::newRow("minJd") << minJd << false; @@ -197,6 +192,32 @@ void tst_QDate::isValid_data() QTest::newRow("jd latest formula") << 1400000 << 12 << 31 << qint64(513060925) << true; } +#if __cpp_lib_chrono >= 201907L +// QDate has a bigger range than year_month_date. The tests use this bigger +// range. However building a year_month_time with "out of range" data has +// unspecified results, so don't do that. See [time.cal.year], +// [time.cal.month], [time.cal.day]. Also, std::chrono::year has a year 0, so +// take that into account. +static std::optional<std::chrono::year_month_day> convertToStdYearMonthDay(int y, int m, int d) +{ + using namespace std::chrono; + + if (y >= int((year::min)()) + && y <= int((year::max)()) + && m >= 0 + && m <= 255 + && d >= 0 + && d <= 255) + { + if (y < 0) + ++y; + return std::make_optional(year(y) / m / d); + } + + return std::nullopt; +} +#endif + void tst_QDate::isValid() { QFETCH(int, year); @@ -216,6 +237,19 @@ void tst_QDate::isValid() QCOMPARE(d.year(), year); QCOMPARE(d.month(), month); QCOMPARE(d.day(), day); +#if __cpp_lib_chrono >= 201907L + std::optional<std::chrono::year_month_day> ymd = convertToStdYearMonthDay(year, month, day); + if (ymd) { + QDate d = *ymd; + QCOMPARE(d.year(), year); + QCOMPARE(d.month(), month); + QCOMPARE(d.day(), day); + + const std::chrono::sys_days qdateSysDays = d.toStdSysDays(); + const std::chrono::sys_days ymdSysDays = *ymd; + QCOMPARE(qdateSysDays, ymdSysDays); + } +#endif } else { QCOMPARE(d.year(), 0); QCOMPARE(d.month(), 0); @@ -462,113 +496,178 @@ void tst_QDate::weekNumber_invalid() QCOMPARE( dt.weekNumber( &yearNumber ), 0 ); } -#if QT_CONFIG(timezone) +/* The MS backend tends to lack data for historical transitions. So some of the + transition-based tests will get wrong results, that we can't do anything + about, when using that backend. Rather than complicating the #if-ery more, + overtly record, in a flags column, which we need to ignore and merely make + the testing of these flags subject to #if-ery. + + Android appears to lack at least one other. +*/ +enum BackendKludge { IgnoreStart = 1, IgnoreEnd = 2, }; +Q_DECLARE_FLAGS(BackendKludges, BackendKludge) +Q_DECLARE_OPERATORS_FOR_FLAGS(BackendKludges) + void tst_QDate::startOfDay_endOfDay_data() { QTest::addColumn<QDate>("date"); // Typically a spring-forward. // A zone in which that date's start and end are worth checking: - QTest::addColumn<QByteArray>("zoneName"); + QTest::addColumn<QTimeZone>("zone"); // The start and end times in that zone: QTest::addColumn<QTime>("start"); QTest::addColumn<QTime>("end"); - - const QTime initial(0, 0), final(23, 59, 59, 999), invalid(QDateTime().time()); - - QTest::newRow("epoch") - << QDate(1970, 1, 1) << QByteArray("UTC") - << initial << final; - QTest::newRow("Brazil") - << QDate(2008, 10, 19) << QByteArray("America/Sao_Paulo") - << QTime(1, 0) << final; -#if QT_CONFIG(icu) || !defined(Q_OS_WIN) // MS's TZ APIs lack data - QTest::newRow("Sofia") - << QDate(1994, 3, 27) << QByteArray("Europe/Sofia") - << QTime(1, 0) << final; + // Ignored for backends that don't need it: + QTest::addColumn<BackendKludges>("kludge"); + + const QTime early(0, 0), late(23, 59, 59, 999), invalid(QDateTime().time()); + constexpr BackendKludges Clean = {}; + constexpr BackendKludges IgnoreBoth = IgnoreStart | IgnoreEnd; +#ifdef USING_WIN_TZ + constexpr BackendKludges MsNoStart = IgnoreStart; + constexpr BackendKludges MsNoBoth = IgnoreBoth; +#else + constexpr BackendKludges MsNoStart = Clean; + constexpr BackendKludges MsNoBoth = Clean; + // And use IgnoreBoth directly for the one transition Android lacks. #endif - QTest::newRow("Kiritimati") - << QDate(1994, 12, 31) << QByteArray("Pacific/Kiritimati") - << invalid << invalid; - QTest::newRow("Samoa") - << QDate(2011, 12, 30) << QByteArray("Pacific/Apia") - << invalid << invalid; - // TODO: find other zones with transitions at/crossing midnight. + const QTimeZone UTC(QTimeZone::UTC); + + using Bound = std::numeric_limits<qint64>; + const auto dateAtMillis = [UTC](qint64 millis) { + return QDateTime::fromMSecsSinceEpoch(millis, UTC).date(); + }; + + // UTC and fixed offset are always available and predictable: + QTest::newRow("epoch") << epochDate() << UTC << early << late << Clean; + + // First and last days in QDateTime's supported range: + QTest::newRow("earliest") + << dateAtMillis(Bound::min()) << UTC << invalid << late << Clean; + QTest::newRow("latest") + << dateAtMillis(Bound::max()) << UTC << early << invalid << Clean; + + const struct { + const char *test; + const char *zone; + const QDate day; + const QTime start; + const QTime end; + const BackendKludges msOpt; + } transitions[] = { + // The western Mexico time-zones skipped the first hour of 1970. + { "BajaMexico", "America/Hermosillo", QDate(1970, 1, 1), QTime(1, 0), late, MsNoStart }, + + // Compare tst_QDateTime::fromStringDateFormat(ISO 24:00 in DST). + { "Brazil", "America/Sao_Paulo", QDate(2008, 10, 19), QTime(1, 0), late, Clean }, + + // Several southern zones within EET (but not the northern ones) spent + // part of the 1990s using midnight as spring transition. + { "Sofia", "Europe/Sofia", QDate(1994, 3, 27), QTime(1, 0), late, MsNoStart }, + + // Two Pacific zones skipped days to get on the west of the + // International Date Line; those days have neither start nor end. + { "Kiritimati", "Pacific/Kiritimati", QDate(1994, 12, 31), invalid, invalid, IgnoreBoth }, + { "Samoa", "Pacific/Apia", QDate(2011, 12, 30), invalid, invalid, MsNoBoth }, + + // TODO: find other zones with transitions at/crossing midnight. + }; + const QTimeZone local = QTimeZone::LocalTime; + +#if QT_CONFIG(timezone) + const QTimeZone sys = QTimeZone::systemTimeZone(); + QVERIFY2(sys.isValid(), "Test depends on properly configured system"); + for (const auto &tran : transitions) { + if (QTimeZone zone(tran.zone); zone.isValid()) { + QTest::newRow(tran.test) + << tran.day << zone << tran.start << tran.end << tran.msOpt; + if (zone == sys) { + QTest::addRow("Local=%s", tran.test) + << tran.day << local << tran.start << tran.end << tran.msOpt; + } + } + } +#else + const auto isLocalZone = [](const char *zone) { + const QLatin1StringView name(zone); + for (int i = 0; i < 2; ++i) { + if (qTzName(i) == name) + return true; + } + return false; + }; + for (const auto &tran : transitions) { + if (isLocalZone(tran.zone)) { // Might need a different name to match + QTest::addRow("Local=%s", tran.test) + << tran.day << local << tran.start << tran.end << tran.msOpt; + } + } +#endif // timezone } void tst_QDate::startOfDay_endOfDay() { - QFETCH(QDate, date); - QFETCH(QByteArray, zoneName); - QFETCH(QTime, start); - QFETCH(QTime, end); - const QTimeZone zone(zoneName); - const bool isSystem = QTimeZone::systemTimeZone() == zone; + QFETCH(const QDate, date); + QFETCH(const QTimeZone, zone); + QFETCH(const QTime, start); + QFETCH(const QTime, end); +#if defined(USING_WIN_TZ) || defined(Q_OS_ANDROID) // Coping with backend limitations. + QFETCH(const BackendKludges, kludge); +#define UNLESSKLUDGE(flag) if (!kludge.testFlag(flag)) +#else +#define UNLESSKLUDGE(flag) +#endif + QVERIFY(zone.isValid()); + QDateTime front(date.startOfDay(zone)), back(date.endOfDay(zone)); if (end.isValid()) QCOMPARE(date.addDays(1).startOfDay(zone).addMSecs(-1), back); if (start.isValid()) QCOMPARE(date.addDays(-1).endOfDay(zone).addMSecs(1), front); - do { // Avoids duplicating these tests for local-time when it *is* zone: - if (start.isValid()) { - QCOMPARE(front.date(), date); - QCOMPARE(front.time(), start); - } - if (end.isValid()) { - QCOMPARE(back.date(), date); - QCOMPARE(back.time(), end); - } - if (front.timeSpec() == Qt::LocalTime) - break; - front = date.startOfDay(Qt::LocalTime); - back = date.endOfDay(Qt::LocalTime); - } while (isSystem); - if (end.isValid()) - QCOMPARE(date.addDays(1).startOfDay(Qt::LocalTime).addMSecs(-1), back); - if (start.isValid()) - QCOMPARE(date.addDays(-1).endOfDay(Qt::LocalTime).addMSecs(1), front); - if (!isSystem) { - // These might fail if system zone coincides with zone; but only if it - // did something similarly unusual on the date picked for this test. - if (start.isValid()) { - QCOMPARE(front.date(), date); - QCOMPARE(front.time(), QTime(0, 0)); - } - if (end.isValid()) { - QCOMPARE(back.date(), date); - QCOMPARE(back.time(), QTime(23, 59, 59, 999)); - } + + if (start.isValid()) { + QVERIFY(front.isValid()); + QCOMPARE(front.date(), date); + UNLESSKLUDGE(IgnoreStart) QCOMPARE(front.time(), start); + } else UNLESSKLUDGE(IgnoreStart) { + auto report = qScopeGuard([front]() { qDebug() << "Start of day:" << front; }); + QVERIFY(!front.isValid()); + report.dismiss(); } + if (end.isValid()) { + QVERIFY(back.isValid()); + QCOMPARE(back.date(), date); + UNLESSKLUDGE(IgnoreEnd) QCOMPARE(back.time(), end); + } else UNLESSKLUDGE(IgnoreEnd) { + auto report = qScopeGuard([back]() { qDebug() << "End of day:" << back; }); + QVERIFY(!back.isValid()); + report.dismiss(); + } +#undef UNLESSKLUDGE } -#endif // timezone void tst_QDate::startOfDay_endOfDay_fixed_data() { + QTest::addColumn<QDate>("date"); + const qint64 kilo(1000); using Bounds = std::numeric_limits<qint64>; - const QDateTime - first(QDateTime::fromMSecsSinceEpoch(Bounds::min() + 1, Qt::UTC)), - start32sign(QDateTime::fromMSecsSinceEpoch(-0x80000000L * kilo, Qt::UTC)), - end32sign(QDateTime::fromMSecsSinceEpoch(0x80000000L * kilo, Qt::UTC)), - end32unsign(QDateTime::fromMSecsSinceEpoch(0x100000000L * kilo, Qt::UTC)), - last(QDateTime::fromMSecsSinceEpoch(Bounds::max(), Qt::UTC)); - - const struct { - const char *name; - QDate date; - } data[] = { - { "epoch", QDate(1970, 1, 1) }, - { "y2k-leap-day", QDate(2000, 2, 29) }, - // Just outside the start and end of 32-bit time_t: - { "pre-sign32", QDate(start32sign.date().year(), 1, 1) }, - { "post-sign32", QDate(end32sign.date().year(), 12, 31) }, - { "post-uint32", QDate(end32unsign.date().year(), 12, 31) }, - // Just inside the start and end of QDateTime's range: - { "first-full", first.date().addDays(1) }, - { "last-full", last.date().addDays(-1) } - }; - - QTest::addColumn<QDate>("date"); - for (const auto &r : data) - QTest::newRow(r.name) << r.date; + const auto UTC = QTimeZone::UTC; + const QDateTime first(QDateTime::fromMSecsSinceEpoch(Bounds::min() + 1, UTC)); + const QDateTime start32sign(QDateTime::fromMSecsSinceEpoch(Q_INT64_C(-0x80000000) * kilo, UTC)); + const QDateTime end32sign(QDateTime::fromMSecsSinceEpoch(Q_INT64_C(0x80000000) * kilo, UTC)); + const QDateTime end32unsign(QDateTime::fromMSecsSinceEpoch(Q_INT64_C(0x100000000) * kilo, UTC)); + const QDateTime last(QDateTime::fromMSecsSinceEpoch(Bounds::max(), UTC)); + + QTest::newRow("epoch") << epochDate(); + QTest::newRow("y2k-leap-day") << QDate(2000, 2, 29); + QTest::newRow("start-1900") << QDate(1900, 1, 1); // QTBUG-99747 + // Just outside the start and end of 32-bit time_t: + QTest::newRow("pre-sign32") << QDate(start32sign.date().year(), 1, 1); + QTest::newRow("post-sign32") << QDate(end32sign.date().year(), 12, 31); + QTest::newRow("post-uint32") << QDate(end32unsign.date().year(), 12, 31); + // Just inside the start and end of QDateTime's range: + QTest::newRow("first-full") << first.date().addDays(1); + QTest::newRow("last-full") << last.date().addDays(-1); } void tst_QDate::startOfDay_endOfDay_fixed() @@ -576,56 +675,79 @@ void tst_QDate::startOfDay_endOfDay_fixed() const QTime early(0, 0), late(23, 59, 59, 999); QFETCH(QDate, date); - QDateTime start(date.startOfDay(Qt::UTC)); - QDateTime end(date.endOfDay(Qt::UTC)); + QDateTime start(date.startOfDay(QTimeZone::UTC)); + QDateTime end(date.endOfDay(QTimeZone::UTC)); QCOMPARE(start.date(), date); QCOMPARE(end.date(), date); QCOMPARE(start.time(), early); QCOMPARE(end.time(), late); - QCOMPARE(date.addDays(1).startOfDay(Qt::UTC).addMSecs(-1), end); - QCOMPARE(date.addDays(-1).endOfDay(Qt::UTC).addMSecs(1), start); + QCOMPARE(date.addDays(1).startOfDay(QTimeZone::UTC).addMSecs(-1), end); + QCOMPARE(date.addDays(-1).endOfDay(QTimeZone::UTC).addMSecs(1), start); for (int offset = -60 * 16; offset <= 60 * 16; offset += 65) { - start = date.startOfDay(Qt::OffsetFromUTC, offset); - end = date.endOfDay(Qt::OffsetFromUTC, offset); + const auto zone = QTimeZone::fromSecondsAheadOfUtc(offset); + start = date.startOfDay(zone); + end = date.endOfDay(zone); QCOMPARE(start.date(), date); QCOMPARE(end.date(), date); QCOMPARE(start.time(), early); QCOMPARE(end.time(), late); - QCOMPARE(date.addDays(1).startOfDay(Qt::OffsetFromUTC, offset).addMSecs(-1), end); - QCOMPARE(date.addDays(-1).endOfDay(Qt::OffsetFromUTC, offset).addMSecs(1), start); + QCOMPARE(date.addDays(1).startOfDay(zone).addMSecs(-1), end); + QCOMPARE(date.addDays(-1).endOfDay(zone).addMSecs(1), start); + } + + // Minimal testing for LocalTime and TimeZone + QCOMPARE(date.startOfDay().date(), date); + QCOMPARE(date.endOfDay().date(), date); +#if QT_CONFIG(timezone) + const QTimeZone cet("Europe/Oslo"); + if (cet.isValid()) { + QCOMPARE(date.startOfDay(cet).date(), date); + QCOMPARE(date.endOfDay(cet).date(), date); } +#endif } void tst_QDate::startOfDay_endOfDay_bounds() { // Check the days in which QDateTime's range starts and ends: using Bounds = std::numeric_limits<qint64>; + const auto UTC = QTimeZone::UTC; const QDateTime - first(QDateTime::fromMSecsSinceEpoch(Bounds::min(), Qt::UTC)), - last(QDateTime::fromMSecsSinceEpoch(Bounds::max(), Qt::UTC)), - epoch(QDateTime::fromMSecsSinceEpoch(0, Qt::UTC)); + first(QDateTime::fromMSecsSinceEpoch(Bounds::min(), UTC)), + last(QDateTime::fromMSecsSinceEpoch(Bounds::max(), UTC)), + epoch(QDateTime::fromMSecsSinceEpoch(0, UTC)); // First, check these *are* the start and end of QDateTime's range: QVERIFY(first.isValid()); QVERIFY(last.isValid()); QVERIFY(first < epoch); QVERIFY(last > epoch); - // QDateTime's addMSecs doesn't check against {und,ov}erflow ... QVERIFY(!first.addMSecs(-1).isValid() || first.addMSecs(-1) > first); QVERIFY(!last.addMSecs(1).isValid() || last.addMSecs(1) < last); // Now test start/end methods with them: - QCOMPARE(first.date().endOfDay(Qt::UTC).time(), QTime(23, 59, 59, 999)); - QCOMPARE(last.date().startOfDay(Qt::UTC).time(), QTime(0, 0)); - QVERIFY(!first.date().startOfDay(Qt::UTC).isValid()); - QVERIFY(!last.date().endOfDay(Qt::UTC).isValid()); + QCOMPARE(first.date().endOfDay(UTC).time(), QTime(23, 59, 59, 999)); + QCOMPARE(last.date().startOfDay(UTC).time(), QTime(0, 0)); + QVERIFY(!first.date().startOfDay(UTC).isValid()); + QVERIFY(!last.date().endOfDay(UTC).isValid()); + + // Test for QTBUG-100873, shouldn't assert: + const QDate qdteMin(1752, 9, 14); // Used by QDateTimeEdit + QCOMPARE(qdteMin.startOfDay(UTC).date(), qdteMin); + QCOMPARE(qdteMin.startOfDay().date(), qdteMin); +#if QT_CONFIG(timezone) + const QTimeZone sys = QTimeZone::systemTimeZone(); + QVERIFY2(sys.isValid(), "Test depends on properly configured system"); + QCOMPARE(qdteMin.startOfDay(sys).date(), qdteMin); + QTimeZone berlin("Europe/Berlin"); + if (berlin.isValid()) + QCOMPARE(qdteMin.startOfDay(berlin).date(), qdteMin); +#endif } void tst_QDate::julianDaysLimits() { qint64 min = std::numeric_limits<qint64>::min(); qint64 max = std::numeric_limits<qint64>::max(); - qint64 minJd = Q_INT64_C(-784350574879); - qint64 maxJd = Q_INT64_C( 784354017364); QDate maxDate = QDate::fromJulianDay(maxJd); QDate minDate = QDate::fromJulianDay(minJd); @@ -693,11 +815,19 @@ void tst_QDate::addDays() QFETCH( int, expectedDay ); QDate dt( year, month, day ); - dt = dt.addDays( amountToAdd ); + QDate dt2 = dt.addDays( amountToAdd ); - QCOMPARE( dt.year(), expectedYear ); - QCOMPARE( dt.month(), expectedMonth ); - QCOMPARE( dt.day(), expectedDay ); + QCOMPARE( dt2.year(), expectedYear ); + QCOMPARE( dt2.month(), expectedMonth ); + QCOMPARE( dt2.day(), expectedDay ); + +#if __cpp_lib_chrono >= 201907L + QDate dt3 = dt.addDuration( std::chrono::days( amountToAdd ) ); + + QCOMPARE( dt3.year(), expectedYear ); + QCOMPARE( dt3.month(), expectedMonth ); + QCOMPARE( dt3.day(), expectedDay ); +#endif } void tst_QDate::addDays_data() @@ -840,9 +970,6 @@ void tst_QDate::addYears_data() void tst_QDate::daysTo() { - qint64 minJd = Q_INT64_C(-784350574879); - qint64 maxJd = Q_INT64_C( 784354017364); - QDate dt1(2000, 1, 1); QDate dt2(2000, 1, 5); QCOMPARE(dt1.daysTo(dt2), (qint64) 4); @@ -867,6 +994,17 @@ void tst_QDate::daysTo() QCOMPARE(zeroDate.daysTo(minDate), minJd); } +void tst_QDate::orderingCompiles() +{ + QTestPrivate::testAllComparisonOperatorsCompile<QDate>(); +#if __cpp_lib_chrono >= 201907L + QTestPrivate::testAllComparisonOperatorsCompile<QDate, std::chrono::year_month_day>(); + QTestPrivate::testAllComparisonOperatorsCompile<QDate, std::chrono::year_month_day_last>(); + QTestPrivate::testAllComparisonOperatorsCompile<QDate, std::chrono::year_month_weekday>(); + QTestPrivate::testAllComparisonOperatorsCompile<QDate, std::chrono::year_month_weekday_last>(); +#endif +} + void tst_QDate::operator_eq_eq_data() { QTest::addColumn<QDate>("d1"); @@ -903,137 +1041,83 @@ void tst_QDate::operator_eq_eq() QFETCH(QDate, d2); QFETCH(bool, expectEqual); - bool equal = d1 == d2; - QCOMPARE(equal, expectEqual); - bool notEqual = d1 != d2; - QCOMPARE(notEqual, !expectEqual); + QT_TEST_EQUALITY_OPS(d1, d2, expectEqual); - if (equal) + if (expectEqual) QVERIFY(qHash(d1) == qHash(d2)); } -void tst_QDate::operator_lt() +void tst_QDate::ordering_data() { - QDate d1(2000,1,2); - QDate d2(2000,1,2); - QVERIFY( !(d1 < d2) ); - - d1 = QDate(2001,12,4); - d2 = QDate(2001,12,5); - QVERIFY( d1 < d2 ); - - d1 = QDate(2001,11,5); - d2 = QDate(2001,12,5); - QVERIFY( d1 < d2 ); - - d1 = QDate(2000,12,5); - d2 = QDate(2001,12,5); - QVERIFY( d1 < d2 ); - - d1 = QDate(2002,12,5); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 < d2) ); - - d1 = QDate(2001,12,5); - d2 = QDate(2001,11,5); - QVERIFY( !(d1 < d2) ); - - d1 = QDate(2001,12,6); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 < d2) ); + QTest::addColumn<QDate>("left"); + QTest::addColumn<QDate>("right"); + QTest::addColumn<Qt::strong_ordering>("expectedOrdering"); + + QTest::newRow("2000-1-2_vs_2000-1-2") + << QDate(2000, 1, 2) << QDate(2000, 1, 2) << Qt::strong_ordering::equivalent; + QTest::newRow("2001-12-4_vs_2001-12-5") + << QDate(2001, 12, 4) << QDate(2001, 12, 5) << Qt::strong_ordering::less; + QTest::newRow("2001-11-5_vs_2001-12-5") + << QDate(2001, 11, 5) << QDate(2001, 12, 5) << Qt::strong_ordering::less; + QTest::newRow("2000-12-5_vs_2001-12-5") + << QDate(2000, 12, 5) << QDate(2001, 12, 5) << Qt::strong_ordering::less; + QTest::newRow("2002-12-5_vs_2001-12-5") + << QDate(2002, 12, 5) << QDate(2001, 12, 5) << Qt::strong_ordering::greater; + QTest::newRow("2001-12-5_vs_2001-11-5") + << QDate(2001, 12, 5) << QDate(2001, 11, 5) << Qt::strong_ordering::greater; + QTest::newRow("2001-12-6_vs_2001-12-5") + << QDate(2001, 12, 6) << QDate(2001, 12, 5) << Qt::strong_ordering::greater; } -void tst_QDate::operator_gt() +void tst_QDate::ordering() { - QDate d1(2000,1,2); - QDate d2(2000,1,2); - QVERIFY( !(d1 > d2) ); - - d1 = QDate(2001,12,4); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 > d2) ); - - d1 = QDate(2001,11,5); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 > d2) ); - - d1 = QDate(2000,12,5); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 > d2) ); + QFETCH(QDate, left); + QFETCH(QDate, right); + QFETCH(Qt::strong_ordering, expectedOrdering); - d1 = QDate(2002,12,5); - d2 = QDate(2001,12,5); - QVERIFY( d1 > d2 ); - - d1 = QDate(2001,12,5); - d2 = QDate(2001,11,5); - QVERIFY( d1 > d2 ); - - d1 = QDate(2001,12,6); - d2 = QDate(2001,12,5); - QVERIFY( d1 > d2 ); + QT_TEST_ALL_COMPARISON_OPS(left, right, expectedOrdering); } -void tst_QDate::operator_lt_eq() +void tst_QDate::ordering_chrono_types() { - QDate d1(2000,1,2); - QDate d2(2000,1,2); - QVERIFY( d1 <= d2 ); - - d1 = QDate(2001,12,4); - d2 = QDate(2001,12,5); - QVERIFY( d1 <= d2 ); - - d1 = QDate(2001,11,5); - d2 = QDate(2001,12,5); - QVERIFY( d1 <= d2 ); - - d1 = QDate(2000,12,5); - d2 = QDate(2001,12,5); - QVERIFY( d1 <= d2 ); - - d1 = QDate(2002,12,5); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 <= d2) ); - - d1 = QDate(2001,12,5); - d2 = QDate(2001,11,5); - QVERIFY( !(d1 <= d2) ); - - d1 = QDate(2001,12,6); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 <= d2) ); -} - -void tst_QDate::operator_gt_eq() -{ - QDate d1(2000,1,2); - QDate d2(2000,1,2); - QVERIFY( d1 >= d2 ); - - d1 = QDate(2001,12,4); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 >= d2) ); - - d1 = QDate(2001,11,5); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 >= d2) ); - - d1 = QDate(2000,12,5); - d2 = QDate(2001,12,5); - QVERIFY( !(d1 >= d2) ); - - d1 = QDate(2002,12,5); - d2 = QDate(2001,12,5); - QVERIFY( d1 >= d2 ); - - d1 = QDate(2001,12,5); - d2 = QDate(2001,11,5); - QVERIFY( d1 >= d2 ); - - d1 = QDate(2001,12,6); - d2 = QDate(2001,12,5); - QVERIFY( d1 >= d2 ); +#if __cpp_lib_chrono >= 201907L + using namespace std::chrono; + QDate friday(2001, 11, 30); // the 5th Friday of November 2001 + // std::chrono::year_month_day + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_day(2001y, November, 29d), + Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_day(2001y, November, 30d), + Qt::strong_ordering::equivalent); + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_day(2001y, December, 1d), + Qt::strong_ordering::less); + + // std::chrono::year_month_day_last + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_day_last(2001y, {October / last}), + Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_day_last(2001y, {November / last}), + Qt::strong_ordering::equivalent); + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_day_last(2001y, {December / last}), + Qt::strong_ordering::less); + + // std::chrono::year_month_weekday + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_weekday(2001y, November, Thursday[5]), + Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_weekday(2001y, November, Friday[5]), + Qt::strong_ordering::equivalent); + QT_TEST_ALL_COMPARISON_OPS(friday, year_month_weekday(2001y, December, Saturday[1]), + Qt::strong_ordering::less); + + // std::chrono::year_month_weekday_last + QDate thursday(2001, 11, 29); // the last Thursday of November 2001 + QT_TEST_ALL_COMPARISON_OPS(thursday, year_month_weekday_last(2001y, November, Wednesday[last]), + Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(thursday, year_month_weekday_last(2001y, November, Thursday[last]), + Qt::strong_ordering::equivalent); + QT_TEST_ALL_COMPARISON_OPS(thursday, year_month_weekday_last(2001y, November, Friday[last]), + Qt::strong_ordering::less); +#else + QSKIP("This test requires C++20-level <chrono> support enabled in the standard library."); +#endif // __cpp_lib_chrono >= 201907L } Q_DECLARE_METATYPE(QDataStream::Version) @@ -1095,7 +1179,7 @@ void tst_QDate::operator_insert_extract() QCOMPARE(deserialised, date); } -#if QT_CONFIG(datetimeparser) +#if QT_CONFIG(datestring) void tst_QDate::fromStringDateFormat_data() { QTest::addColumn<QString>("dateStr"); @@ -1137,18 +1221,20 @@ void tst_QDate::fromStringDateFormat_data() << QString::fromLatin1(" 13 Feb 1987 13:24:51 +0100") << Qt::RFC2822Date << QDate(1987, 2, 13); QTest::newRow("RFC 2822 with day") << QString::fromLatin1("Thu, 01 Jan 1970 00:12:34 +0000") - << Qt::RFC2822Date << QDate(1970, 1, 1); + << Qt::RFC2822Date << epochDate(); QTest::newRow("RFC 2822 with day after space") << QString::fromLatin1(" Thu, 01 Jan 1970 00:12:34 +0000") - << Qt::RFC2822Date << QDate(1970, 1, 1); + << Qt::RFC2822Date << epochDate(); // No timezone QTest::newRow("RFC 2822 no timezone") << QString::fromLatin1("01 Jan 1970 00:12:34") - << Qt::RFC2822Date << QDate(1970, 1, 1); + << Qt::RFC2822Date << epochDate(); // No time specified QTest::newRow("RFC 2822 date only") << QString::fromLatin1("01 Nov 2002") << Qt::RFC2822Date << QDate(2002, 11, 1); QTest::newRow("RFC 2822 with day date only") << QString::fromLatin1("Fri, 01 Nov 2002") << Qt::RFC2822Date << QDate(2002, 11, 1); + QTest::newRow("RFC 2822 malformed time") + << QString::fromLatin1("01 Nov 2002 0:") << Qt::RFC2822Date << QDate(); // Test invalid month, day, year QTest::newRow("RFC 2822 invalid month name") << QString::fromLatin1("13 Fev 1987 13:24:51 +0100") << Qt::RFC2822Date << QDate(); @@ -1180,7 +1266,7 @@ void tst_QDate::fromStringDateFormat_data() << Qt::RFC2822Date << QDate(1987, 2, 13); // No timezone QTest::newRow("RFC 850 and 1036 no timezone") << QString::fromLatin1("Thu Jan 01 00:12:34 1970") - << Qt::RFC2822Date << QDate(1970, 1, 1); + << Qt::RFC2822Date << epochDate(); // No time specified QTest::newRow("RFC 850 and 1036 date only") << QString::fromLatin1("Fri Nov 01 2002") << Qt::RFC2822Date << QDate(2002, 11, 1); @@ -1217,78 +1303,177 @@ void tst_QDate::fromStringDateFormat() QCOMPARE(QDate::fromString(dateStr, dateFormat), expectedDate); } +# if QT_CONFIG(datetimeparser) void tst_QDate::fromStringFormat_data() { QTest::addColumn<QString>("string"); QTest::addColumn<QString>("format"); + QTest::addColumn<int>("baseYear"); QTest::addColumn<QDate>("expected"); - // Get names: - const QString january = QStringLiteral("January"); - const QString february = QStringLiteral("February"); - const QString march = QStringLiteral("March"); - const QString august = QStringLiteral("August"); - const QString mon = QStringLiteral("Mon"); - const QString monday = QStringLiteral("Monday"); - const QString tuesday = QStringLiteral("Tuesday"); - const QString wednesday = QStringLiteral("Wednesday"); - const QString thursday = QStringLiteral("Thursday"); - const QString friday = QStringLiteral("Friday"); - const QString saturday = QStringLiteral("Saturday"); - const QString sunday = QStringLiteral("Sunday"); - - QTest::newRow("data0") << QString("") << QString("") << defDate(); - QTest::newRow("data1") << QString(" ") << QString("") << invalidDate(); - QTest::newRow("data2") << QString(" ") << QString(" ") << defDate(); - QTest::newRow("data3") << QString("-%$%#") << QString("$*(#@") << invalidDate(); - QTest::newRow("data4") << QString("d") << QString("'d'") << defDate(); - QTest::newRow("data5") << QString("101010") << QString("dMyy") << QDate(1910, 10, 10); - QTest::newRow("data6") << QString("101010b") << QString("dMyy") << invalidDate(); - QTest::newRow("data7") << january << QString("MMMM") << defDate(); - QTest::newRow("data8") << QString("ball") << QString("balle") << invalidDate(); - QTest::newRow("data9") << QString("balleh") << QString("balleh") << defDate(); - QTest::newRow("data10") << QString("10.01.1") << QString("M.dd.d") << QDate(defDate().year(), 10, 1); - QTest::newRow("data11") << QString("-1.01.1") << QString("M.dd.d") << invalidDate(); - QTest::newRow("data12") << QString("11010") << QString("dMMyy") << invalidDate(); - QTest::newRow("data13") << QString("-2") << QString("d") << invalidDate(); - QTest::newRow("data14") << QString("132") << QString("Md") << invalidDate(); - QTest::newRow("data15") << february << QString("MMMM") << QDate(defDate().year(), 2, 1); - - QString date = mon + QLatin1Char(' ') + august + " 8 2005"; - QTest::newRow("data16") << date << QString("ddd MMMM d yyyy") << QDate(2005, 8, 8); - QTest::newRow("data17") << QString("2000:00") << QString("yyyy:yy") << QDate(2000, 1, 1); - QTest::newRow("data18") << QString("1999:99") << QString("yyyy:yy") << QDate(1999, 1, 1); - QTest::newRow("data19") << QString("2099:99") << QString("yyyy:yy") << QDate(2099, 1, 1); - QTest::newRow("data20") << QString("2001:01") << QString("yyyy:yy") << QDate(2001, 1, 1); - QTest::newRow("data21") << QString("99") << QString("yy") << QDate(1999, 1, 1); - QTest::newRow("data22") << QString("01") << QString("yy") << QDate(1901, 1, 1); - - QTest::newRow("data23") << monday << QString("dddd") << QDate(1900, 1, 1); - QTest::newRow("data24") << tuesday << QString("dddd") << QDate(1900, 1, 2); - QTest::newRow("data25") << wednesday << QString("dddd") << QDate(1900, 1, 3); - QTest::newRow("data26") << thursday << QString("dddd") << QDate(1900, 1, 4); - QTest::newRow("data27") << friday << QString("dddd") << QDate(1900, 1, 5); - QTest::newRow("data28") << saturday << QString("dddd") << QDate(1900, 1, 6); - QTest::newRow("data29") << sunday << QString("dddd") << QDate(1900, 1, 7); - - QTest::newRow("data30") << monday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 2); - QTest::newRow("data31") << tuesday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 3); - QTest::newRow("data32") << wednesday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 4); - QTest::newRow("data33") << thursday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 5); - QTest::newRow("data34") << friday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 6); - QTest::newRow("data35") << saturday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 7); - QTest::newRow("data36") << sunday + " 2006" << QString("dddd yyyy") << QDate(2006, 1, 1); - - QTest::newRow("data37") << tuesday + " 2007 " + march << QString("dddd yyyy MMMM") << QDate(2007, 3, 6); - - QTest::newRow("data38") << QString("21052006") << QString("ddMMyyyy") << QDate(2006,5,21); - QTest::newRow("data39") << QString("210506") << QString("ddMMyy") << QDate(1906,5,21); - QTest::newRow("data40") << QString("21/5/2006") << QString("d/M/yyyy") << QDate(2006,5,21); - QTest::newRow("data41") << QString("21/5/06") << QString("d/M/yy") << QDate(1906,5,21); - QTest::newRow("data42") << QString("20060521") << QString("yyyyMMdd") << QDate(2006,5,21); - QTest::newRow("data43") << QString("060521") << QString("yyMMdd") << QDate(1906,5,21); - QTest::newRow("lateMarch") << QString("9999-03-06") << QString("yyyy-MM-dd") << QDate(9999, 3, 6); - QTest::newRow("late") << QString("9999-12-31") << QString("yyyy-MM-dd") << QDate(9999, 12, 31); + QTest::newRow("empty") << u""_s << u""_s << 1900 << defDate(); + QTest::newRow("space-as-empty") << u" "_s << u""_s << 1900 << invalidDate(); + QTest::newRow("space") << u" "_s << u" "_s << 1900 << defDate(); + QTest::newRow("mispunc") << u"-%$%#"_s << u"$*(#@"_s << 1900 << invalidDate(); + QTest::newRow("literal-d") << u"d"_s << u"'d'"_s << 1900 << defDate(); + QTest::newRow("greedy") << u"101010"_s << u"dMyy"_s << 1900 << QDate(1910, 10, 10); + QTest::newRow("greedy-miss") << u"101010b"_s << u"dMyy"_s << 1900 << invalidDate(); + QTest::newRow("January") << u"January"_s << u"MMMM"_s << 1900 << defDate(); + QTest::newRow("mistext") << u"ball"_s << u"balle"_s << 1900 << invalidDate(); + QTest::newRow("text") << u"balleh"_s << u"balleh"_s << 1900 << defDate(); + QTest::newRow("yearless:19") << u"10.01.1"_s << u"M.dd.d"_s << 1900 << QDate(1900, 10, 1); + QTest::newRow("yearless:20") << u"10.01.1"_s << u"M.dd.d"_s << 2000 << QDate(2000, 10, 1); + QTest::newRow("neg-month") << u"-1.01.1"_s << u"M.dd.d"_s << 1900 << invalidDate(); + QTest::newRow("greedy-break") << u"11010"_s << u"dMMyy"_s << 1900 << invalidDate(); + QTest::newRow("neg-day") << u"-2"_s << u"d"_s << 1900 << invalidDate(); + QTest::newRow("Md:132") << u"132"_s << u"Md"_s << 1900 << invalidDate(); + QTest::newRow("February") << u"February"_s << u"MMMM"_s << 1900 << QDate(1900, 2, 1); + + QTest::newRow("mon-aug-8th") + << u"Mon August 8 2005"_s << u"ddd MMMM d yyyy"_s << 1900 << QDate(2005, 8, 8); + QTest::newRow("year-match-20000") << u"2000:00"_s << u"yyyy:yy"_s << 1900 << QDate(2000, 1, 1); + QTest::newRow("year-match-1999") << u"1999:99"_s << u"yyyy:yy"_s << 1900 << QDate(1999, 1, 1); + QTest::newRow("year-match-2099") << u"2099:99"_s << u"yyyy:yy"_s << 1900 << QDate(2099, 1, 1); + QTest::newRow("year-match-2001") << u"2001:01"_s << u"yyyy:yy"_s << 1900 << QDate(2001, 1, 1); + QTest::newRow("just-yy-1999") << u"99"_s << u"yy"_s << 1900 << QDate(1999, 1, 1); + QTest::newRow("just-yy-1901") << u"01"_s << u"yy"_s << 1900 << QDate(1901, 1, 1); + QTest::newRow("just-yy-2001") << u"01"_s << u"yy"_s << 1970 << QDate(2001, 1, 1); + + QTest::newRow("Monday") << u"Monday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 1); + QTest::newRow("Tuesday") << u"Tuesday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 2); + QTest::newRow("Wednesday") << u"Wednesday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 3); + QTest::newRow("Thursday") << u"Thursday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 4); + QTest::newRow("Friday") << u"Friday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 5); + QTest::newRow("Saturday") << u"Saturday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 6); + QTest::newRow("Sunday") << u"Sunday"_s << u"dddd"_s << 1900 << QDate(1900, 1, 7); + + QTest::newRow("Mon06") << u"Monday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 2); + QTest::newRow("Tues06") << u"Tuesday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 3); + QTest::newRow("Wed06") << u"Wednesday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 4); + QTest::newRow("Thu06") << u"Thursday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 5); + QTest::newRow("Fri06") << u"Friday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 6); + QTest::newRow("Sat06") << u"Saturday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 7); + QTest::newRow("Sun06") << u"Sunday 2006"_s << u"dddd yyyy"_s << 1900 << QDate(2006, 1, 1); + QTest::newRow("Tue07Mar") + << u"Tuesday 2007 March"_s << u"dddd yyyy MMMM"_s << 1900 << QDate(2007, 3, 6); + + QTest::newRow("21May2006") + << u"21052006"_s << u"ddMMyyyy"_s << 1900 << QDate(2006, 5, 21); + QTest::newRow("21May06:19") + << u"210506"_s << u"ddMMyy"_s << 1900 << QDate(1906, 5, 21); + QTest::newRow("21May06:20") + << u"210506"_s << u"ddMMyy"_s << 1970 << QDate(2006, 5, 21); + QTest::newRow("21/May/2006") + << u"21/5/2006"_s << u"d/M/yyyy"_s << 1900 << QDate(2006, 5, 21); + QTest::newRow("21/5/06") + << u"21/5/06"_s << u"d/M/yy"_s << 1900 << QDate(1906, 5, 21); + QTest::newRow("21/5/06:19") + << u"21/5/06"_s << u"d/M/yy"_s << 1900 << QDate(1906, 5, 21); + QTest::newRow("21/5/06:20") + << u"21/5/06"_s << u"d/M/yy"_s << 1910 << QDate(2006, 5, 21); + QTest::newRow("2006May21") + << u"20060521"_s << u"yyyyMMdd"_s << 1900 << QDate(2006, 5, 21); + QTest::newRow("06May21:19") + << u"060521"_s << u"yyMMdd"_s << 1900 << QDate(1906, 5, 21); + QTest::newRow("06May21:20") + << u"060521"_s << u"yyMMdd"_s << 1907 << QDate(2006, 5, 21); + QTest::newRow("lateMarch") + << u"9999-03-06"_s << u"yyyy-MM-dd"_s << 1900 << QDate(9999, 3, 6); + QTest::newRow("late") + << u"9999-12-31"_s << u"yyyy-MM-dd"_s << 1900 << QDate(9999, 12, 31); + + QTest::newRow("quoted-dd") + << u"21dd-05-2006"_s << u"dd'dd'-MM-yyyy"_s << 1900 << QDate(2006, 5, 21); + QTest::newRow("quoted-MM") + << u"21-MM05-2006"_s << u"dd-'MM'MM-yyyy"_s << 1900 << QDate(2006, 5, 21); + QTest::newRow("quotes-empty") + << u"21-'05-2006"_s << u"dd-MM-''yy"_s << 1900 << QDate(2006, 5, 21); + + // Test unicode handling. + QTest::newRow("Unicode in format string") + << QString(u8"2020🤣09🤣21") << QString(u8"yyyy🤣MM🤣dd") << 1900 << QDate(2020, 9, 21); + QTest::newRow("Unicode-in-format-string-quoted-emoji") + << QString(u8"🤣🤣2020👍09🤣21") << QString(u8"'🤣🤣'yyyy👍MM🤣dd") << 1900 + << QDate(2020, 9, 21); + QTest::newRow("Unicode-in-quoted-dd-format-string") + << QString(u8"🤣🤣2020👍09🤣21dd") << QString(u8"🤣🤣yyyy👍MM🤣dd'dd'") << 1900 + << QDate(2020, 9, 21); + QTest::newRow("Unicode-in-all-formats-quoted-string") + << QString(u8"🤣🤣yyyy2020👍MM09🤣21dd") << QString(u8"🤣🤣'yyyy'yyyy👍'MM'MM🤣dd'dd'") + << 1900 << QDate(2020, 9, 21); + + // QTBUG-84334 + QTest::newRow("-ve year: front, nosep") + << u"-20060521"_s << u"yyyyMMdd"_s << 1900 << QDate(-2006, 5, 21); + QTest::newRow("-ve year: mid, nosep") + << u"05-200621"_s << u"MMyyyydd"_s << 1900 << QDate(-2006, 5, 21); + QTest::newRow("-ve year: back, nosep") + << u"0521-2006"_s << u"MMddyyyy"_s << 1900 << QDate(-2006, 5, 21); + // - as separator should not interfere with negative year numbers: + QTest::newRow("-ve year: front, dash") + << u"-2006-05-21"_s << u"yyyy-MM-dd"_s << 1900 << QDate(-2006, 5, 21); + QTest::newRow("positive year: front, dash") + << u"-2006-05-21"_s << u"-yyyy-MM-dd"_s << 1900 << QDate(2006, 5, 21); + QTest::newRow("-ve year: mid, dash") + << u"05--2006-21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(-2006, 5, 21); + QTest::newRow("-ve year: back, dash") + << u"05-21--2006"_s << u"MM-dd-yyyy"_s << 1900 << QDate(-2006, 5, 21); + // negative three digit year numbers should be rejected: + QTest::newRow("-ve 3digit year: front") + << u"-206-05-21"_s << u"yyyy-MM-dd"_s << 1900 << QDate(); + QTest::newRow("-ve 3digit year: mid") + << u"05--206-21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(); + QTest::newRow("-ve 3digit year: back") + << u"05-21--206"_s << u"MM-dd-yyyy"_s << 1900 << QDate(); + // negative month numbers should be rejected: + QTest::newRow("-ve 2digit month: mid") + << u"2060--05-21"_s << u"yyyy-MM-dd"_s << 1900 << QDate(); + QTest::newRow("-ve 2digit month: front") + << u"-05-2060-21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(); + QTest::newRow("-ve 2digit month: back") + << u"21-2060--05"_s << u"dd-yyyy-MM"_s << 1900 << QDate(); + // negative single digit month numbers should be rejected: + QTest::newRow("-ve 1digit month: mid") + << u"2060--5-21"_s << u"yyyy-MM-dd"_s << 1900 << QDate(); + QTest::newRow("-ve 1digit month: front") + << u"-5-2060-21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(); + QTest::newRow("-ve 1digit month: back") + << u"21-2060--5"_s << u"dd-yyyy-MM"_s << 1900 << QDate(); + // negative day numbers should be rejected: + QTest::newRow("-ve 2digit day: front") + << u"-21-2060-05"_s << u"dd-yyyy-MM"_s << 1900 << QDate(); + QTest::newRow("-ve 2digit day: mid") + << u"2060--21-05"_s << u"yyyy-dd-MM"_s << 1900 << QDate(); + QTest::newRow("-ve 2digit day: back") + << u"05-2060--21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(); + // negative single digit day numbers should be rejected: + QTest::newRow("-ve 1digit day: front") + << u"-2-2060-05"_s << u"dd-yyyy-MM"_s << 1900 << QDate(); + QTest::newRow("-ve 1digit day: mid") + << u"05--2-2060"_s << u"MM-dd-yyyy"_s << 1900 << QDate(); + QTest::newRow("-ve 1digit day: back") + << u"2060-05--2"_s << u"yyyy-MM-dd"_s << 1900 << QDate(); + // positive three digit year numbers should be rejected: + QTest::newRow("3digit year, front") << u"206-05-21"_s << u"yyyy-MM-dd"_s << 1900 << QDate(); + QTest::newRow("3digit year, mid") << u"05-206-21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(); + QTest::newRow("3digit year, back") << u"05-21-206"_s << u"MM-dd-yyyy"_s << 1900 << QDate(); + // positive five digit year numbers should be rejected: + QTest::newRow("5digit year, front") + << u"00206-05-21"_s << u"yyyy-MM-dd"_s << 1900 << QDate(); + QTest::newRow("5digit year, mid") + << u"05-00206-21"_s << u"MM-yyyy-dd"_s << 1900 << QDate(); + QTest::newRow("5digit year, back") + << u"05-21-00206"_s << u"MM-dd-yyyy"_s << 1900 << QDate(); + + QTest::newRow("dash separator, no year at end") + << u"05-21-"_s << u"dd-MM-yyyy"_s << 1900 << QDate(); + QTest::newRow("slash separator, no year at end") + << u"11/05/"_s << u"d/MM/yyyy"_s << 1900 << QDate(); + + // QTBUG-84349 + QTest::newRow("+ sign in year field") << u"+0200322"_s << u"yyyyMMdd"_s << 1900 << QDate(); + QTest::newRow("+ sign in month field") << u"2020+322"_s << u"yyyyMMdd"_s << 1900 << QDate(); + QTest::newRow("+ sign in day field") << u"202003+1"_s << u"yyyyMMdd"_s << 1900 << QDate(); } @@ -1296,14 +1481,16 @@ void tst_QDate::fromStringFormat() { QFETCH(QString, string); QFETCH(QString, format); + QFETCH(int, baseYear); QFETCH(QDate, expected); - QDate dt = QDate::fromString(string, format); + QDate dt = QDate::fromString(string, format, baseYear); + QEXPECT_FAIL("quotes-empty", "QTBUG-110669: doubled single-quotes in format mishandled", + Continue); QCOMPARE(dt, expected); } #endif // datetimeparser -#if QT_CONFIG(datestring) void tst_QDate::toStringFormat_data() { QTest::addColumn<QDate>("t"); @@ -1337,7 +1524,7 @@ void tst_QDate::toStringDateFormat_data() QTest::newRow("data2") << QDate(111,1,1) << Qt::ISODate << QString("0111-01-01"); QTest::newRow("data3") << QDate(1974,12,1) << Qt::ISODate << QString("1974-12-01"); QTest::newRow("year < 0") << QDate(-1,1,1) << Qt::ISODate << QString(); - QTest::newRow("year > 9999") << QDate(-1,1,1) << Qt::ISODate << QString(); + QTest::newRow("year > 9999") << QDate(10000, 1, 1) << Qt::ISODate << QString(); QTest::newRow("RFC2822Date") << QDate(1974,12,1) << Qt::RFC2822Date << QString("01 Dec 1974"); QTest::newRow("ISODateWithMs") << QDate(1974,12,1) << Qt::ISODateWithMs << QString("1974-12-01"); } @@ -1461,11 +1648,13 @@ void tst_QDate::printNegativeYear() const void tst_QDate::roundtripString() const { /* This code path should not result in warnings. */ - const QDate theDate(QDate::currentDate()); - theDate.fromString(theDate.toString(Qt::TextDate), Qt::TextDate); + const QDate date(QDate::currentDate()); + QCOMPARE(date.fromString(date.toString(Qt::TextDate), Qt::TextDate), date); - const QDateTime theDateTime(QDateTime::currentDateTime()); - theDateTime.fromString(theDateTime.toString(Qt::TextDate), Qt::TextDate); + const QDateTime now(QDateTime::currentDateTime()); + // TextDate discards milliseconds, so clip to whole second: + const QDateTime when = now.addMSecs(-now.time().msec()); + QCOMPARE(when.fromString(when.toString(Qt::TextDate), Qt::TextDate), when); } #endif @@ -1509,9 +1698,6 @@ void tst_QDate::roundtrip() const loopDate = loopDate.addDays(1); } - qint64 minJd = Q_INT64_C(-784350574879); - qint64 maxJd = Q_INT64_C( 784354017364); - // Test Gregorian round trip at top end of conversion range loopDate = QDate::fromJulianDay(maxJd); while (loopDate.toJulianDay() >= maxJd - 146397) { @@ -1527,6 +1713,38 @@ void tst_QDate::roundtrip() const QCOMPARE(loopDate.toJulianDay(), testDate.toJulianDay()); loopDate = loopDate.addDays(1); } + +#if __cpp_lib_chrono >= 201907L + // Test roundtrip for from/to std::chrono conversions. + // Compile-time test, to verify it's all constexpr. + using namespace std::chrono; + { + constexpr sys_days expected{days{minJd}}; + constexpr sys_days actual{QDate::fromStdSysDays(expected).toStdSysDays()}; + static_assert(actual == expected); + } + { + // constexpr year_month_day expected{sys_days{days{maxJd}}}; // Overflow at least on MSVC + constexpr year_month_day expected{1970y, January, 1d}; + constexpr sys_days actual{QDate(expected).toStdSysDays()}; + static_assert(actual == sys_days(expected)); + } + { + constexpr year_month_day_last expected{2001y, {October / last}}; + constexpr sys_days actual{QDate(expected).toStdSysDays()}; + static_assert(actual == sys_days(expected)); + } + { + constexpr year_month_weekday expected{2001y, December, Saturday[1]}; + constexpr sys_days actual{QDate(expected).toStdSysDays()}; + static_assert(actual == sys_days(expected)); + } + { + constexpr year_month_weekday_last expected{2001y, November, Friday[last]}; + constexpr sys_days actual{QDate(expected).toStdSysDays()}; + static_assert(actual == sys_days(expected)); + } +#endif // __cpp_lib_chrono >= 201907L } void tst_QDate::qdebug() const diff --git a/tests/auto/corelib/time/qdatetime/CMakeLists.txt b/tests/auto/corelib/time/qdatetime/CMakeLists.txt index e27559c401..499369c131 100644 --- a/tests/auto/corelib/time/qdatetime/CMakeLists.txt +++ b/tests/auto/corelib/time/qdatetime/CMakeLists.txt @@ -1,29 +1,33 @@ -# Generated from qdatetime.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qdatetime Test: ##################################################################### -qt_add_test(tst_qdatetime +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qdatetime LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qdatetime SOURCES tst_qdatetime.cpp DEFINES QT_NO_FOREACH QT_NO_KEYWORDS - PUBLIC_LIBRARIES + LIBRARIES Qt::CorePrivate + Qt::TestPrivate ) ## Scopes: ##################################################################### -#### Keys ignored in scope 2:.:.:qdatetime.pro:MSVC: -# QMAKE_CFLAGS_RELEASE = "--O1" -# QMAKE_CXXFLAGS_RELEASE = "--O1" - -qt_extend_target(tst_qdatetime CONDITION APPLE +qt_internal_extend_target(tst_qdatetime CONDITION APPLE SOURCES tst_qdatetime_mac.mm - PUBLIC_LIBRARIES + LIBRARIES ${FWFoundation} ) diff --git a/tests/auto/corelib/time/qdatetime/qdatetime.pro b/tests/auto/corelib/time/qdatetime/qdatetime.pro deleted file mode 100644 index 60d4d810d4..0000000000 --- a/tests/auto/corelib/time/qdatetime/qdatetime.pro +++ /dev/null @@ -1,18 +0,0 @@ -CONFIG += testcase -TARGET = tst_qdatetime -QT = core-private testlib -SOURCES = tst_qdatetime.cpp -DEFINES += QT_NO_KEYWORDS QT_NO_FOREACH - -# For some reason using optimization here triggers a compiler issue, which causes an exception -# However, the code is correct -msvc { - !build_pass:message ( "Compiler issue, removing -O1 flag" ) - QMAKE_CFLAGS_RELEASE -= -O1 - QMAKE_CXXFLAGS_RELEASE -= -O1 -} - -mac { - OBJECTIVE_SOURCES += tst_qdatetime_mac.mm - LIBS += -framework Foundation -} diff --git a/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp b/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp index c6ec869460..f9c6afc795 100644 --- a/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp +++ b/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp @@ -1,41 +1,28 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Copyright (C) 2016 Intel Corporation. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include <QtTest/QtTest> -#include <time.h> -#include <qdatetime.h> +// Copyright (C) 2022 The Qt Company Ltd. +// Copyright (C) 2016 Intel Corporation. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QDateTime> +#include <QTest> + +#include <QTimeZone> #include <private/qdatetime_p.h> +#include <private/qtenvironmentvariables_p.h> // for qTzSet(), qTzName() +#include <private/qcomparisontesthelper_p.h> #ifdef Q_OS_WIN -# include <qt_windows.h> +# include <qt_windows.h> +# if !QT_CONFIG(icu) +// The native MS back-end for time-zones lacks info about historic transitions: +# define INADEQUATE_TZ_DATA +# endif +#endif +#ifdef Q_OS_ANDROID // Also seems to lack full-day zone transitions: +# define INADEQUATE_TZ_DATA #endif +using namespace Qt::StringLiterals; + class tst_QDateTime : public QObject { Q_OBJECT @@ -43,18 +30,19 @@ class tst_QDateTime : public QObject public: tst_QDateTime(); - static QString str( int y, int month, int d, int h, int min, int s ); - static QDateTime dt( const QString& str ); public Q_SLOTS: void initTestCase(); private Q_SLOTS: void ctor(); void operator_eq(); + void moveSemantics(); void isNull(); void isValid(); void date(); void time(); +#if QT_DEPRECATED_SINCE(6, 9) void timeSpec(); +#endif void toSecsSinceEpoch_data(); void toSecsSinceEpoch(); void daylightSavingsTimeChange_data(); @@ -64,13 +52,17 @@ private Q_SLOTS: void setDate(); void setTime_data(); void setTime(); + void setTimeZone_data(); + void setTimeZone(); +#if QT_DEPRECATED_SINCE(6, 9) void setTimeSpec_data(); void setTimeSpec(); +#endif void setSecsSinceEpoch(); void setMSecsSinceEpoch_data(); void setMSecsSinceEpoch(); void fromSecsSinceEpoch(); - void fromMSecsSinceEpoch_data(); + void fromMSecsSinceEpoch_data() { setMSecsSinceEpoch_data(); } void fromMSecsSinceEpoch(); #if QT_CONFIG(datestring) void toString_isoDate_data(); @@ -85,6 +77,7 @@ private Q_SLOTS: void toString_strformat(); #endif void addDays(); + void addInvalid(); void addMonths(); void addMonths_data(); void addYears(); @@ -93,19 +86,25 @@ private Q_SLOTS: void addSecs(); void addMSecs_data(); void addMSecs(); +#if QT_DEPRECATED_SINCE(6, 9) void toTimeSpec_data(); void toTimeSpec(); - void toLocalTime_data(); + void toLocalTime_data() { toTimeSpec_data(); } void toLocalTime(); - void toUTC_data(); + void toUTC_data() { toTimeSpec_data(); } void toUTC(); + void toUTC_extra(); +#endif void daysTo(); void secsTo_data(); void secsTo(); - void msecsTo_data(); + void msecsTo_data() { addMSecs_data(); } void msecsTo(); + void orderingCompiles(); void operator_eqeq_data(); void operator_eqeq(); + void ordering_data(); + void ordering(); void operator_insert_extract_data(); void operator_insert_extract(); void currentDateTime(); @@ -123,8 +122,10 @@ private Q_SLOTS: #endif void offsetFromUtc(); +#if QT_DEPRECATED_SINCE(6, 9) void setOffsetFromUtc(); void toOffsetFromUtc(); +#endif void zoneAtTime_data(); void zoneAtTime(); @@ -142,6 +143,7 @@ private Q_SLOTS: void isDaylightTime() const; void daylightTransitions() const; void timeZones() const; + void systemTimeZoneChange_data() const; void systemTimeZoneChange() const; void invalid_data() const; @@ -150,10 +152,44 @@ private Q_SLOTS: void macTypes(); + void stdCompatibilitySysTime_data(); + void stdCompatibilitySysTime(); + void stdCompatibilityLocalTime_data(); + void stdCompatibilityLocalTime(); +#if QT_CONFIG(timezone) + void stdCompatibilityZonedTime_data(); + void stdCompatibilityZonedTime(); +#endif + private: - enum { LocalTimeIsUtc = 0, LocalTimeAheadOfUtc = 1, LocalTimeBehindUtc = -1} localTimeType; + /* + Various zones close to UTC (notably Iceland, the WET zones and several in + West Africa) or nominally assigned to it historically (north Canada, the + Antarctic) and those that have crossed the international date-line (by + skipping or repeating a day) don't have a consistent answer to "which side + of UTC is it ?" So the various LocalTimeType members may be different. + */ + enum LocalTimeType { LocalTimeIsUtc = 0, LocalTimeAheadOfUtc = 1, LocalTimeBehindUtc = -1}; + const LocalTimeType solarMeanType, epochTimeType, futureTimeType, distantTimeType; + static constexpr auto UTC = QTimeZone::UTC; + static constexpr qint64 epochJd = Q_INT64_C(2440588); + int preZoneFix; bool zoneIsCET; + static LocalTimeType timeTypeFor(qint64 jand, qint64 juld) + { + constexpr uint day = 24 * 3600; // in seconds + QDateTime jan = QDateTime::fromSecsSinceEpoch(jand * day); + QDateTime jul = QDateTime::fromSecsSinceEpoch(juld * day); + if (jan.date().toJulianDay() < jand + epochJd || jul.date().toJulianDay() < juld + epochJd) + return LocalTimeBehindUtc; + if (jan.date().toJulianDay() > jand + epochJd || jul.date().toJulianDay() > juld + epochJd + || jan.time().hour() > 0 || jul.time().hour() > 0) { + return LocalTimeAheadOfUtc; + } + return LocalTimeIsUtc; + } + class TimeZoneRollback { const QByteArray prior; @@ -164,7 +200,7 @@ private: { reset(zone); } void reset(const QByteArray &zone) { - qputenv("TZ", zone.constData()); + qputenv("TZ", zone); qTzSet(); } ~TimeZoneRollback() @@ -172,7 +208,7 @@ private: if (prior.isNull()) qunsetenv("TZ"); else - qputenv("TZ", prior.constData()); + qputenv("TZ", prior); qTzSet(); } }; @@ -181,7 +217,18 @@ private: Q_DECLARE_METATYPE(Qt::TimeSpec) Q_DECLARE_METATYPE(Qt::DateFormat) -tst_QDateTime::tst_QDateTime() +tst_QDateTime::tst_QDateTime() : + // UTC starts of January and July in the commented years: + solarMeanType(timeTypeFor(-62091, -61910)), // 1800 + epochTimeType(timeTypeFor(0, 181)), // 1970 + // Use stable future, to which current rule is extrapolated, as surrogate for variable current: + futureTimeType(timeTypeFor(24837, 25018)), // 2038 + // The glibc functions only handle DST as far as a 32-bit signed day-count + // from some date in 1970 reaches; the future extreme of that is in the + // second half of 5'881'580 CE. Beyond 5'881'581 CE it treats all zones as + // being in their January state, regardless of time of year. So use data for + // this later year for tests of QDateTime's upper bound. + distantTimeType(timeTypeFor(0x800000adLL, 0x80000162LL)) { /* Due to some jurisdictions changing their zones and rules, it's possible @@ -191,11 +238,10 @@ tst_QDateTime::tst_QDateTime() test thoroughly; ideally at every mid-winter or mid-summer in whose half-year any test below assumes zoneIsCET means what it says. (Tests at or near a DST transition implicate both of the half-years that meet - there.) Years outside the 1970--2038 range, however, are likely not - properly handled by the TZ-database; and QDateTime explicitly handles them - differently, so don't probe them here. + there.) Years outside the +ve half of 32-bit time_t's range, however, + might not be properly handled by our work-arounds for the MS backend and + 32-bit time_t; so don't probe them here. */ - const uint day = 24 * 3600; // in seconds zoneIsCET = (QDateTime(QDate(2038, 1, 19), QTime(4, 14, 7)).toSecsSinceEpoch() == 0x7fffffff // Entries a year apart robustly differ by multiples of day. && QDate(2015, 7, 1).startOfDay().toSecsSinceEpoch() == 1435701600 @@ -210,43 +256,21 @@ tst_QDateTime::tst_QDateTime() && QDate(1990, 7, 1).startOfDay().toSecsSinceEpoch() == 646783200 && QDate(1990, 1, 1).startOfDay().toSecsSinceEpoch() == 631148400 && QDate(1979, 1, 1).startOfDay().toSecsSinceEpoch() == 283993200 - // .toSecsSinceEpoch() returns -1 for everything before this: && QDateTime(QDate(1970, 1, 1), QTime(1, 0)).toSecsSinceEpoch() == 0); // Use .toMSecsSinceEpoch() if you really need to test anything earlier. /* - Again, rule changes can cause a TZ to look like UTC at some sample dates - but deviate at some date relevant to a test using localTimeType. These - tests mostly use years outside the 1970--2038 range for which TZ data is - credible, so we can't helpfully be exhaustive. So scan a sample of years' - starts and middles. - */ - const int sampled = 3; - // UTC starts of months in 2004, 2038 and 1970: - qint64 jans[sampled] = { 12418 * day, 24837 * day, 0 }; - qint64 juls[sampled] = { 12600 * day, 25018 * day, 181 * day }; - localTimeType = LocalTimeIsUtc; - for (int i = sampled; i-- > 0; ) { - QDateTime jan = QDateTime::fromSecsSinceEpoch(jans[i]); - QDateTime jul = QDateTime::fromSecsSinceEpoch(juls[i]); - if (jan.date().year() < 1970 || jul.date().month() < 7) { - localTimeType = LocalTimeBehindUtc; - break; - } else if (jan.time().hour() > 0 || jul.time().hour() > 0 - || jan.date().day() > 1 || jul.date().day() > 1) { - localTimeType = LocalTimeAheadOfUtc; - break; - } - } - /* - Even so, TZ=Africa/Algiers will fail fromMSecsSinceEpoch(-1) because it - switched from WET without DST (i.e. UTC) in the late 1960s to WET with DST - for all of 1970 - so they had a DST transition *on the epoch*. They've - since switched to CET with no DST, making life simple; but our tests for - mistakes around the epoch can't tell the difference between what Algeria - really did and the symptoms we can believe a bug might produce: there's - not much we can do about that, that wouldn't hide real bugs. + Zones which currently appear to be CET may have distinct offsets before + the advent of time-zones. The date used here is the eve of the birth of + Dr. William Hyde Wollaston, who first proposed a uniform national time, + instead of local mean time: */ + preZoneFix = zoneIsCET ? QDate(1766, 8, 5).startOfDay().offsetFromUtc() - 3600 : 0; + // Madrid, actually west of Greenwich, uses CET as if it were an hour east + // of Greenwich; allow that the fix might be more than an hour, either way: + Q_ASSERT(preZoneFix > -7200 && preZoneFix < 7200); + // So it's OK to add it to a QTime() between 02:00 and 22:00, but otherwise + // we must add it to the QDateTime constructed from it. } void tst_QDateTime::initTestCase() @@ -254,7 +278,7 @@ void tst_QDateTime::initTestCase() // Never construct a message like this in an i18n context... const char *typemsg1 = "exactly"; const char *typemsg2 = "and therefore not"; - switch (localTimeType) { + switch (futureTimeType) { case LocalTimeIsUtc: break; case LocalTimeBehindUtc: @@ -273,27 +297,13 @@ void tst_QDateTime::initTestCase() << "the Central European timezone"; } -QString tst_QDateTime::str( int y, int month, int d, int h, int min, int s ) -{ - return QDateTime( QDate(y, month, d), QTime(h, min, s) ).toString( Qt::ISODate ); -} - -QDateTime tst_QDateTime::dt(const QString &text) -{ -#if QT_CONFIG(datestring) - if (text != "INVALID") - return QDateTime::fromString(text, Qt::ISODate); -#endif - return QDateTime(); -} - void tst_QDateTime::ctor() { QDateTime dt1(QDate(2004, 1, 2), QTime(1, 2, 3)); QCOMPARE(dt1.timeSpec(), Qt::LocalTime); - QDateTime dt2(QDate(2004, 1, 2), QTime(1, 2, 3), Qt::LocalTime); + QDateTime dt2(QDate(2004, 1, 2), QTime(1, 2, 3)); QCOMPARE(dt2.timeSpec(), Qt::LocalTime); - QDateTime dt3(QDate(2004, 1, 2), QTime(1, 2, 3), Qt::UTC); + QDateTime dt3(QDate(2004, 1, 2), QTime(1, 2, 3), UTC); QCOMPARE(dt3.timeSpec(), Qt::UTC); QVERIFY(dt1 == dt2); @@ -307,25 +317,26 @@ void tst_QDateTime::ctor() QDate offsetDate(2013, 1, 1); QTime offsetTime(1, 2, 3); - QDateTime offset1(offsetDate, offsetTime, Qt::OffsetFromUTC); + QDateTime offset1(offsetDate, offsetTime, QTimeZone::fromSecondsAheadOfUtc(0)); QCOMPARE(offset1.timeSpec(), Qt::UTC); QCOMPARE(offset1.offsetFromUtc(), 0); QCOMPARE(offset1.date(), offsetDate); QCOMPARE(offset1.time(), offsetTime); - QDateTime offset2(offsetDate, offsetTime, Qt::OffsetFromUTC, 0); + QDateTime offset2(offsetDate, offsetTime, + QTimeZone::fromDurationAheadOfUtc(std::chrono::seconds{})); QCOMPARE(offset2.timeSpec(), Qt::UTC); QCOMPARE(offset2.offsetFromUtc(), 0); QCOMPARE(offset2.date(), offsetDate); QCOMPARE(offset2.time(), offsetTime); - QDateTime offset3(offsetDate, offsetTime, Qt::OffsetFromUTC, 60 * 60); + QDateTime offset3(offsetDate, offsetTime, QTimeZone::fromSecondsAheadOfUtc(60 * 60)); QCOMPARE(offset3.timeSpec(), Qt::OffsetFromUTC); QCOMPARE(offset3.offsetFromUtc(), 60 * 60); QCOMPARE(offset3.date(), offsetDate); QCOMPARE(offset3.time(), offsetTime); - QDateTime offset4(offsetDate, QTime(0, 0), Qt::OffsetFromUTC, 60 * 60); + QDateTime offset4(offsetDate, QTime(0, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); QCOMPARE(offset4.timeSpec(), Qt::OffsetFromUTC); QCOMPARE(offset4.offsetFromUtc(), 60 * 60); QCOMPARE(offset4.date(), offsetDate); @@ -334,13 +345,25 @@ void tst_QDateTime::ctor() void tst_QDateTime::operator_eq() { - QVERIFY(QDateTime() != QDateTime(QDate(1970, 1, 1), QTime(0, 0))); // QTBUG-79006 - QDateTime dt1(QDate(2004, 3, 24), QTime(23, 45, 57), Qt::UTC); - QDateTime dt2(QDate(2005, 3, 11), QTime(0, 0), Qt::UTC); + QVERIFY(QDateTime() != QDate(1970, 1, 1).startOfDay()); // QTBUG-79006 + QDateTime dt1(QDate(2004, 3, 24), QTime(23, 45, 57), UTC); + QDateTime dt2(QDate(2005, 3, 11), QTime(0, 0), UTC); dt2 = dt1; QVERIFY(dt1 == dt2); } +void tst_QDateTime::moveSemantics() +{ + QDateTime dt1{QDate{2004, 3, 24}, QTime{23, 45, 57}, UTC}; + QDateTime dt2{QDate{2005, 3, 11}, QTime{0, 0}, UTC}; + QDateTime copy = dt1; + QDateTime moved = std::move(dt1); + QCOMPARE(copy, moved); + copy = dt2; + moved = std::move(dt2); + QCOMPARE(copy, moved); +} + void tst_QDateTime::isNull() { QDateTime dt1; @@ -349,15 +372,27 @@ void tst_QDateTime::isNull() QVERIFY(dt1.isNull()); dt1.setTime(QTime()); QVERIFY(dt1.isNull()); - dt1.setTimeSpec(Qt::UTC); - QVERIFY(dt1.isNull()); // maybe it should return false? + dt1.setTimeZone(UTC); + QVERIFY(dt1.isNull()); + dt1.setTime(QTime(12, 34, 56)); + QVERIFY(!dt1.isNull()); + dt1.setTime(QTime()); // Date still invalid, so this really clears time. + QVERIFY(dt1.isNull()); dt1.setDate(QDate(2004, 1, 2)); QVERIFY(!dt1.isNull()); dt1.setTime(QTime(12, 34, 56)); QVERIFY(!dt1.isNull()); - dt1.setTime(QTime()); + dt1.setTime(QTime()); // Actually sets time to QTime(0, 0), as date is still valid. QVERIFY(!dt1.isNull()); + dt1.setDate(QDate()); // Time remains valid + QVERIFY(!dt1.isNull()); + dt1.setTime(QTime()); // Now really sets time invalid, too + QVERIFY(dt1.isNull()); + + // Either date or time non-null => date-time isn't null: + QVERIFY(!QDateTime(QDate(), QTime(0, 0)).isNull()); + QVERIFY(!QDateTime(QDate(2022, 2, 16), QTime()).isNull()); } void tst_QDateTime::isValid() @@ -368,49 +403,61 @@ void tst_QDateTime::isValid() QVERIFY(!dt1.isValid()); dt1.setTime(QTime()); QVERIFY(!dt1.isValid()); - dt1.setTimeSpec(Qt::UTC); + dt1.setTimeZone(UTC); QVERIFY(!dt1.isValid()); dt1.setDate(QDate(2004, 1, 2)); QVERIFY(dt1.isValid()); + dt1.setTime(QTime()); // Effectively QTime(0, 0) + QVERIFY(dt1.isValid()); dt1.setDate(QDate()); QVERIFY(!dt1.isValid()); dt1.setTime(QTime(12, 34, 56)); QVERIFY(!dt1.isValid()); - dt1.setTime(QTime()); + dt1.setTime(QTime()); // Does sets time invalid, as date is invalid QVERIFY(!dt1.isValid()); + dt1.setDate(QDate(2004, 1, 2)); // Kicks time back to QTime(0, 0) + QVERIFY(dt1.isValid()); + + // Invalid date => invalid date-time: + QVERIFY(!QDateTime(QDate(), QTime(0, 0)).isValid()); + // Invalid time gets replaced with QTime(0, 0) when date is valid: + QVERIFY(QDateTime(QDate(2022, 2, 16), QTime()).isValid()); } void tst_QDateTime::date() { - QDateTime dt1(QDate(2004, 3, 24), QTime(23, 45, 57), Qt::LocalTime); + QDateTime dt1(QDate(2004, 3, 24), QTime(23, 45, 57)); QCOMPARE(dt1.date(), QDate(2004, 3, 24)); - QDateTime dt2(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::LocalTime); + QDateTime dt2(QDate(2004, 3, 25), QTime(0, 45, 57)); QCOMPARE(dt2.date(), QDate(2004, 3, 25)); - QDateTime dt3(QDate(2004, 3, 24), QTime(23, 45, 57), Qt::UTC); + QDateTime dt3(QDate(2004, 3, 24), QTime(23, 45, 57), UTC); QCOMPARE(dt3.date(), QDate(2004, 3, 24)); - QDateTime dt4(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC); + QDateTime dt4(QDate(2004, 3, 25), QTime(0, 45, 57), UTC); QCOMPARE(dt4.date(), QDate(2004, 3, 25)); } void tst_QDateTime::time() { - QDateTime dt1(QDate(2004, 3, 24), QTime(23, 45, 57), Qt::LocalTime); + QDateTime dt1(QDate(2004, 3, 24), QTime(23, 45, 57)); QCOMPARE(dt1.time(), QTime(23, 45, 57)); - QDateTime dt2(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::LocalTime); + QDateTime dt2(QDate(2004, 3, 25), QTime(0, 45, 57)); QCOMPARE(dt2.time(), QTime(0, 45, 57)); - QDateTime dt3(QDate(2004, 3, 24), QTime(23, 45, 57), Qt::UTC); + QDateTime dt3(QDate(2004, 3, 24), QTime(23, 45, 57), UTC); QCOMPARE(dt3.time(), QTime(23, 45, 57)); - QDateTime dt4(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC); + QDateTime dt4(QDate(2004, 3, 25), QTime(0, 45, 57), UTC); QCOMPARE(dt4.time(), QTime(0, 45, 57)); } +#if QT_DEPRECATED_SINCE(6, 9) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED void tst_QDateTime::timeSpec() { QDateTime dt1(QDate(2004, 1, 24), QTime(23, 45, 57)); @@ -424,49 +471,51 @@ void tst_QDateTime::timeSpec() QCOMPARE(dt1.toTimeSpec(Qt::LocalTime).timeSpec(), Qt::LocalTime); QCOMPARE(dt1.toTimeSpec(Qt::UTC).timeSpec(), Qt::UTC); - QDateTime dt2(QDate(2004, 1, 24), QTime(23, 45, 57), Qt::LocalTime); + QDateTime dt2(QDate(2004, 1, 24), QTime(23, 45, 57)); QCOMPARE(dt2.timeSpec(), Qt::LocalTime); - QDateTime dt3(QDate(2004, 1, 25), QTime(0, 45, 57), Qt::UTC); + QDateTime dt3(QDate(2004, 1, 25), QTime(0, 45, 57), UTC); QCOMPARE(dt3.timeSpec(), Qt::UTC); QDateTime dt4 = QDateTime::currentDateTime(); QCOMPARE(dt4.timeSpec(), Qt::LocalTime); } +QT_WARNING_POP +#endif void tst_QDateTime::setDate() { - QDateTime dt1(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC); + QDateTime dt1(QDate(2004, 3, 25), QTime(0, 45, 57), UTC); dt1.setDate(QDate(2004, 6, 25)); QCOMPARE(dt1.date(), QDate(2004, 6, 25)); QCOMPARE(dt1.time(), QTime(0, 45, 57)); QCOMPARE(dt1.timeSpec(), Qt::UTC); - QDateTime dt2(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::LocalTime); + QDateTime dt2(QDate(2004, 3, 25), QTime(0, 45, 57)); dt2.setDate(QDate(2004, 6, 25)); QCOMPARE(dt2.date(), QDate(2004, 6, 25)); QCOMPARE(dt2.time(), QTime(0, 45, 57)); QCOMPARE(dt2.timeSpec(), Qt::LocalTime); - QDateTime dt3(QDate(4004, 3, 25), QTime(0, 45, 57), Qt::UTC); + QDateTime dt3(QDate(4004, 3, 25), QTime(0, 45, 57), UTC); dt3.setDate(QDate(4004, 6, 25)); QCOMPARE(dt3.date(), QDate(4004, 6, 25)); QCOMPARE(dt3.time(), QTime(0, 45, 57)); QCOMPARE(dt3.timeSpec(), Qt::UTC); - QDateTime dt4(QDate(4004, 3, 25), QTime(0, 45, 57), Qt::LocalTime); + QDateTime dt4(QDate(4004, 3, 25), QTime(0, 45, 57)); dt4.setDate(QDate(4004, 6, 25)); QCOMPARE(dt4.date(), QDate(4004, 6, 25)); QCOMPARE(dt4.time(), QTime(0, 45, 57)); QCOMPARE(dt4.timeSpec(), Qt::LocalTime); - QDateTime dt5(QDate(1760, 3, 25), QTime(0, 45, 57), Qt::UTC); + QDateTime dt5(QDate(1760, 3, 25), QTime(0, 45, 57), UTC); dt5.setDate(QDate(1760, 6, 25)); QCOMPARE(dt5.date(), QDate(1760, 6, 25)); QCOMPARE(dt5.time(), QTime(0, 45, 57)); QCOMPARE(dt5.timeSpec(), Qt::UTC); - QDateTime dt6(QDate(1760, 3, 25), QTime(0, 45, 57), Qt::LocalTime); + QDateTime dt6(QDate(1760, 3, 25), QTime(0, 45, 57)); dt6.setDate(QDate(1760, 6, 25)); QCOMPARE(dt6.date(), QDate(1760, 6, 25)); QCOMPARE(dt6.time(), QTime(0, 45, 57)); @@ -478,12 +527,18 @@ void tst_QDateTime::setTime_data() QTest::addColumn<QDateTime>("dateTime"); QTest::addColumn<QTime>("newTime"); - QTest::newRow("data0") << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC) << QTime(23, 11, 22); - QTest::newRow("data1") << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::LocalTime) << QTime(23, 11, 22); - QTest::newRow("data2") << QDateTime(QDate(4004, 3, 25), QTime(0, 45, 57), Qt::UTC) << QTime(23, 11, 22); - QTest::newRow("data3") << QDateTime(QDate(4004, 3, 25), QTime(0, 45, 57), Qt::LocalTime) << QTime(23, 11, 22); - QTest::newRow("data4") << QDateTime(QDate(1760, 3, 25), QTime(0, 45, 57), Qt::UTC) << QTime(23, 11, 22); - QTest::newRow("data5") << QDateTime(QDate(1760, 3, 25), QTime(0, 45, 57), Qt::LocalTime) << QTime(23, 11, 22); + QTest::newRow("data0") + << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), UTC) << QTime(23, 11, 22); + QTest::newRow("data1") + << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57)) << QTime(23, 11, 22); + QTest::newRow("data2") + << QDateTime(QDate(4004, 3, 25), QTime(0, 45, 57), UTC) << QTime(23, 11, 22); + QTest::newRow("data3") + << QDateTime(QDate(4004, 3, 25), QTime(0, 45, 57)) << QTime(23, 11, 22); + QTest::newRow("data4") + << QDateTime(QDate(1760, 3, 25), QTime(0, 45, 57), UTC) << QTime(23, 11, 22); + QTest::newRow("data5") + << QDateTime(QDate(1760, 3, 25), QTime(0, 45, 57)) << QTime(23, 11, 22); QTest::newRow("set on std/dst") << QDateTime::currentDateTime() << QTime(23, 11, 22); } @@ -503,16 +558,73 @@ void tst_QDateTime::setTime() QCOMPARE(dateTime.timeSpec(), expectedTimeSpec); } +void tst_QDateTime::setTimeZone_data() +{ + QTest::addColumn<QDateTime>("dateTime"); + QTest::addColumn<QTimeZone>("zone"); + const QDate day(2004, 3, 25); + const QTime time(0, 45, 57); + struct { + const char *id; + QTimeZone zone; + } data[] = { + { nullptr, QTimeZone() }, // For time-zone, when supported. + { "UTC", UTC }, + { "LocalTime", QTimeZone() }, + { "Offset", QTimeZone::fromSecondsAheadOfUtc(3600) } + }; +#if QT_CONFIG(timezone) + const QTimeZone cet("Europe/Oslo"); + if (cet.isValid()) { + data[0].zone = cet; + data[0].id = "Zone"; + } +#endif + for (const auto &from : data) { + if (from.id) { + for (const auto &to : data) { + if (to.id) { + QTest::addRow("%s => %s", from.id, to.id) + << QDateTime(day, time, from.zone) << to.zone; + } + } + } + } +} + +void tst_QDateTime::setTimeZone() +{ + QFETCH(QDateTime, dateTime); + QFETCH(QTimeZone, zone); + + // QDateTime::setTimeZone() preserves the date and time rather than + // converting to the new time representation. + const QDate expectedDate(dateTime.date()); + const QTime expectedTime(dateTime.time()); + + dateTime.setTimeZone(zone); + + QCOMPARE(dateTime.date(), expectedDate); + QCOMPARE(dateTime.time(), expectedTime); + QCOMPARE(dateTime.timeRepresentation(), zone); +} + +#if QT_DEPRECATED_SINCE(6, 9) void tst_QDateTime::setTimeSpec_data() { QTest::addColumn<QDateTime>("dateTime"); QTest::addColumn<Qt::TimeSpec>("newTimeSpec"); - QTest::newRow("UTC => UTC") << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC) << Qt::UTC; - QTest::newRow("UTC => LocalTime") << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC) << Qt::LocalTime; - QTest::newRow("UTC => OffsetFromUTC") << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), Qt::UTC) << Qt::OffsetFromUTC; + QTest::newRow("UTC => UTC") + << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), UTC) << Qt::UTC; + QTest::newRow("UTC => LocalTime") + << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), UTC) << Qt::LocalTime; + QTest::newRow("UTC => OffsetFromUTC") + << QDateTime(QDate(2004, 3, 25), QTime(0, 45, 57), UTC) << Qt::OffsetFromUTC; } +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED void tst_QDateTime::setTimeSpec() { QFETCH(QDateTime, dateTime); @@ -530,56 +642,72 @@ void tst_QDateTime::setTimeSpec() else QCOMPARE(dateTime.timeSpec(), newTimeSpec); } +QT_WARNING_POP +#endif void tst_QDateTime::setSecsSinceEpoch() { QDateTime dt1; dt1.setSecsSinceEpoch(0); - QCOMPARE(dt1.toUTC(), QDate(1970, 1, 1).startOfDay(Qt::UTC)); + QCOMPARE(dt1.toUTC(), QDate(1970, 1, 1).startOfDay(UTC)); QCOMPARE(dt1.timeSpec(), Qt::LocalTime); - dt1.setTimeSpec(Qt::UTC); + dt1.setTimeZone(UTC); dt1.setSecsSinceEpoch(0); - QCOMPARE(dt1, QDate(1970, 1, 1).startOfDay(Qt::UTC)); + QCOMPARE(dt1, QDate(1970, 1, 1).startOfDay(UTC)); QCOMPARE(dt1.timeSpec(), Qt::UTC); dt1.setSecsSinceEpoch(123456); - QCOMPARE(dt1, QDateTime(QDate(1970, 1, 2), QTime(10, 17, 36), Qt::UTC)); + QCOMPARE(dt1, QDateTime(QDate(1970, 1, 2), QTime(10, 17, 36), UTC)); if (zoneIsCET) { QDateTime dt2; dt2.setSecsSinceEpoch(123456); - QCOMPARE(dt2, QDateTime(QDate(1970, 1, 2), QTime(11, 17, 36), Qt::LocalTime)); + QCOMPARE(dt2, QDateTime(QDate(1970, 1, 2), QTime(11, 17, 36))); } dt1.setSecsSinceEpoch((uint)(quint32)-123456); - QCOMPARE(dt1, QDateTime(QDate(2106, 2, 5), QTime(20, 10, 40), Qt::UTC)); + QCOMPARE(dt1, QDateTime(QDate(2106, 2, 5), QTime(20, 10, 40), UTC)); if (zoneIsCET) { QDateTime dt2; dt2.setSecsSinceEpoch((uint)(quint32)-123456); - QCOMPARE(dt2, QDateTime(QDate(2106, 2, 5), QTime(21, 10, 40), Qt::LocalTime)); + QCOMPARE(dt2, QDateTime(QDate(2106, 2, 5), QTime(21, 10, 40))); } dt1.setSecsSinceEpoch(1214567890); - QCOMPARE(dt1, QDateTime(QDate(2008, 6, 27), QTime(11, 58, 10), Qt::UTC)); + QCOMPARE(dt1, QDateTime(QDate(2008, 6, 27), QTime(11, 58, 10), UTC)); if (zoneIsCET) { QDateTime dt2; dt2.setSecsSinceEpoch(1214567890); - QCOMPARE(dt2, QDateTime(QDate(2008, 6, 27), QTime(13, 58, 10), Qt::LocalTime)); + QCOMPARE(dt2, QDateTime(QDate(2008, 6, 27), QTime(13, 58, 10))); } dt1.setSecsSinceEpoch(0x7FFFFFFF); - QCOMPARE(dt1, QDateTime(QDate(2038, 1, 19), QTime(3, 14, 7), Qt::UTC)); + QCOMPARE(dt1, QDateTime(QDate(2038, 1, 19), QTime(3, 14, 7), UTC)); if (zoneIsCET) { QDateTime dt2; dt2.setSecsSinceEpoch(0x7FFFFFFF); - QCOMPARE(dt2, QDateTime(QDate(2038, 1, 19), QTime(4, 14, 7), Qt::LocalTime)); + QCOMPARE(dt2, QDateTime(QDate(2038, 1, 19), QTime(4, 14, 7))); } - dt1 = QDateTime(QDate(2013, 1, 1), QTime(0, 0), Qt::OffsetFromUTC, 60 * 60); + dt1 = QDateTime(QDate(2013, 1, 1), QTime(0, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); dt1.setSecsSinceEpoch(123456); - QCOMPARE(dt1, QDateTime(QDate(1970, 1, 2), QTime(10, 17, 36), Qt::UTC)); + QCOMPARE(dt1, QDateTime(QDate(1970, 1, 2), QTime(10, 17, 36), UTC)); QCOMPARE(dt1.timeSpec(), Qt::OffsetFromUTC); QCOMPARE(dt1.offsetFromUtc(), 60 * 60); + + // Only testing UTC; see fromSecsSinceEpoch() for fuller test. + dt1.setTimeZone(UTC); + const qint64 maxSeconds = std::numeric_limits<qint64>::max() / 1000; + dt1.setSecsSinceEpoch(maxSeconds); + QVERIFY(dt1.isValid()); + dt1.setSecsSinceEpoch(-maxSeconds); + QVERIFY(dt1.isValid()); + dt1.setSecsSinceEpoch(maxSeconds + 1); + QVERIFY(!dt1.isValid()); + dt1.setSecsSinceEpoch(0); + QVERIFY(dt1.isValid()); + dt1.setSecsSinceEpoch(-maxSeconds - 1); + QVERIFY(!dt1.isValid()); } void tst_QDateTime::setMSecsSinceEpoch_data() @@ -590,44 +718,56 @@ void tst_QDateTime::setMSecsSinceEpoch_data() QTest::newRow("zero") << Q_INT64_C(0) - << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0), UTC) << QDateTime(QDate(1970, 1, 1), QTime(1, 0)); - QTest::newRow("-1") + QTest::newRow("+1ms") + << Q_INT64_C(+1) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0, 1), UTC) + << QDateTime(QDate(1970, 1, 1), QTime(1, 0, 0, 1)); + QTest::newRow("+1s") + << Q_INT64_C(+1000) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0, 1), UTC) + << QDateTime(QDate(1970, 1, 1), QTime(1, 0, 1)); + QTest::newRow("-1ms") << Q_INT64_C(-1) - << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59, 999), Qt::UTC) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59, 999), UTC) << QDateTime(QDate(1970, 1, 1), QTime(0, 59, 59, 999)); + QTest::newRow("-1s") + << Q_INT64_C(-1000) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59), UTC) + << QDateTime(QDate(1970, 1, 1), QTime(0, 59, 59)); QTest::newRow("123456789") << Q_INT64_C(123456789) - << QDateTime(QDate(1970, 1, 2), QTime(10, 17, 36, 789), Qt::UTC) - << QDateTime(QDate(1970, 1, 2), QTime(11, 17, 36, 789), Qt::LocalTime); + << QDateTime(QDate(1970, 1, 2), QTime(10, 17, 36, 789), UTC) + << QDateTime(QDate(1970, 1, 2), QTime(11, 17, 36, 789)); QTest::newRow("-123456789") << Q_INT64_C(-123456789) - << QDateTime(QDate(1969, 12, 30), QTime(13, 42, 23, 211), Qt::UTC) - << QDateTime(QDate(1969, 12, 30), QTime(14, 42, 23, 211), Qt::LocalTime); - QTest::newRow("non-time_t") + << QDateTime(QDate(1969, 12, 30), QTime(13, 42, 23, 211), UTC) + << QDateTime(QDate(1969, 12, 30), QTime(14, 42, 23, 211)); + QTest::newRow("post-32-bit-time_t") << (Q_INT64_C(1000) << 32) - << QDateTime(QDate(2106, 2, 7), QTime(6, 28, 16), Qt::UTC) + << QDateTime(QDate(2106, 2, 7), QTime(6, 28, 16), UTC) << QDateTime(QDate(2106, 2, 7), QTime(7, 28, 16)); QTest::newRow("very-large") << (Q_INT64_C(123456) << 32) - << QDateTime(QDate(18772, 8, 15), QTime(1, 8, 14, 976), Qt::UTC) + << QDateTime(QDate(18772, 8, 15), QTime(1, 8, 14, 976), UTC) << QDateTime(QDate(18772, 8, 15), QTime(3, 8, 14, 976)); QTest::newRow("old min (Tue Nov 25 00:00:00 -4714)") << Q_INT64_C(-210866716800000) - << QDateTime(QDate::fromJulianDay(1), QTime(0, 0), Qt::UTC) - << QDateTime(QDate::fromJulianDay(1), QTime(1, 0)); + << QDateTime(QDate::fromJulianDay(1), QTime(0, 0), UTC) + << QDateTime(QDate::fromJulianDay(1), QTime(1, 0)).addSecs(preZoneFix); QTest::newRow("old max (Tue Jun 3 21:59:59 5874898)") << Q_INT64_C(185331720376799999) - << QDateTime(QDate::fromJulianDay(0x7fffffff), QTime(21, 59, 59, 999), Qt::UTC) + << QDateTime(QDate::fromJulianDay(0x7fffffff), QTime(21, 59, 59, 999), UTC) << QDateTime(QDate::fromJulianDay(0x7fffffff), QTime(23, 59, 59, 999)); QTest::newRow("min") << std::numeric_limits<qint64>::min() - << QDateTime(QDate(-292275056, 5, 16), QTime(16, 47, 4, 192), Qt::UTC) - << QDateTime(QDate(-292275056, 5, 16), QTime(17, 47, 4, 192), Qt::LocalTime); + << QDateTime(QDate(-292275056, 5, 16), QTime(16, 47, 4, 192), UTC) + << QDateTime(QDate(-292275056, 5, 16), QTime(17, 47, 4, 192).addSecs(preZoneFix)); QTest::newRow("max") << std::numeric_limits<qint64>::max() - << QDateTime(QDate(292278994, 8, 17), QTime(7, 12, 55, 807), Qt::UTC) - << QDateTime(QDate(292278994, 8, 17), QTime(9, 12, 55, 807), Qt::LocalTime); + << QDateTime(QDate(292278994, 8, 17), QTime(7, 12, 55, 807), UTC) + << QDateTime(QDate(292278994, 8, 17), QTime(9, 12, 55, 807)); } void tst_QDateTime::setMSecsSinceEpoch() @@ -635,9 +775,10 @@ void tst_QDateTime::setMSecsSinceEpoch() QFETCH(qint64, msecs); QFETCH(QDateTime, utc); QFETCH(QDateTime, cet); + using Bound = std::numeric_limits<qint64>; QDateTime dt; - dt.setTimeSpec(Qt::UTC); + dt.setTimeZone(UTC); dt.setMSecsSinceEpoch(msecs); QCOMPARE(dt, utc); @@ -646,14 +787,14 @@ void tst_QDateTime::setMSecsSinceEpoch() QCOMPARE(dt.timeSpec(), Qt::UTC); { - QDateTime dt1 = QDateTime::fromMSecsSinceEpoch(msecs, Qt::UTC); + QDateTime dt1 = QDateTime::fromMSecsSinceEpoch(msecs, UTC); QCOMPARE(dt1, utc); QCOMPARE(dt1.date(), utc.date()); QCOMPARE(dt1.time(), utc.time()); QCOMPARE(dt1.timeSpec(), Qt::UTC); } { - QDateTime dt1(utc.date(), utc.time(), Qt::UTC); + QDateTime dt1(utc.date(), utc.time(), UTC); QCOMPARE(dt1, utc); QCOMPARE(dt1.date(), utc.date()); QCOMPARE(dt1.time(), utc.time()); @@ -668,17 +809,21 @@ void tst_QDateTime::setMSecsSinceEpoch() QCOMPARE(dt1.timeSpec(), Qt::UTC); } - if (zoneIsCET) { + if (zoneIsCET && (msecs == Bound::max() + // LocalTime will also overflow for min in a CET zone west + // of Greenwich (Europe/Madrid): + || (preZoneFix < -3600 && msecs == Bound::min()))) { + QVERIFY(!cet.isValid()); // overflows + } else if (zoneIsCET) { + QVERIFY(cet.isValid()); QCOMPARE(dt.toLocalTime(), cet); // Test converting from LocalTime to UTC back to LocalTime. QDateTime localDt; - localDt.setTimeSpec(Qt::LocalTime); + localDt.setTimeZone(QTimeZone::LocalTime); localDt.setMSecsSinceEpoch(msecs); - // LocalTime will overflow for max - if (msecs != std::numeric_limits<qint64>::max()) - QCOMPARE(localDt, utc); + QCOMPARE(localDt, utc); QCOMPARE(localDt.timeSpec(), Qt::LocalTime); // Compare result for LocalTime to TimeZone @@ -688,12 +833,13 @@ void tst_QDateTime::setMSecsSinceEpoch() dt2.setTimeZone(europe); #endif dt2.setMSecsSinceEpoch(msecs); - QCOMPARE(dt2.date(), cet.date()); + if (cet.date().year() >= 1970 || cet.date() == utc.date()) + QCOMPARE(dt2.date(), cet.date()); - // don't compare the time if the date is too early or too late: prior - // to 1916, timezones in Europe were not standardised and some OS APIs - // have hard limits. Let's restrict it to the 32-bit Unix range - if (dt2.date().year() >= 1970 && dt2.date().year() <= 2037) + // Don't compare the time if the date is too early: prior to the early + // 20th century, timezones in Europe were not standardised. Limit to the + // same year-range as we used when determining zoneIsCET: + if (cet.date().year() >= 1970 && cet.date().year() <= 2037) QCOMPARE(dt2.time(), cet.time()); #if QT_CONFIG(timezone) QCOMPARE(dt2.timeSpec(), Qt::TimeZone); @@ -702,18 +848,32 @@ void tst_QDateTime::setMSecsSinceEpoch() } QCOMPARE(dt.toMSecsSinceEpoch(), msecs); + QCOMPARE(qint64(dt.toSecsSinceEpoch()), msecs / 1000); - if (quint64(msecs / 1000) < 0xFFFFFFFF) { - QCOMPARE(qint64(dt.toSecsSinceEpoch()), msecs / 1000); - } - - QDateTime reference(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime reference(QDate(1970, 1, 1), QTime(0, 0), UTC); QCOMPARE(dt, reference.addMSecs(msecs)); -} -void tst_QDateTime::fromMSecsSinceEpoch_data() -{ - setMSecsSinceEpoch_data(); + // Tests that we correctly recognize when we fall off the extremities: + if (msecs == Bound::max()) { + QDateTime off(QDate(1970, 1, 1).startOfDay(QTimeZone::fromSecondsAheadOfUtc(1))); + off.setMSecsSinceEpoch(msecs); + QVERIFY(!off.isValid()); + } else if (msecs == Bound::min()) { + QDateTime off(QDate(1970, 1, 1).startOfDay(QTimeZone::fromSecondsAheadOfUtc(-1))); + off.setMSecsSinceEpoch(msecs); + QVERIFY(!off.isValid()); + } + + // Check overflow; only robust if local time is the same at epoch as relevant bound. + // See setting of LocalTimeType values for details. + if (epochTimeType == LocalTimeAheadOfUtc + ? distantTimeType == LocalTimeAheadOfUtc && msecs == Bound::max() + : (solarMeanType == LocalTimeBehindUtc && msecs == Bound::min() + && epochTimeType == LocalTimeBehindUtc)) { + QDateTime curt = QDate(1970, 1, 1).startOfDay(); // initially in short-form + curt.setMSecsSinceEpoch(msecs); // Overflows due to offset + QVERIFY(!curt.isValid()); + } } void tst_QDateTime::fromMSecsSinceEpoch() @@ -721,80 +881,113 @@ void tst_QDateTime::fromMSecsSinceEpoch() QFETCH(qint64, msecs); QFETCH(QDateTime, utc); QFETCH(QDateTime, cet); - - QDateTime dtLocal = QDateTime::fromMSecsSinceEpoch(msecs, Qt::LocalTime); - QDateTime dtUtc = QDateTime::fromMSecsSinceEpoch(msecs, Qt::UTC); - QDateTime dtOffset = QDateTime::fromMSecsSinceEpoch(msecs, Qt::OffsetFromUTC, 60*60); using Bound = std::numeric_limits<qint64>; - // LocalTime will overflow for "min" or "max" tests, depending on whether - // you're East or West of Greenwich. In UTC, we won't overflow. - const bool localOverflow = (localTimeType == LocalTimeAheadOfUtc ? msecs == Bound::max() - : localTimeType == LocalTimeBehindUtc ? msecs == Bound::min() - : false); - if (!localOverflow) + QDateTime dtLocal = QDateTime::fromMSecsSinceEpoch(msecs); + QDateTime dtUtc = QDateTime::fromMSecsSinceEpoch(msecs, UTC); + QDateTime dtOffset + = QDateTime::fromMSecsSinceEpoch(msecs, QTimeZone::fromSecondsAheadOfUtc(60 * 60)); + // LocalTime will overflow for "min" or "max" tests, depending on whether + // you're East or West of Greenwich. In UTC, we won't overflow. If we're + // actually west of Greenwich but (e.g. Europe/Madrid) our zone claims east, + // "min" can also overflow (case only caught if local time is CET). + const bool localOverflow = + (distantTimeType == LocalTimeAheadOfUtc && (msecs == Bound::max() || preZoneFix < -3600)) + || (solarMeanType == LocalTimeBehindUtc && msecs == Bound::min()); + if (!localOverflow) // Can fail if offset changes sign, e.g. Alaska, Philippines. QCOMPARE(dtLocal, utc); QCOMPARE(dtUtc, utc); QCOMPARE(dtUtc.date(), utc.date()); QCOMPARE(dtUtc.time(), utc.time()); - QCOMPARE(dtOffset, utc); - QCOMPARE(dtOffset.offsetFromUtc(), 60*60); - if (msecs != Bound::max()) // Offset is positive, so overflows max + if (msecs == Bound::max()) { // Offset is positive, so overflows max + QVERIFY(!dtOffset.isValid()); + } else { + QCOMPARE(dtOffset, utc); + QCOMPARE(dtOffset.offsetFromUtc(), 60*60); QCOMPARE(dtOffset.time(), utc.time().addMSecs(60*60*1000)); + } if (zoneIsCET) { QCOMPARE(dtLocal.toLocalTime(), cet); QCOMPARE(dtUtc.toLocalTime(), cet); - QCOMPARE(dtOffset.toLocalTime(), cet); + if (msecs != Bound::max()) + QCOMPARE(dtOffset.toLocalTime(), cet); } if (!localOverflow) QCOMPARE(dtLocal.toMSecsSinceEpoch(), msecs); QCOMPARE(dtUtc.toMSecsSinceEpoch(), msecs); - QCOMPARE(dtOffset.toMSecsSinceEpoch(), msecs); + if (msecs != Bound::max()) + QCOMPARE(dtOffset.toMSecsSinceEpoch(), msecs); - if (quint64(msecs / 1000) < 0xFFFFFFFF) { + if (!localOverflow) QCOMPARE(qint64(dtLocal.toSecsSinceEpoch()), msecs / 1000); - QCOMPARE(qint64(dtUtc.toSecsSinceEpoch()), msecs / 1000); + QCOMPARE(qint64(dtUtc.toSecsSinceEpoch()), msecs / 1000); + if (msecs != Bound::max()) QCOMPARE(qint64(dtOffset.toSecsSinceEpoch()), msecs / 1000); - } - QDateTime reference(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime reference(QDate(1970, 1, 1), QTime(0, 0), UTC); if (!localOverflow) QCOMPARE(dtLocal, reference.addMSecs(msecs)); QCOMPARE(dtUtc, reference.addMSecs(msecs)); - QCOMPARE(dtOffset, reference.addMSecs(msecs)); + if (msecs != Bound::max()) + QCOMPARE(dtOffset, reference.addMSecs(msecs)); } void tst_QDateTime::fromSecsSinceEpoch() { + // Compare setSecsSinceEpoch() const qint64 maxSeconds = std::numeric_limits<qint64>::max() / 1000; + const QDateTime early = QDateTime::fromSecsSinceEpoch(-maxSeconds, UTC); + const QDateTime late = QDateTime::fromSecsSinceEpoch(maxSeconds, UTC); + + QVERIFY(late.isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds + 1, UTC).isValid()); + QVERIFY(early.isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(-maxSeconds - 1, UTC).isValid()); - QVERIFY(QDateTime::fromSecsSinceEpoch(maxSeconds).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds + 1).isValid()); - QVERIFY(QDateTime::fromSecsSinceEpoch(-maxSeconds).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(-maxSeconds - 1).isValid()); + // Local time: need to adjust for its zone offset + const int lateOffset = late.addYears(-1).toLocalTime().offsetFromUtc(); +#if QT_CONFIG(timezone) + // Check what system zone believes in, as it's used as fall-back to cope + // with times outside the system time_t functions' range, or overflow on the + // results of using those functions. (It seems glibc's handling of + // Australasian zones parts company with the IANA DB after about 5881580 CE, + // leaving NZ in permanent DST after that, for example.) Of course, if + // that's less than lateOffset (as it is for glibc's similar handling of + // MET), the fall-back code will also fail when the primary code fails, so + // use the lesser of these late offsets. + const int lateZone = qMin(QTimeZone::systemTimeZone().offsetFromUtc(late), lateOffset); +#else + const int lateZone = lateOffset; +#endif - QVERIFY(QDateTime::fromSecsSinceEpoch(maxSeconds, Qt::UTC).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds + 1, Qt::UTC).isValid()); - QVERIFY(QDateTime::fromSecsSinceEpoch(-maxSeconds, Qt::UTC).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(-maxSeconds - 1, Qt::UTC).isValid()); + const qint64 last = maxSeconds - qMax(lateZone, 0); + QVERIFY(QDateTime::fromSecsSinceEpoch(last).isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(last + 1).isValid()); + const qint64 first = -maxSeconds - qMin(early.addYears(1).toLocalTime().offsetFromUtc(), 0); + QVERIFY(QDateTime::fromSecsSinceEpoch(first).isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(first - 1).isValid()); // Use an offset for which .toUTC()'s return would flip the validity: - QVERIFY(QDateTime::fromSecsSinceEpoch(maxSeconds, Qt::OffsetFromUTC, 7200).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds + 1, Qt::OffsetFromUTC, -7200).isValid()); - QVERIFY(QDateTime::fromSecsSinceEpoch(-maxSeconds, Qt::OffsetFromUTC, -7200).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(-maxSeconds - 1, Qt::OffsetFromUTC, 7200).isValid()); + QVERIFY(QDateTime::fromSecsSinceEpoch(maxSeconds - 7200, + QTimeZone::fromSecondsAheadOfUtc(7200)).isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds - 7199, + QTimeZone::fromSecondsAheadOfUtc(7200)).isValid()); + QVERIFY(QDateTime::fromSecsSinceEpoch(7200 - maxSeconds, + QTimeZone::fromSecondsAheadOfUtc(-7200)).isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(7199 - maxSeconds, + QTimeZone::fromSecondsAheadOfUtc(-7200)).isValid()); #if QT_CONFIG(timezone) // As for offset, use zones each side of UTC: const QTimeZone west("UTC-02:00"), east("UTC+02:00"); - QVERIFY(QDateTime::fromSecsSinceEpoch(maxSeconds, east).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds + 1, west).isValid()); - QVERIFY(QDateTime::fromSecsSinceEpoch(-maxSeconds, west).isValid()); - QVERIFY(!QDateTime::fromSecsSinceEpoch(-maxSeconds - 1, east).isValid()); + QVERIFY(QDateTime::fromSecsSinceEpoch(maxSeconds, west).isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(maxSeconds + 1, east).isValid()); + QVERIFY(QDateTime::fromSecsSinceEpoch(-maxSeconds, east).isValid()); + QVERIFY(!QDateTime::fromSecsSinceEpoch(-maxSeconds - 1, west).isValid()); #endif // timezone } @@ -809,23 +1002,23 @@ void tst_QDateTime::toString_isoDate_data() << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34)) << Qt::ISODate << QString("1978-11-09T13:28:34"); QTest::newRow("UTC") - << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34), Qt::UTC) + << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34), UTC) << Qt::ISODate << QString("1978-11-09T13:28:34Z"); QDateTime dt(QDate(1978, 11, 9), QTime(13, 28, 34)); - dt.setOffsetFromUtc(19800); + dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(19800)); QTest::newRow("positive OffsetFromUTC") << dt << Qt::ISODate << QString("1978-11-09T13:28:34+05:30"); - dt.setOffsetFromUtc(-7200); + dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-7200)); QTest::newRow("negative OffsetFromUTC") << dt << Qt::ISODate << QString("1978-11-09T13:28:34-02:00"); - dt.setOffsetFromUtc(-900); + dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-900)); QTest::newRow("negative non-integral OffsetFromUTC") << dt << Qt::ISODate << QString("1978-11-09T13:28:34-00:15"); - QTest::newRow("invalid") - << QDateTime(QDate(-1, 11, 9), QTime(13, 28, 34), Qt::UTC) + QTest::newRow("invalid") // ISODate < 2019 doesn't allow -ve year numbers; QTBUG-91070 + << QDateTime(QDate(-1, 11, 9), QTime(13, 28, 34), UTC) << Qt::ISODate << QString(); QTest::newRow("without-ms") << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34, 20)) @@ -837,31 +1030,32 @@ void tst_QDateTime::toString_isoDate_data() void tst_QDateTime::toString_isoDate() { - QFETCH(QDateTime, datetime); - QFETCH(Qt::DateFormat, format); - QFETCH(QString, expected); + QFETCH(const QDateTime, datetime); + QFETCH(const Qt::DateFormat, format); + QFETCH(const QString, expected); - QString result = datetime.toString(format); + const QString result = datetime.toString(format); QCOMPARE(result, expected); - QDateTime resultDatetime = QDateTime::fromString(result, format); - // If expecting invalid result the datetime may still be valid, i.e. year < 0 or > 9999 - if (!expected.isEmpty()) { - QEXPECT_FAIL("without-ms", "Qt::ISODate truncates milliseconds (QTBUG-56552)", Abort); - - QCOMPARE(resultDatetime, datetime); - QCOMPARE(resultDatetime.date(), datetime.date()); - QCOMPARE(resultDatetime.time(), datetime.time()); - QCOMPARE(resultDatetime.timeSpec(), datetime.timeSpec()); - QCOMPARE(resultDatetime.offsetFromUtc(), datetime.offsetFromUtc()); - } else { + const QDateTime resultDatetime = QDateTime::fromString(result, format); + if (QByteArrayView(QTest::currentDataTag()) == "invalid") { QCOMPARE(resultDatetime, QDateTime()); + } else { + const QDateTime when = + QByteArrayView(QTest::currentDataTag()) == "without-ms" + ? datetime.addMSecs(-datetime.time().msec()) : datetime; + QCOMPARE(resultDatetime.toMSecsSinceEpoch(), when.toMSecsSinceEpoch()); + QCOMPARE(resultDatetime, when); + QCOMPARE(resultDatetime.date(), when.date()); + QCOMPARE(resultDatetime.time(), when.time()); + QCOMPARE(resultDatetime.timeSpec(), when.timeSpec()); + QCOMPARE(resultDatetime.offsetFromUtc(), when.offsetFromUtc()); } } void tst_QDateTime::toString_isoDate_extra() { - QDateTime dt = QDateTime::fromMSecsSinceEpoch(0, Qt::UTC); + QDateTime dt = QDateTime::fromMSecsSinceEpoch(0, UTC); QCOMPARE(dt.toString(Qt::ISODate), QLatin1String("1970-01-01T00:00:00Z")); #if QT_CONFIG(timezone) QTimeZone PST("America/Vancouver"); @@ -889,15 +1083,16 @@ void tst_QDateTime::toString_textDate_data() const QString wednesdayJanuary = QLocale::c().dayName(3, QLocale::ShortFormat) + ' ' + QLocale::c().monthName(1, QLocale::ShortFormat); - QTest::newRow("localtime") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), Qt::LocalTime) + // ### Qt 7 GMT: change to UTC - see matching QDateTime::fromString() comment + QTest::newRow("localtime") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3)) << wednesdayJanuary + QString(" 2 01:02:03 2013"); - QTest::newRow("utc") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), Qt::UTC) + QTest::newRow("utc") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), UTC) << wednesdayJanuary + QString(" 2 01:02:03 2013 GMT"); - QTest::newRow("offset+") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), Qt::OffsetFromUTC, - 10 * 60 * 60) + QTest::newRow("offset+") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), + QTimeZone::fromSecondsAheadOfUtc(10 * 60 * 60)) << wednesdayJanuary + QString(" 2 01:02:03 2013 GMT+1000"); - QTest::newRow("offset-") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), Qt::OffsetFromUTC, - -10 * 60 * 60) + QTest::newRow("offset-") << QDateTime(QDate(2013, 1, 2), QTime(1, 2, 3), + QTimeZone::fromSecondsAheadOfUtc(-10 * 60 * 60)) << wednesdayJanuary + QString(" 2 01:02:03 2013 GMT-1000"); QTest::newRow("invalid") << QDateTime() << QString(""); @@ -923,18 +1118,16 @@ void tst_QDateTime::toString_textDate() void tst_QDateTime::toString_textDate_extra() { + // ### Qt 7 GMT: change to UTC - see matching QDateTime::fromString() comment auto endsWithGmt = [](const QDateTime &dt) { return dt.toString().endsWith(QLatin1String("GMT")); }; - QDateTime dt = QDateTime::fromMSecsSinceEpoch(0, Qt::LocalTime); + QDateTime dt = QDateTime::fromMSecsSinceEpoch(0); QVERIFY(!endsWithGmt(dt)); - dt = QDateTime::fromMSecsSinceEpoch(0, Qt::UTC).toLocalTime(); + dt = QDateTime::fromMSecsSinceEpoch(0, UTC).toLocalTime(); QVERIFY(!endsWithGmt(dt)); #if QT_CONFIG(timezone) -# if defined Q_OS_UNIX && !defined Q_OS_DARWIN && !defined Q_OS_ANDROID -# define CORRECT_ZONE_ABBREV -# endif // QTBUG-57320, QTBUG-57298, QTBUG-68833 if (QTimeZone::systemTimeZone().offsetFromUtc(dt)) QVERIFY(dt.toString() != QLatin1String("Thu Jan 1 00:00:00 1970")); else @@ -943,11 +1136,7 @@ void tst_QDateTime::toString_textDate_extra() QTimeZone PST("America/Vancouver"); if (PST.isValid()) { dt = QDateTime::fromMSecsSinceEpoch(0, PST); -# ifdef CORRECT_ZONE_ABBREV - QCOMPARE(dt.toString(), QLatin1String("Wed Dec 31 16:00:00 1969 PST")); -# else - QVERIFY(dt.toString().startsWith(QLatin1String("Wed Dec 31 16:00:00 1969 "))); -# endif + QCOMPARE(dt.toString(), QLatin1String("Wed Dec 31 16:00:00 1969 UTC-08:00")); dt = dt.toLocalTime(); QVERIFY(!endsWithGmt(dt)); } else { @@ -956,11 +1145,7 @@ void tst_QDateTime::toString_textDate_extra() QTimeZone CET("Europe/Berlin"); if (CET.isValid()) { dt = QDateTime::fromMSecsSinceEpoch(0, CET); -# ifdef CORRECT_ZONE_ABBREV - QCOMPARE(dt.toString(), QLatin1String("Thu Jan 1 01:00:00 1970 CET")); -# else - QVERIFY(dt.toString().startsWith(QLatin1String("Thu Jan 1 01:00:00 1970 "))); -# endif + QCOMPARE(dt.toString(), QLatin1String("Thu Jan 1 01:00:00 1970 UTC+01:00")); dt = dt.toLocalTime(); QVERIFY(!endsWithGmt(dt)); } else { @@ -972,7 +1157,7 @@ void tst_QDateTime::toString_textDate_extra() else QCOMPARE(dt.toString(), QLatin1String("Thu Jan 1 00:00:00 1970")); #endif - dt = QDateTime::fromMSecsSinceEpoch(0, Qt::UTC); + dt = QDateTime::fromMSecsSinceEpoch(0, UTC); QVERIFY(endsWithGmt(dt)); } @@ -987,22 +1172,22 @@ void tst_QDateTime::toString_rfcDate_data() << QString("09 Nov 1978 13:28:34 +0100"); } QTest::newRow("UTC") - << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34), Qt::UTC) + << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34), UTC) << QString("09 Nov 1978 13:28:34 +0000"); QDateTime dt(QDate(1978, 11, 9), QTime(13, 28, 34)); - dt.setOffsetFromUtc(19800); + dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(19800)); QTest::newRow("positive OffsetFromUTC") << dt << QString("09 Nov 1978 13:28:34 +0530"); - dt.setOffsetFromUtc(-7200); + dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-7200)); QTest::newRow("negative OffsetFromUTC") << dt << QString("09 Nov 1978 13:28:34 -0200"); QTest::newRow("invalid") - << QDateTime(QDate(1978, 13, 9), QTime(13, 28, 34), Qt::UTC) + << QDateTime(QDate(1978, 13, 9), QTime(13, 28, 34), UTC) << QString(); QTest::newRow("999 milliseconds UTC") - << QDateTime(QDate(2000, 1, 1), QTime(13, 28, 34, 999), Qt::UTC) + << QDateTime(QDate(2000, 1, 1), QTime(13, 28, 34, 999), UTC) << QString("01 Jan 2000 13:28:34 +0000"); } @@ -1034,27 +1219,44 @@ void tst_QDateTime::toString_strformat() { // Most tests are in QLocale, just test that the api works. QDate testDate(2013, 1, 1); - QTime testTime(1, 2, 3); - QDateTime testDateTime(testDate, testTime, Qt::UTC); + QTime testTime(1, 2, 3, 456); + QDateTime testDateTime(testDate, testTime, UTC); QCOMPARE(testDate.toString("yyyy-MM-dd"), QString("2013-01-01")); QCOMPARE(testTime.toString("hh:mm:ss"), QString("01:02:03")); + QCOMPARE(testTime.toString("hh:mm:ss.zz"), QString("01:02:03.456")); QCOMPARE(testDateTime.toString("yyyy-MM-dd hh:mm:ss t"), QString("2013-01-01 01:02:03 UTC")); + QCOMPARE(testDateTime.toString("yyyy-MM-dd hh:mm:ss tt"), QString("2013-01-01 01:02:03 +0000")); + QCOMPARE(testDateTime.toString("yyyy-MM-dd hh:mm:ss ttt"), QString("2013-01-01 01:02:03 +00:00")); + QCOMPARE(testDateTime.toString("yyyy-MM-dd hh:mm:ss tttt"), QString("2013-01-01 01:02:03 UTC")); } #endif // datestring void tst_QDateTime::addDays() { - for (int pass = 0; pass < 2; ++pass) { - QDateTime dt(QDate(2004, 1, 1), QTime(12, 34, 56), pass == 0 ? Qt::LocalTime : Qt::UTC); - dt = dt.addDays(185); + const QTimeZone zones[] = { + QTimeZone(QTimeZone::LocalTime), + QTimeZone(QTimeZone::UTC), +#if QT_CONFIG(timezone) + QTimeZone("Europe/Oslo"), +#endif + QTimeZone::fromSecondsAheadOfUtc(3600) + }; + for (const auto &zone : zones) { + QDateTime dt = QDateTime(QDate(2004, 1, 1), QTime(12, 34, 56), zone).addDays(185); QVERIFY(dt.date().year() == 2004 && dt.date().month() == 7 && dt.date().day() == 4); QVERIFY(dt.time().hour() == 12 && dt.time().minute() == 34 && dt.time().second() == 56 && dt.time().msec() == 0); - QCOMPARE(dt.timeSpec(), (pass == 0 ? Qt::LocalTime : Qt::UTC)); + QCOMPARE(dt.timeRepresentation(), zone); dt = dt.addDays(-185); QCOMPARE(dt.date(), QDate(2004, 1, 1)); QCOMPARE(dt.time(), QTime(12, 34, 56)); + + // Test we can do this before time-zones existed: + dt = QDateTime(QDate(1704, 1, 1), QTime(12, 0), zone).addDays(185); + QCOMPARE(dt.date(), QDate(1704, 7, 4)); + QCOMPARE(dt.time(), QTime(12, 0)); + QCOMPARE(dt.timeRepresentation(), zone); } QDateTime dt(QDate(1752, 9, 14), QTime(12, 34, 56)); @@ -1069,33 +1271,136 @@ void tst_QDateTime::addDays() } // Test preserves TimeSpec - QDateTime dt1(QDate(2013, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime dt1(QDate(2013, 1, 1), QTime(0, 0), UTC); QDateTime dt2 = dt1.addDays(2); QCOMPARE(dt2.date(), QDate(2013, 1, 3)); QCOMPARE(dt2.time(), QTime(0, 0)); QCOMPARE(dt2.timeSpec(), Qt::UTC); - dt1 = QDateTime(QDate(2013, 1, 1), QTime(0, 0), Qt::LocalTime); + dt1 = QDateTime(QDate(2013, 1, 1), QTime(0, 0)); dt2 = dt1.addDays(2); QCOMPARE(dt2.date(), QDate(2013, 1, 3)); QCOMPARE(dt2.time(), QTime(0, 0)); QCOMPARE(dt2.timeSpec(), Qt::LocalTime); - dt1 = QDateTime(QDate(2013, 1, 1), QTime(0, 0), Qt::OffsetFromUTC, 60*60); + dt1 = QDateTime(QDate(2013, 1, 1), QTime(0, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); dt2 = dt1.addDays(2); QCOMPARE(dt2.date(), QDate(2013, 1, 3)); QCOMPARE(dt2.time(), QTime(0, 0)); QCOMPARE(dt2.timeSpec(), Qt::OffsetFromUTC); QCOMPARE(dt2.offsetFromUtc(), 60 * 60); - // test last second of 1969 *is* valid (despite being time_t(-1)) - dt1 = QDateTime(QDate(1970, 1, 1), QTime(23, 59, 59)); - dt2 = dt1.addDays(-1); - QVERIFY(dt2.isValid()); +#if QT_CONFIG(timezone) + const QTimeZone cet("Europe/Oslo"); + if (cet.isValid()) { + dt1 = QDate(2022, 1, 10).startOfDay(cet); + dt2 = dt1.addDays(2); // QTBUG-99668: should not assert + QCOMPARE(dt2.date(), QDate(2022, 1, 12)); + QCOMPARE(dt2.time(), QTime(0, 0)); + QCOMPARE(dt2.timeSpec(), Qt::TimeZone); + QCOMPARE(dt2.timeZone(), cet); + } +# ifndef INADEQUATE_TZ_DATA + if (const QTimeZone lint("Pacific/Kiritimati"); lint.isValid()) { + // Line Islands Time skipped Sat 1994-12-31: + dt1 = QDateTime(QDate(1994, 12, 30), QTime(12, 0), lint); + dt2 = QDateTime(QDate(1995, 1, 1), QTime(12, 0), lint); + // Trying to step into the hole gets the other side: + QCOMPARE(dt1.addDays(1), dt2); + QCOMPARE(dt2.addDays(-1), dt1); + // But the other side is in fact two days away: + QCOMPARE(dt1.addDays(2), dt2); + QCOMPARE(dt2.addDays(-2), dt1); + QCOMPARE(dt1.daysTo(dt2), 2); + } +# ifndef Q_OS_DARWIN + if (const QTimeZone alaska("America/Anchorage"); alaska.isValid()) { + // On Julian date 1867, Sat Oct 7 (at 14:31 local solar mean time for + // Anchorage, 15:30 LMT in Sitka, which hosted the transfer ceremony) + // Russia sold Alaska to the USA, which changed the calendar to + // Gregorian, hence the date to Fri Oct 18. Compare addSecs:Alaska-Day. + // Friday evening and Saturday morning were repeated, with different dates. + // Friday noon, as described by the Russians: + dt1 = QDateTime(QDate(1867, 10, 6, QCalendar(QCalendar::System::Julian)), + QTime(12, 0), alaska); + // Sunday noon, as described by the Americans: + dt2 = QDateTime(QDate(1867, 10, 20), QTime(12, 0), alaska); + // Three elapsed days, but daysTo() and addDays only see two: + QCOMPARE(dt1.addDays(2), dt2); + QCOMPARE(dt2.addDays(-2), dt1); + QCOMPARE(dt1.daysTo(dt2), 2); + // Stepping into the duplicated day (Julian 7th, Gregorian 19th) gets + // the nearer side, with the same nominal date (and time): + QCOMPARE(dt1.addDays(1).date(), dt2.addDays(-1).date()); + QCOMPARE(dt1.addDays(1).time(), dt2.addDays(-1).time()); + QCOMPARE(dt1.addDays(1).daysTo(dt2.addDays(-1)), 0); + // Yet they differ by a day: + QCOMPARE_NE(dt1.addDays(1), dt2.addDays(-1)); + QCOMPARE(dt1.addDays(1).secsTo(dt2.addDays(-1)), 24 * 60 * 60); + // Stepping from one duplicate one day towards the other jumps it: + QCOMPARE(dt1, dt2.addDays(-1).addDays(-1)); + QCOMPARE(dt1.addDays(1).addDays(1), dt2); + } +# endif // Darwin +# endif // inadequate zone data +#endif // timezone - // ### test invalid QDateTime() + // Baja Mexico has a transition at the epoch, see fromStringDateFormat_data(). + if (QDateTime(QDate(1969, 12, 30), QTime(0, 0)).secsTo( + QDateTime(QDate(1970, 1, 2), QTime(0, 0))) == 3 * 24 * 60 * 60) { + // Test last UTC second of 1969 *is* valid (despite being time_t(-1)) + dt1 = QDateTime(QDate(1969, 12, 30), QTime(23, 59, 59), UTC).toLocalTime().addDays(1); + QVERIFY(dt1.isValid()); + QCOMPARE(dt1.toSecsSinceEpoch(), -1); + dt2 = QDateTime(QDate(1970, 1, 1), QTime(23, 59, 59), UTC).toLocalTime().addDays(-1); + QVERIFY(dt2.isValid()); + QCOMPARE(dt2.toSecsSinceEpoch(), -1); + } } +void tst_QDateTime::addInvalid() +{ + QDateTime bad; + QVERIFY(!bad.isValid()); + QVERIFY(bad.isNull()); + + QDateTime offset = bad.addDays(2); + QVERIFY(offset.isNull()); + offset = bad.addMonths(-1); + QVERIFY(offset.isNull()); + offset = bad.addYears(23); + QVERIFY(offset.isNull()); + offset = bad.addSecs(73); + QVERIFY(offset.isNull()); + offset = bad.addMSecs(73); + QVERIFY(offset.isNull()); + + QDateTime bound = QDateTime::fromMSecsSinceEpoch(std::numeric_limits<qint64>::min(), UTC); + QVERIFY(bound.isValid()); + offset = bound.addMSecs(-1); + QVERIFY(!offset.isValid()); + offset = bound.addSecs(-1); + QVERIFY(!offset.isValid()); + offset = bound.addDays(-1); + QVERIFY(!offset.isValid()); + offset = bound.addMonths(-1); + QVERIFY(!offset.isValid()); + offset = bound.addYears(-1); + QVERIFY(!offset.isValid()); + + bound.setMSecsSinceEpoch(std::numeric_limits<qint64>::max()); + QVERIFY(bound.isValid()); + offset = bound.addMSecs(1); + QVERIFY(!offset.isValid()); + offset = bound.addSecs(1); + QVERIFY(!offset.isValid()); + offset = bound.addDays(1); + QVERIFY(!offset.isValid()); + offset = bound.addMonths(1); + QVERIFY(!offset.isValid()); + offset = bound.addYears(1); + QVERIFY(!offset.isValid()); +} void tst_QDateTime::addMonths_data() { @@ -1149,13 +1454,13 @@ void tst_QDateTime::addMonths() QCOMPARE(end.time(), testTime); QCOMPARE(end.timeSpec(), Qt::LocalTime); - start = QDateTime(testDate, testTime, Qt::UTC); + start = QDateTime(testDate, testTime, UTC); end = start.addMonths(months); QCOMPARE(end.date(), resultDate); QCOMPARE(end.time(), testTime); QCOMPARE(end.timeSpec(), Qt::UTC); - start = QDateTime(testDate, testTime, Qt::OffsetFromUTC, 60 * 60); + start = QDateTime(testDate, testTime, QTimeZone::fromSecondsAheadOfUtc(60 * 60)); end = start.addMonths(months); QCOMPARE(end.date(), resultDate); QCOMPARE(end.time(), testTime); @@ -1201,13 +1506,13 @@ void tst_QDateTime::addYears() QCOMPARE(end.time(), testTime); QCOMPARE(end.timeSpec(), Qt::LocalTime); - start = QDateTime(startDate, testTime, Qt::UTC); + start = QDateTime(startDate, testTime, UTC); end = start.addYears(years1).addYears(years2); QCOMPARE(end.date(), resultDate); QCOMPARE(end.time(), testTime); QCOMPARE(end.timeSpec(), Qt::UTC); - start = QDateTime(startDate, testTime, Qt::OffsetFromUTC, 60 * 60); + start = QDateTime(startDate, testTime, QTimeZone::fromSecondsAheadOfUtc(60 * 60)); end = start.addYears(years1).addYears(years2); QCOMPARE(end.date(), resultDate); QCOMPARE(end.time(), testTime); @@ -1215,7 +1520,7 @@ void tst_QDateTime::addYears() QCOMPARE(end.offsetFromUtc(), 60 * 60); } -void tst_QDateTime::addSecs_data() +void tst_QDateTime::addMSecs_data() { QTest::addColumn<QDateTime>("dt"); QTest::addColumn<qint64>("nsecs"); @@ -1226,91 +1531,156 @@ void tst_QDateTime::addSecs_data() const qint64 daySecs(86400); QTest::newRow("utc0") - << QDateTime(QDate(2004, 1, 1), standardTime, Qt::UTC) << daySecs - << QDateTime(QDate(2004, 1, 2), standardTime, Qt::UTC); + << QDateTime(QDate(2004, 1, 1), standardTime, UTC) << daySecs + << QDateTime(QDate(2004, 1, 2), standardTime, UTC); QTest::newRow("utc1") - << QDateTime(QDate(2004, 1, 1), standardTime, Qt::UTC) << (daySecs * 185) - << QDateTime(QDate(2004, 7, 4), standardTime, Qt::UTC); + << QDateTime(QDate(2004, 1, 1), standardTime, UTC) << (daySecs * 185) + << QDateTime(QDate(2004, 7, 4), standardTime, UTC); QTest::newRow("utc2") - << QDateTime(QDate(2004, 1, 1), standardTime, Qt::UTC) << (daySecs * 366) - << QDateTime(QDate(2005, 1, 1), standardTime, Qt::UTC); + << QDateTime(QDate(2004, 1, 1), standardTime, UTC) << (daySecs * 366) + << QDateTime(QDate(2005, 1, 1), standardTime, UTC); QTest::newRow("utc3") - << QDateTime(QDate(1760, 1, 1), standardTime, Qt::UTC) << daySecs - << QDateTime(QDate(1760, 1, 2), standardTime, Qt::UTC); + << QDateTime(QDate(1760, 1, 1), standardTime, UTC) << daySecs + << QDateTime(QDate(1760, 1, 2), standardTime, UTC); QTest::newRow("utc4") - << QDateTime(QDate(1760, 1, 1), standardTime, Qt::UTC) << (daySecs * 185) - << QDateTime(QDate(1760, 7, 4), standardTime, Qt::UTC); + << QDateTime(QDate(1760, 1, 1), standardTime, UTC) << (daySecs * 185) + << QDateTime(QDate(1760, 7, 4), standardTime, UTC); QTest::newRow("utc5") - << QDateTime(QDate(1760, 1, 1), standardTime, Qt::UTC) << (daySecs * 366) - << QDateTime(QDate(1761, 1, 1), standardTime, Qt::UTC); + << QDateTime(QDate(1760, 1, 1), standardTime, UTC) << (daySecs * 366) + << QDateTime(QDate(1761, 1, 1), standardTime, UTC); QTest::newRow("utc6") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::UTC) << daySecs - << QDateTime(QDate(4000, 1, 2), standardTime, Qt::UTC); + << QDateTime(QDate(4000, 1, 1), standardTime, UTC) << daySecs + << QDateTime(QDate(4000, 1, 2), standardTime, UTC); QTest::newRow("utc7") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::UTC) << (daySecs * 185) - << QDateTime(QDate(4000, 7, 4), standardTime, Qt::UTC); + << QDateTime(QDate(4000, 1, 1), standardTime, UTC) << (daySecs * 185) + << QDateTime(QDate(4000, 7, 4), standardTime, UTC); QTest::newRow("utc8") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::UTC) << (daySecs * 366) - << QDateTime(QDate(4001, 1, 1), standardTime, Qt::UTC); + << QDateTime(QDate(4000, 1, 1), standardTime, UTC) << (daySecs * 366) + << QDateTime(QDate(4001, 1, 1), standardTime, UTC); QTest::newRow("utc9") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::UTC) << qint64(0) - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::UTC); + << QDateTime(QDate(4000, 1, 1), standardTime, UTC) << qint64(0) + << QDateTime(QDate(4000, 1, 1), standardTime, UTC); if (zoneIsCET) { QTest::newRow("cet0") - << QDateTime(QDate(2004, 1, 1), standardTime, Qt::LocalTime) << daySecs - << QDateTime(QDate(2004, 1, 2), standardTime, Qt::LocalTime); + << QDateTime(QDate(2004, 1, 1), standardTime) << daySecs + << QDateTime(QDate(2004, 1, 2), standardTime); QTest::newRow("cet1") - << QDateTime(QDate(2004, 1, 1), standardTime, Qt::LocalTime) << (daySecs * 185) - << QDateTime(QDate(2004, 7, 4), daylightTime, Qt::LocalTime); + << QDateTime(QDate(2004, 1, 1), standardTime) << (daySecs * 185) + << QDateTime(QDate(2004, 7, 4), daylightTime); QTest::newRow("cet2") - << QDateTime(QDate(2004, 1, 1), standardTime, Qt::LocalTime) << (daySecs * 366) - << QDateTime(QDate(2005, 1, 1), standardTime, Qt::LocalTime); + << QDateTime(QDate(2004, 1, 1), standardTime) << (daySecs * 366) + << QDateTime(QDate(2005, 1, 1), standardTime); QTest::newRow("cet3") - << QDateTime(QDate(1760, 1, 1), standardTime, Qt::LocalTime) << daySecs - << QDateTime(QDate(1760, 1, 2), standardTime, Qt::LocalTime); + << QDateTime(QDate(1760, 1, 1), standardTime) << daySecs + << QDateTime(QDate(1760, 1, 2), standardTime); QTest::newRow("cet4") - << QDateTime(QDate(1760, 1, 1), standardTime, Qt::LocalTime) << (daySecs * 185) - << QDateTime(QDate(1760, 7, 4), standardTime, Qt::LocalTime); + << QDateTime(QDate(1760, 1, 1), standardTime) << (daySecs * 185) + << QDateTime(QDate(1760, 7, 4), standardTime); QTest::newRow("cet5") - << QDateTime(QDate(1760, 1, 1), standardTime, Qt::LocalTime) << (daySecs * 366) - << QDateTime(QDate(1761, 1, 1), standardTime, Qt::LocalTime); + << QDateTime(QDate(1760, 1, 1), standardTime) << (daySecs * 366) + << QDateTime(QDate(1761, 1, 1), standardTime); QTest::newRow("cet6") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::LocalTime) << daySecs - << QDateTime(QDate(4000, 1, 2), standardTime, Qt::LocalTime); + << QDateTime(QDate(4000, 1, 1), standardTime) << daySecs + << QDateTime(QDate(4000, 1, 2), standardTime); QTest::newRow("cet7") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::LocalTime) << (daySecs * 185) - << QDateTime(QDate(4000, 7, 4), daylightTime, Qt::LocalTime); + << QDateTime(QDate(4000, 1, 1), standardTime) << (daySecs * 185) + << QDateTime(QDate(4000, 7, 4), daylightTime); QTest::newRow("cet8") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::LocalTime) << (daySecs * 366) - << QDateTime(QDate(4001, 1, 1), standardTime, Qt::LocalTime); + << QDateTime(QDate(4000, 1, 1), standardTime) << (daySecs * 366) + << QDateTime(QDate(4001, 1, 1), standardTime); QTest::newRow("cet9") - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::LocalTime) << qint64(0) - << QDateTime(QDate(4000, 1, 1), standardTime, Qt::LocalTime); + << QDateTime(QDate(4000, 1, 1), standardTime) << qint64(0) + << QDateTime(QDate(4000, 1, 1), standardTime); } // Year sign change QTest::newRow("toNegative") - << QDateTime(QDate(1, 1, 1), QTime(0, 0), Qt::UTC) << qint64(-1) - << QDateTime(QDate(-1, 12, 31), QTime(23, 59, 59), Qt::UTC); + << QDateTime(QDate(1, 1, 1), QTime(0, 0), UTC) << qint64(-1) + << QDateTime(QDate(-1, 12, 31), QTime(23, 59, 59), UTC); QTest::newRow("toPositive") - << QDateTime(QDate(-1, 12, 31), QTime(23, 59, 59), Qt::UTC) << qint64(1) - << QDateTime(QDate(1, 1, 1), QTime(0, 0), Qt::UTC); + << QDateTime(QDate(-1, 12, 31), QTime(23, 59, 59), UTC) << qint64(1) + << QDateTime(QDate(1, 1, 1), QTime(0, 0), UTC); QTest::newRow("invalid") << QDateTime() << qint64(1) << QDateTime(); // Check Offset details are preserved QTest::newRow("offset0") - << QDateTime(QDate(2013, 1, 1), QTime(1, 2, 3), Qt::OffsetFromUTC, 60 * 60) + << QDateTime(QDate(2013, 1, 1), QTime(1, 2, 3), QTimeZone::fromSecondsAheadOfUtc(60 * 60)) << qint64(60 * 60) - << QDateTime(QDate(2013, 1, 1), QTime(2, 2, 3), Qt::OffsetFromUTC, 60 * 60); + << QDateTime(QDate(2013, 1, 1), QTime(2, 2, 3), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); // Check last second of 1969 QTest::newRow("epoch-1s-utc") - << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC) << qint64(-1) - << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59), Qt::UTC); + << QDate(1970, 1, 1).startOfDay(UTC) << qint64(-1) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59), UTC); QTest::newRow("epoch-1s-local") - << QDateTime(QDate(1970, 1, 1), QTime(0, 0)) << qint64(-1) + << QDate(1970, 1, 1).startOfDay() << qint64(-1) << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59)); + QTest::newRow("epoch-1s-utc-as-local") + << QDate(1970, 1, 1).startOfDay(UTC).toLocalTime() << qint64(-1) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59), UTC).toLocalTime(); + + // Overflow and Underflow + const qint64 maxSeconds = std::numeric_limits<qint64>::max() / 1000; + QTest::newRow("after-last") + << QDateTime::fromSecsSinceEpoch(maxSeconds, UTC) << qint64(1) << QDateTime(); + QTest::newRow("to-last") + << QDateTime::fromSecsSinceEpoch(maxSeconds - 1, UTC) << qint64(1) + << QDateTime::fromSecsSinceEpoch(maxSeconds, UTC); + QTest::newRow("before-first") + << QDateTime::fromSecsSinceEpoch(-maxSeconds, UTC) << qint64(-1) << QDateTime(); + QTest::newRow("to-first") + << QDateTime::fromSecsSinceEpoch(1 - maxSeconds, UTC) << qint64(-1) + << QDateTime::fromSecsSinceEpoch(-maxSeconds, UTC); + +#if QT_CONFIG(timezone) + if (const QTimeZone cet("Europe/Oslo"); cet.isValid()) { + QTest::newRow("CET-spring-forward") + << QDateTime(QDate(2023, 3, 26), QTime(1, 30), cet) << qint64(60 * 60) + << QDateTime(QDate(2023, 3, 26), QTime(3, 30), cet); + QTest::newRow("CET-fall-back") + << QDateTime(QDate(2023, 10, 29), QTime(1, 30), cet) << qint64(3 * 60 * 60) + << QDateTime(QDate(2023, 10, 29), QTime(3, 30), cet); + } +# ifndef INADEQUATE_TZ_DATA + const QTimeZone lint("Pacific/Kiritimati"); + if (lint.isValid()) { + // Line Islands Time skipped Sat 1994-12-31: + QTest::newRow("Kiritimati-day-off") + << QDateTime(QDate(1994, 12, 30), QTime(23, 30), lint) << qint64(60 * 60) + << QDateTime(QDate(1995, 1, 1), QTime(0, 30), lint); + } +# ifndef Q_OS_DARWIN + if (const QTimeZone alaska("America/Anchorage"); alaska.isValid()) { + // On Julian date 1867, Sat Oct 7 (at 14:31 local solar mean time for + // Anchorage, 15:30 LMT in Sitka, which hosted the transfer ceremony) + // Russia sold Alaska to the USA, which changed the calendar to + // Gregorian, hence the date to Fri Oct 18. Contrast addDays(). + const QDate sat(1867, 10, 19); + Q_ASSERT(sat == QDate(1867, 10, 7, QCalendar(QCalendar::System::Julian))); + // At the start of the day, it was Sat 7th; by evening it was Fri 18th; + // then the next day was Sat 19th. + QTest::newRow("Alaska-Day") + // The actual morning of the hand-over: + << QDateTime(sat, QTime(6, 0), alaska) << qint64(12 * 60 * 60) + // The evening of the same day. + << QDateTime(sat, QTime(18, 0), alaska).addDays(-1); + } +# endif // Darwin +# endif // inadequate zone data +#endif // timezone +} + +void tst_QDateTime::addSecs_data() +{ + addMSecs_data(); + + const qint64 maxSeconds = std::numeric_limits<qint64>::max() / 1000; + // Results would be representable, but the step isn't + QTest::newRow("leap-up") + << QDateTime::fromSecsSinceEpoch(-1, UTC) << 1 + maxSeconds << QDateTime(); + QTest::newRow("leap-down") + << QDateTime::fromSecsSinceEpoch(1, UTC) << -1 - maxSeconds << QDateTime(); } void tst_QDateTime::addSecs() @@ -1319,16 +1689,31 @@ void tst_QDateTime::addSecs() QFETCH(const qint64, nsecs); QFETCH(const QDateTime, result); QDateTime test = dt.addSecs(nsecs); - QCOMPARE(test, result); - QCOMPARE(test.timeSpec(), dt.timeSpec()); - if (test.timeSpec() == Qt::OffsetFromUTC) - QCOMPARE(test.offsetFromUtc(), dt.offsetFromUtc()); - QCOMPARE(result.addSecs(-nsecs), dt); -} - -void tst_QDateTime::addMSecs_data() -{ - addSecs_data(); + QDateTime test2 = dt + std::chrono::seconds(nsecs); + QDateTime test3 = dt; + test3 += std::chrono::seconds(nsecs); + if (!result.isValid()) { + QVERIFY(!test.isValid()); + QVERIFY(!test2.isValid()); + QVERIFY(!test3.isValid()); + } else { + QCOMPARE(test, result); + QCOMPARE(test2, result); + QCOMPARE(test3, result); + QCOMPARE(test.timeSpec(), dt.timeSpec()); + QCOMPARE(test2.timeSpec(), dt.timeSpec()); + QCOMPARE(test3.timeSpec(), dt.timeSpec()); + if (test.timeSpec() == Qt::OffsetFromUTC) { + QCOMPARE(test.offsetFromUtc(), dt.offsetFromUtc()); + QCOMPARE(test2.offsetFromUtc(), dt.offsetFromUtc()); + QCOMPARE(test3.offsetFromUtc(), dt.offsetFromUtc()); + } + QCOMPARE(result.addSecs(-nsecs), dt); + QCOMPARE(result - std::chrono::seconds(nsecs), dt); + test3 -= std::chrono::seconds(nsecs); + QCOMPARE(test3, dt); + QCOMPARE(dt.secsTo(result), nsecs); + } } void tst_QDateTime::addMSecs() @@ -1337,16 +1722,34 @@ void tst_QDateTime::addMSecs() QFETCH(const qint64, nsecs); QFETCH(const QDateTime, result); - QDateTime test = dt.addMSecs(qint64(nsecs) * 1000); - QCOMPARE(test, result); - QCOMPARE(test.timeSpec(), dt.timeSpec()); - if (test.timeSpec() == Qt::OffsetFromUTC) - QCOMPARE(test.offsetFromUtc(), dt.offsetFromUtc()); - QCOMPARE(result.addMSecs(qint64(-nsecs) * 1000), dt); + const auto verify = [&](const QDateTime &test) { + if (!result.isValid()) { + QVERIFY(!test.isValid()); + } else { + QCOMPARE(test, result); + QCOMPARE(test.timeSpec(), dt.timeSpec()); + if (test.timeSpec() == Qt::OffsetFromUTC) + QCOMPARE(test.offsetFromUtc(), dt.offsetFromUtc()); + QCOMPARE(result.addMSecs(qint64(-nsecs) * 1000), dt); + } + }; +#define VERIFY(datum) \ + verify(datum); \ + if (QTest::currentTestFailed()) \ + return + + VERIFY(dt.addMSecs(qint64(nsecs) * 1000)); + VERIFY(dt.addDuration(std::chrono::seconds(nsecs))); + VERIFY(dt.addDuration(std::chrono::milliseconds(nsecs * 1000))); +#undef VERIFY } +#if QT_DEPRECATED_SINCE(6, 9) void tst_QDateTime::toTimeSpec_data() { + if (!zoneIsCET) + QSKIP("Not tested with timezone other than Central European (CET/CEST)"); + QTest::addColumn<QDateTime>("fromUtc"); QTest::addColumn<QDateTime>("fromLocal"); @@ -1354,158 +1757,153 @@ void tst_QDateTime::toTimeSpec_data() QTime localStandardTime(5, 20, 30); QTime localDaylightTime(6, 20, 30); - QTest::newRow("winter1") << QDateTime(QDate(2004, 1, 1), utcTime, Qt::UTC) - << QDateTime(QDate(2004, 1, 1), localStandardTime, Qt::LocalTime); - QTest::newRow("winter2") << QDateTime(QDate(2004, 2, 29), utcTime, Qt::UTC) - << QDateTime(QDate(2004, 2, 29), localStandardTime, Qt::LocalTime); - QTest::newRow("winter3") << QDateTime(QDate(1760, 2, 29), utcTime, Qt::UTC) - << QDateTime(QDate(1760, 2, 29), localStandardTime, Qt::LocalTime); - QTest::newRow("winter4") << QDateTime(QDate(6000, 2, 29), utcTime, Qt::UTC) - << QDateTime(QDate(6000, 2, 29), localStandardTime, Qt::LocalTime); + QTest::newRow("winter1") + << QDateTime(QDate(2004, 1, 1), utcTime, UTC) + << QDateTime(QDate(2004, 1, 1), localStandardTime); + QTest::newRow("winter2") + << QDateTime(QDate(2004, 2, 29), utcTime, UTC) + << QDateTime(QDate(2004, 2, 29), localStandardTime); + QTest::newRow("winter3") + << QDateTime(QDate(1760, 2, 29), utcTime, UTC) + << QDateTime(QDate(1760, 2, 29), localStandardTime.addSecs(preZoneFix)); + QTest::newRow("winter4") + << QDateTime(QDate(6000, 2, 29), utcTime, UTC) + << QDateTime(QDate(6000, 2, 29), localStandardTime); // Test mktime boundaries (1970 - 2038) and adjustDate(). QTest::newRow("1969/12/31 23:00 UTC") - << QDateTime(QDate(1969, 12, 31), QTime(23, 0), Qt::UTC) - << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::LocalTime); + << QDateTime(QDate(1969, 12, 31), QTime(23, 0), UTC) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0)); + QTest::newRow("1969/12/31 23:59:59 UTC") + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59), UTC) + << QDateTime(QDate(1970, 1, 1), QTime(0, 59, 59)); QTest::newRow("2037/12/31 23:00 UTC") - << QDateTime(QDate(2037, 12, 31), QTime(23, 0), Qt::UTC) - << QDateTime(QDate(2038, 1, 1), QTime(0, 0), Qt::LocalTime); + << QDateTime(QDate(2037, 12, 31), QTime(23, 0), UTC) + << QDateTime(QDate(2038, 1, 1), QTime(0, 0)); QTest::newRow("-271821/4/20 00:00 UTC (JavaScript min date, start of day)") - << QDateTime(QDate(-271821, 4, 20), QTime(0, 0), Qt::UTC) - << QDateTime(QDate(-271821, 4, 20), QTime(1, 0), Qt::LocalTime); + << QDateTime(QDate(-271821, 4, 20), QTime(0, 0), UTC) + << QDateTime(QDate(-271821, 4, 20), QTime(1, 0)).addSecs(preZoneFix); QTest::newRow("-271821/4/20 23:00 UTC (JavaScript min date, end of day)") - << QDateTime(QDate(-271821, 4, 20), QTime(23, 0), Qt::UTC) - << QDateTime(QDate(-271821, 4, 21), QTime(0, 0), Qt::LocalTime); + << QDateTime(QDate(-271821, 4, 20), QTime(23, 0), UTC) + << QDateTime(QDate(-271821, 4, 21), QTime(0, 0)).addSecs(preZoneFix); if (zoneIsCET) { - QTest::newRow("summer1") << QDateTime(QDate(2004, 6, 30), utcTime, Qt::UTC) - << QDateTime(QDate(2004, 6, 30), localDaylightTime, Qt::LocalTime); - QTest::newRow("summer2") << QDateTime(QDate(1760, 6, 30), utcTime, Qt::UTC) - << QDateTime(QDate(1760, 6, 30), localStandardTime, Qt::LocalTime); - QTest::newRow("summer3") << QDateTime(QDate(4000, 6, 30), utcTime, Qt::UTC) - << QDateTime(QDate(4000, 6, 30), localDaylightTime, Qt::LocalTime); + QTest::newRow("summer1") + << QDateTime(QDate(2004, 6, 30), utcTime, UTC) + << QDateTime(QDate(2004, 6, 30), localDaylightTime); + QTest::newRow("summer2") + << QDateTime(QDate(1760, 6, 30), utcTime, UTC) + << QDateTime(QDate(1760, 6, 30), localStandardTime.addSecs(preZoneFix)); + QTest::newRow("summer3") + << QDateTime(QDate(4000, 6, 30), utcTime, UTC) + << QDateTime(QDate(4000, 6, 30), localDaylightTime); QTest::newRow("275760/9/23 00:00 UTC (JavaScript max date, start of day)") - << QDateTime(QDate(275760, 9, 23), QTime(0, 0), Qt::UTC) - << QDateTime(QDate(275760, 9, 23), QTime(2, 0), Qt::LocalTime); + << QDate(275760, 9, 23).startOfDay(UTC) + << QDateTime(QDate(275760, 9, 23), QTime(2, 0)); QTest::newRow("275760/9/23 22:00 UTC (JavaScript max date, end of day)") - << QDateTime(QDate(275760, 9, 23), QTime(22, 0), Qt::UTC) - << QDateTime(QDate(275760, 9, 24), QTime(0, 0), Qt::LocalTime); + << QDateTime(QDate(275760, 9, 23), QTime(22, 0), UTC) + << QDate(275760, 9, 24).startOfDay(); } - QTest::newRow("msec") << QDateTime(QDate(4000, 6, 30), utcTime.addMSecs(1), Qt::UTC) - << QDateTime(QDate(4000, 6, 30), localDaylightTime.addMSecs(1), Qt::LocalTime); + QTest::newRow("msec") + << QDateTime(QDate(4000, 6, 30), utcTime.addMSecs(1), UTC) + << QDateTime(QDate(4000, 6, 30), localDaylightTime.addMSecs(1)); } +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED void tst_QDateTime::toTimeSpec() { - if (zoneIsCET) { - QFETCH(QDateTime, fromUtc); - QFETCH(QDateTime, fromLocal); - - QDateTime utcToUtc = fromUtc.toTimeSpec(Qt::UTC); - QDateTime localToLocal = fromLocal.toTimeSpec(Qt::LocalTime); - QDateTime utcToLocal = fromUtc.toTimeSpec(Qt::LocalTime); - QDateTime localToUtc = fromLocal.toTimeSpec(Qt::UTC); - QDateTime utcToOffset = fromUtc.toTimeSpec(Qt::OffsetFromUTC); - QDateTime localToOffset = fromLocal.toTimeSpec(Qt::OffsetFromUTC); - - QCOMPARE(utcToUtc, fromUtc); - QCOMPARE(utcToUtc.date(), fromUtc.date()); - QCOMPARE(utcToUtc.time(), fromUtc.time()); - QCOMPARE(utcToUtc.timeSpec(), Qt::UTC); - - QCOMPARE(localToLocal, fromLocal); - QCOMPARE(localToLocal.date(), fromLocal.date()); - QCOMPARE(localToLocal.time(), fromLocal.time()); - QCOMPARE(localToLocal.timeSpec(), Qt::LocalTime); - - QCOMPARE(utcToLocal, fromLocal); - QCOMPARE(utcToLocal.date(), fromLocal.date()); - QCOMPARE(utcToLocal.time(), fromLocal.time()); - QCOMPARE(utcToLocal.timeSpec(), Qt::LocalTime); - QCOMPARE(utcToLocal.toTimeSpec(Qt::UTC), fromUtc); - - QCOMPARE(localToUtc, fromUtc); - QCOMPARE(localToUtc.date(), fromUtc.date()); - QCOMPARE(localToUtc.time(), fromUtc.time()); - QCOMPARE(localToUtc.timeSpec(), Qt::UTC); - QCOMPARE(localToUtc.toTimeSpec(Qt::LocalTime), fromLocal); - - QCOMPARE(utcToUtc, localToUtc); - QCOMPARE(utcToUtc.date(), localToUtc.date()); - QCOMPARE(utcToUtc.time(), localToUtc.time()); - QCOMPARE(utcToUtc.timeSpec(), Qt::UTC); - - QCOMPARE(utcToLocal, localToLocal); - QCOMPARE(utcToLocal.date(), localToLocal.date()); - QCOMPARE(utcToLocal.time(), localToLocal.time()); - QCOMPARE(utcToLocal.timeSpec(), Qt::LocalTime); - - // OffsetToUTC becomes UTC - QCOMPARE(utcToOffset, fromUtc); - QCOMPARE(utcToOffset.date(), fromUtc.date()); - QCOMPARE(utcToOffset.time(), fromUtc.time()); - QCOMPARE(utcToOffset.timeSpec(), Qt::UTC); - QCOMPARE(utcToOffset.toTimeSpec(Qt::UTC), fromUtc); - - QCOMPARE(localToOffset, fromUtc); - QCOMPARE(localToOffset.date(), fromUtc.date()); - QCOMPARE(localToOffset.time(), fromUtc.time()); - QCOMPARE(localToOffset.timeSpec(), Qt::UTC); - QCOMPARE(localToOffset.toTimeSpec(Qt::LocalTime), fromLocal); - } else { - QSKIP("Not tested with timezone other than Central European (CET/CEST)"); - } -} - -void tst_QDateTime::toLocalTime_data() -{ - toTimeSpec_data(); + QFETCH(QDateTime, fromUtc); + QFETCH(QDateTime, fromLocal); + + QDateTime utcToUtc = fromUtc.toTimeSpec(Qt::UTC); + QDateTime localToLocal = fromLocal.toTimeSpec(Qt::LocalTime); + QDateTime utcToLocal = fromUtc.toTimeSpec(Qt::LocalTime); + QDateTime localToUtc = fromLocal.toTimeSpec(Qt::UTC); + QDateTime utcToOffset = fromUtc.toTimeSpec(Qt::OffsetFromUTC); + QDateTime localToOffset = fromLocal.toTimeSpec(Qt::OffsetFromUTC); + + QCOMPARE(utcToUtc, fromUtc); + QCOMPARE(utcToUtc.date(), fromUtc.date()); + QCOMPARE(utcToUtc.time(), fromUtc.time()); + QCOMPARE(utcToUtc.timeSpec(), Qt::UTC); + + QCOMPARE(localToLocal, fromLocal); + QCOMPARE(localToLocal.date(), fromLocal.date()); + QCOMPARE(localToLocal.time(), fromLocal.time()); + QCOMPARE(localToLocal.timeSpec(), Qt::LocalTime); + + QCOMPARE(utcToLocal, fromLocal); + QCOMPARE(utcToLocal.date(), fromLocal.date()); + QCOMPARE(utcToLocal.time(), fromLocal.time()); + QCOMPARE(utcToLocal.timeSpec(), Qt::LocalTime); + QCOMPARE(utcToLocal.toTimeSpec(Qt::UTC), fromUtc); + + QCOMPARE(localToUtc, fromUtc); + QCOMPARE(localToUtc.date(), fromUtc.date()); + QCOMPARE(localToUtc.time(), fromUtc.time()); + QCOMPARE(localToUtc.timeSpec(), Qt::UTC); + QCOMPARE(localToUtc.toTimeSpec(Qt::LocalTime), fromLocal); + + QCOMPARE(utcToUtc, localToUtc); + QCOMPARE(utcToUtc.date(), localToUtc.date()); + QCOMPARE(utcToUtc.time(), localToUtc.time()); + QCOMPARE(utcToUtc.timeSpec(), Qt::UTC); + + QCOMPARE(utcToLocal, localToLocal); + QCOMPARE(utcToLocal.date(), localToLocal.date()); + QCOMPARE(utcToLocal.time(), localToLocal.time()); + QCOMPARE(utcToLocal.timeSpec(), Qt::LocalTime); + + // OffsetToUTC becomes UTC + QCOMPARE(utcToOffset, fromUtc); + QCOMPARE(utcToOffset.date(), fromUtc.date()); + QCOMPARE(utcToOffset.time(), fromUtc.time()); + QCOMPARE(utcToOffset.timeSpec(), Qt::UTC); + QCOMPARE(utcToOffset.toTimeSpec(Qt::UTC), fromUtc); + + QCOMPARE(localToOffset, fromUtc); + QCOMPARE(localToOffset.date(), fromUtc.date()); + QCOMPARE(localToOffset.time(), fromUtc.time()); + QCOMPARE(localToOffset.timeSpec(), Qt::UTC); + QCOMPARE(localToOffset.toTimeSpec(Qt::LocalTime), fromLocal); } void tst_QDateTime::toLocalTime() { - if (zoneIsCET) { - QFETCH(QDateTime, fromUtc); - QFETCH(QDateTime, fromLocal); + QFETCH(QDateTime, fromUtc); + QFETCH(QDateTime, fromLocal); - QCOMPARE(fromLocal.toLocalTime(), fromLocal); - QCOMPARE(fromUtc.toLocalTime(), fromLocal); - QCOMPARE(fromUtc.toLocalTime(), fromLocal.toLocalTime()); - } else { - QSKIP("Not tested with timezone other than Central European (CET/CEST)"); - } -} - -void tst_QDateTime::toUTC_data() -{ - toTimeSpec_data(); + QCOMPARE(fromLocal.toLocalTime(), fromLocal); + QCOMPARE(fromUtc.toLocalTime(), fromLocal); + QCOMPARE(fromUtc.toLocalTime(), fromLocal.toLocalTime()); } void tst_QDateTime::toUTC() { - if (zoneIsCET) { - QFETCH(QDateTime, fromUtc); - QFETCH(QDateTime, fromLocal); + QFETCH(QDateTime, fromUtc); + QFETCH(QDateTime, fromLocal); - QCOMPARE(fromUtc.toUTC(), fromUtc); - QCOMPARE(fromLocal.toUTC(), fromUtc); - QCOMPARE(fromUtc.toUTC(), fromLocal.toUTC()); - } else { - QSKIP("Not tested with timezone other than Central European (CET/CEST)"); - } + QCOMPARE(fromUtc.toUTC(), fromUtc); + QCOMPARE(fromLocal.toUTC(), fromUtc); + QCOMPARE(fromUtc.toUTC(), fromLocal.toUTC()); +} +void tst_QDateTime::toUTC_extra() +{ QDateTime dt = QDateTime::currentDateTime(); - if(dt.time().msec() == 0){ + if (dt.time().msec() == 0) dt.setTime(dt.time().addMSecs(1)); - } QString s = dt.toString("zzz"); QString t = dt.toUTC().toString("zzz"); QCOMPARE(s, t); } +QT_WARNING_POP +#endif // 6.9 deprecation void tst_QDateTime::daysTo() { @@ -1537,11 +1935,11 @@ void tst_QDateTime::secsTo_data() addSecs_data(); QTest::newRow("disregard milliseconds #1") - << QDateTime(QDate(2012, 3, 7), QTime(0, 58, 0, 0)) << qint64(60) + << QDateTime(QDate(2012, 3, 7), QTime(0, 58)) << qint64(60) << QDateTime(QDate(2012, 3, 7), QTime(0, 59, 0, 400)); QTest::newRow("disregard milliseconds #2") - << QDateTime(QDate(2012, 3, 7), QTime(0, 59, 0, 0)) << qint64(60) + << QDateTime(QDate(2012, 3, 7), QTime(0, 59)) << qint64(60) << QDateTime(QDate(2012, 3, 7), QTime(1, 0, 0, 400)); } @@ -1551,7 +1949,7 @@ void tst_QDateTime::secsTo() QFETCH(const qint64, nsecs); QFETCH(const QDateTime, result); - if (dt.isValid()) { + if (result.isValid()) { QCOMPARE(dt.secsTo(result), (qint64)nsecs); QCOMPARE(result.secsTo(dt), (qint64)-nsecs); QVERIFY((dt == result) == (0 == nsecs)); @@ -1566,20 +1964,17 @@ void tst_QDateTime::secsTo() } } -void tst_QDateTime::msecsTo_data() -{ - addMSecs_data(); -} - void tst_QDateTime::msecsTo() { QFETCH(const QDateTime, dt); QFETCH(const qint64, nsecs); QFETCH(const QDateTime, result); - if (dt.isValid()) { + if (result.isValid()) { QCOMPARE(dt.msecsTo(result), qint64(nsecs) * 1000); + QCOMPARE(result - dt, std::chrono::milliseconds(nsecs * 1000)); QCOMPARE(result.msecsTo(dt), -qint64(nsecs) * 1000); + QCOMPARE(dt - result, -std::chrono::milliseconds(nsecs * 1000)); QVERIFY((dt == result) == (0 == (qint64(nsecs) * 1000))); QVERIFY((dt != result) == (0 != (qint64(nsecs) * 1000))); QVERIFY((dt < result) == (0 < (qint64(nsecs) * 1000))); @@ -1588,10 +1983,17 @@ void tst_QDateTime::msecsTo() QVERIFY((dt >= result) == (0 >= (qint64(nsecs) * 1000))); } else { QVERIFY(dt.msecsTo(result) == 0); + QCOMPARE(result - dt, std::chrono::milliseconds(0)); QVERIFY(result.msecsTo(dt) == 0); + QCOMPARE(dt - result, std::chrono::milliseconds(0)); } } +void tst_QDateTime::orderingCompiles() +{ + QTestPrivate::testAllComparisonOperatorsCompile<QDateTime>(); +} + void tst_QDateTime::currentDateTime() { time_t buf1, buf2; @@ -1611,30 +2013,32 @@ void tst_QDateTime::currentDateTime() // 1 second difference from the more accurate method used by QDateTime::currentDateTime() upperBound = upperBound.addSecs(2); - QString details = QString("\n" - "lowerBound: %1\n" - "dt1: %2\n" - "dt2: %3\n" - "dt3: %4\n" - "upperBound: %5\n") - .arg(lowerBound.toSecsSinceEpoch()) - .arg(dt1.toSecsSinceEpoch()) - .arg(dt2.toSecsSinceEpoch()) - .arg(dt3.toSecsSinceEpoch()) - .arg(upperBound.toSecsSinceEpoch()); - - QVERIFY2(lowerBound < upperBound, qPrintable(details)); - - QVERIFY2(lowerBound <= dt1, qPrintable(details)); - QVERIFY2(dt1 < upperBound, qPrintable(details)); - QVERIFY2(lowerBound <= dt2, qPrintable(details)); - QVERIFY2(dt2 < upperBound, qPrintable(details)); - QVERIFY2(lowerBound <= dt3, qPrintable(details)); - QVERIFY2(dt3 < upperBound, qPrintable(details)); + auto reporter = qScopeGuard([=]() { + qInfo("\n" + "lowerBound: %lld\n" + "dt1: %lld\n" + "dt2: %lld\n" + "dt3: %lld\n" + "upperBound: %lld\n", + lowerBound.toSecsSinceEpoch(), + dt1.toSecsSinceEpoch(), + dt2.toSecsSinceEpoch(), + dt3.toSecsSinceEpoch(), + upperBound.toSecsSinceEpoch()); + }); + + QCOMPARE_LT(lowerBound, upperBound); + QCOMPARE_LE(lowerBound, dt1); + QCOMPARE_LT(dt1, upperBound); + QCOMPARE_LE(lowerBound, dt2); + QCOMPARE_LT(dt2, upperBound); + QCOMPARE_LE(lowerBound, dt3); + QCOMPARE_LT(dt3, upperBound); + reporter.dismiss(); - QVERIFY(dt1.timeSpec() == Qt::LocalTime); - QVERIFY(dt2.timeSpec() == Qt::LocalTime); - QVERIFY(dt3.timeSpec() == Qt::UTC); + QCOMPARE(dt1.timeSpec(), Qt::LocalTime); + QCOMPARE(dt2.timeSpec(), Qt::LocalTime); + QCOMPARE(dt3.timeSpec(), Qt::UTC); } void tst_QDateTime::currentDateTimeUtc() @@ -1657,30 +2061,32 @@ void tst_QDateTime::currentDateTimeUtc() // 1 second difference from the more accurate method used by QDateTime::currentDateTime() upperBound = upperBound.addSecs(2); - QString details = QString("\n" - "lowerBound: %1\n" - "dt1: %2\n" - "dt2: %3\n" - "dt3: %4\n" - "upperBound: %5\n") - .arg(lowerBound.toSecsSinceEpoch()) - .arg(dt1.toSecsSinceEpoch()) - .arg(dt2.toSecsSinceEpoch()) - .arg(dt3.toSecsSinceEpoch()) - .arg(upperBound.toSecsSinceEpoch()); + auto reporter = qScopeGuard([=]() { + qInfo("\n" + "lowerBound: %lld\n" + "dt1: %lld\n" + "dt2: %lld\n" + "dt3: %lld\n" + "upperBound: %lld\n", + lowerBound.toSecsSinceEpoch(), + dt1.toSecsSinceEpoch(), + dt2.toSecsSinceEpoch(), + dt3.toSecsSinceEpoch(), + upperBound.toSecsSinceEpoch()); + }); + + QCOMPARE_LT(lowerBound, upperBound); + QCOMPARE_LE(lowerBound, dt1); + QCOMPARE_LT(dt1, upperBound); + QCOMPARE_LE(lowerBound, dt2); + QCOMPARE_LT(dt2, upperBound); + QCOMPARE_LE(lowerBound, dt3); + QCOMPARE_LT(dt3, upperBound); + reporter.dismiss(); - QVERIFY2(lowerBound < upperBound, qPrintable(details)); - - QVERIFY2(lowerBound <= dt1, qPrintable(details)); - QVERIFY2(dt1 < upperBound, qPrintable(details)); - QVERIFY2(lowerBound <= dt2, qPrintable(details)); - QVERIFY2(dt2 < upperBound, qPrintable(details)); - QVERIFY2(lowerBound <= dt3, qPrintable(details)); - QVERIFY2(dt3 < upperBound, qPrintable(details)); - - QVERIFY(dt1.timeSpec() == Qt::UTC); - QVERIFY(dt2.timeSpec() == Qt::LocalTime); - QVERIFY(dt3.timeSpec() == Qt::UTC); + QCOMPARE(dt1.timeSpec(), Qt::UTC); + QCOMPARE(dt2.timeSpec(), Qt::LocalTime); + QCOMPARE(dt3.timeSpec(), Qt::UTC); } void tst_QDateTime::currentDateTimeUtc2() @@ -1721,31 +2127,27 @@ void tst_QDateTime::currentDateTimeUtc2() void tst_QDateTime::toSecsSinceEpoch_data() { - QTest::addColumn<QString>("dateTimeStr"); - QTest::addColumn<bool>("valid"); + QTest::addColumn<QDate>("date"); - QTest::newRow( "data1" ) << str( 1800, 1, 1, 12, 0, 0 ) << true; - QTest::newRow( "data2" ) << str( 1969, 1, 1, 12, 0, 0 ) << true; - QTest::newRow( "data3" ) << str( 2002, 1, 1, 12, 0, 0 ) << true; - QTest::newRow( "data4" ) << str( 2002, 6, 1, 12, 0, 0 ) << true; - QTest::newRow( "data5" ) << QString("INVALID") << false; - QTest::newRow( "data6" ) << str( 2038, 1, 1, 12, 0, 0 ) << true; - QTest::newRow( "data7" ) << str( 2063, 4, 5, 12, 0, 0 ) << true; // the day of First Contact - QTest::newRow( "data8" ) << str( 2107, 1, 1, 12, 0, 0 ) << true; + QTest::newRow("start-1800") << QDate(1800, 1, 1); + QTest::newRow("start-1969") << QDate(1969, 1, 1); + QTest::newRow("start-2002") << QDate(2002, 1, 1); + QTest::newRow("mid-2002") << QDate(2002, 6, 1); + QTest::newRow("start-2038") << QDate(2038, 1, 1); + QTest::newRow("star-trek-1st-contact") << QDate(2063, 4, 5); + QTest::newRow("start-2107") << QDate(2107, 1, 1); } void tst_QDateTime::toSecsSinceEpoch() { - QFETCH(const QString, dateTimeStr); - const QDateTime datetime = dt(dateTimeStr); - QFETCH(const bool, valid); - QCOMPARE(datetime.isValid(), valid); + const QTime noon(12, 0); + QFETCH(const QDate, date); + const QDateTime dateTime(date, noon); + QVERIFY(dateTime.isValid()); - if (valid) { - const qint64 asSecsSinceEpoch = datetime.toSecsSinceEpoch(); - QCOMPARE(asSecsSinceEpoch, datetime.toMSecsSinceEpoch() / 1000); - QCOMPARE(QDateTime::fromSecsSinceEpoch(asSecsSinceEpoch), datetime); - } + const qint64 asSecsSinceEpoch = dateTime.toSecsSinceEpoch(); + QCOMPARE(asSecsSinceEpoch, dateTime.toMSecsSinceEpoch() / 1000); + QCOMPARE(QDateTime::fromSecsSinceEpoch(asSecsSinceEpoch), dateTime); } void tst_QDateTime::daylightSavingsTimeChange_data() @@ -1783,7 +2185,7 @@ void tst_QDateTime::daylightSavingsTimeChange() QFETCH(int, months); // First with simple construction - QDateTime dt = QDateTime(outDST, QTime(0, 0, 0), Qt::LocalTime); + QDateTime dt = outDST.startOfDay(); int outDSTsecs = dt.toSecsSinceEpoch(); dt.setDate(inDST); @@ -1808,29 +2210,29 @@ void tst_QDateTime::daylightSavingsTimeChange() // now using fromSecsSinceEpoch dt = QDateTime::fromSecsSinceEpoch(outDSTsecs); - QCOMPARE(dt, QDateTime(outDST, QTime(0, 0, 0))); + QCOMPARE(dt, outDST.startOfDay()); dt.setDate(inDST); dt = dt.addSecs(60); - QCOMPARE(dt, QDateTime(inDST, QTime(0, 1, 0))); + QCOMPARE(dt, QDateTime(inDST, QTime(0, 1))); // using addMonths: dt = dt.addMonths(months).addSecs(60); - QCOMPARE(dt, QDateTime(outDST, QTime(0, 2, 0))); + QCOMPARE(dt, QDateTime(outDST, QTime(0, 2))); // back again: dt = dt.addMonths(-months).addSecs(60); - QCOMPARE(dt, QDateTime(inDST, QTime(0, 3, 0))); + QCOMPARE(dt, QDateTime(inDST, QTime(0, 3))); // using addDays: dt = dt.addDays(days).addSecs(60); - QCOMPARE(dt, QDateTime(outDST, QTime(0, 4, 0))); + QCOMPARE(dt, QDateTime(outDST, QTime(0, 4))); // back again: dt = dt.addDays(-days).addSecs(60); - QCOMPARE(dt, QDateTime(inDST, QTime(0, 5, 0))); + QCOMPARE(dt, QDateTime(inDST, QTime(0, 5))); // Now use the result of a UTC -> LocalTime conversion - dt = QDateTime(outDST, QTime(0, 0), Qt::LocalTime).toUTC(); - dt = QDateTime(dt.date(), dt.time(), Qt::UTC).toLocalTime(); + dt = outDST.startOfDay().toUTC(); + dt = QDateTime(dt.date(), dt.time(), UTC).toLocalTime(); QCOMPARE(dt, QDateTime(outDST, QTime(0, 0))); // using addDays: @@ -1855,6 +2257,7 @@ void tst_QDateTime::daylightSavingsTimeChange() void tst_QDateTime::springForward_data() { + QTest::addColumn<QTimeZone>("zone"); QTest::addColumn<QDate>("day"); // day of DST transition QTest::addColumn<QTime>("time"); // in the "missing hour" QTest::addColumn<int>("step"); // days to step; +ve from before, -ve from after @@ -1868,67 +2271,136 @@ void tst_QDateTime::springForward_data() document any such conflicts, if discovered. See http://www.timeanddate.com/time/zones/ for data on more candidates to - test. - */ + test. Note, however, that the IANA DB disagrees with it for some zones, + and is authoritative. + */ - uint winter = QDate(2015, 1, 1).startOfDay().toSecsSinceEpoch(); - uint summer = QDate(2015, 7, 1).startOfDay().toSecsSinceEpoch(); + const QTimeZone local(QTimeZone::LocalTime); + const uint winter = QDate(2015, 1, 1).startOfDay(local).toSecsSinceEpoch(); + const uint summer = QDate(2015, 7, 1).startOfDay(local).toSecsSinceEpoch(); if (winter == 1420066800 && summer == 1435701600) { - QTest::newRow("CET from day before") << QDate(2015, 3, 29) << QTime(2, 30, 0) << 1 << 60; - QTest::newRow("CET from day after") << QDate(2015, 3, 29) << QTime(2, 30, 0) << -1 << 120; + QTest::newRow("Local (CET) from day before") + << local << QDate(2015, 3, 29) << QTime(2, 30) << 1 << 60; + QTest::newRow("Local (CET) from day after") + << local << QDate(2015, 3, 29) << QTime(2, 30) << -1 << 120; } else if (winter == 1420063200 && summer == 1435698000) { - // e.g. Finland, where our CI runs ... - QTest::newRow("EET from day before") << QDate(2015, 3, 29) << QTime(3, 30, 0) << 1 << 120; - QTest::newRow("EET from day after") << QDate(2015, 3, 29) << QTime(3, 30, 0) << -1 << 180; + // EET: but there's some variation in the date and time. + // Asia/{Amman,Beirut,Gaza,Hebron}, Europe/Chisinau and Israel: at start of + QDate date(2015, 3, 29); // Sunday by default. + QTime time(0, 30); + if (auto thursday = QDate(2015, 3, 26); thursday.startOfDay(local).time() > time) { + // Asia/Damascus: start of March 26th. + date = thursday; + } else if (auto friday = QDate(2015, 3, 27); friday.startOfDay(local).time() > time) { + // Israel, Asia/{Jerusalem,Tel_Aviv}: start of March 27th (IANA DB). + date = friday; + } else if (friday.startOfDay(local).addSecs(2 * 60 * 60).time() == QTime(3, 0)) { + // Israel, Asia/{Jerusalem,Tel_Aviv} according to glibc at 02:00 on March 27th. + date = friday; + time = QTime(2, 30); + } else if (date.startOfDay(local).time() < time) { + // Most of Europeean EET, e.g. Finland. + time = QTime(3, 30); + } + QTest::newRow("Local (EET) from day before") + << local << date << time << 1 << 120; + QTest::newRow("Local (EET) from day after") + << local << date << time << -1 << 180; } else if (winter == 1420070400 && summer == 1435705200) { // Western European Time, WET/WEST; a.k.a. GMT/BST - QTest::newRow("WET from day before") << QDate(2015, 3, 29) << QTime(1, 30, 0) << 1 << 0; - QTest::newRow("WET from day after") << QDate(2015, 3, 29) << QTime(1, 30, 0) << -1 << 60; + QTest::newRow("Local (WET) from day before") + << local << QDate(2015, 3, 29) << QTime(1, 30) << 1 << 0; + QTest::newRow("Local (WET) from day after") + << local << QDate(2015, 3, 29) << QTime(1, 30) << -1 << 60; } else if (winter == 1420099200 && summer == 1435734000) { // Western USA, Canada: Pacific Time (e.g. US/Pacific) - QTest::newRow("PT from day before") << QDate(2015, 3, 8) << QTime(2, 30, 0) << 1 << -480; - QTest::newRow("PT from day after") << QDate(2015, 3, 8) << QTime(2, 30, 0) << -1 << -420; + QDate date(2015, 3, 8); + // America/Ensenada did its transition on April 5th, like the rest of Mexico. + if (QDate(2015, 4, 1).startOfDay().toSecsSinceEpoch() == 1427875200) + date = QDate(2015, 4, 5); + QTest::newRow("Local (PT) from day before") + << local << date << QTime(2, 30) << 1 << -480; + QTest::newRow("Local (PT) from day after") + << local << date << QTime(2, 30) << -1 << -420; } else if (winter == 1420088400 && summer == 1435723200) { // Eastern USA, Canada: Eastern Time (e.g. US/Eastern) - QTest::newRow("ET from day before") << QDate(2015, 3, 8) << QTime(2, 30, 0) << 1 << -300; - QTest::newRow("ET from day after") << QDate(2015, 3, 8) << QTime(2, 30, 0) << -1 << -240; + // Havana matches offset and date, but at midnight. + const QTime start = QDate(2015, 3, 8).startOfDay(local).time(); + const QTime when = start == QTime(0, 0) ? QTime(2, 30) : QTime(0, 30); + QTest::newRow("Local(ET) from day before") + << local << QDate(2015, 3, 8) << when << 1 << -300; + QTest::newRow("Local(ET) from day after") + << local << QDate(2015, 3, 8) << when << -1 << -240; +#if !QT_CONFIG(timezone) } else { // Includes the numbers you need to test for your zone, as above: QString msg(QString::fromLatin1("No spring forward test data for this TZ (%1, %2)" ).arg(winter).arg(summer)); QSKIP(qPrintable(msg)); +#endif + } +#if QT_CONFIG(timezone) + if (const QTimeZone cet("Europe/Oslo"); cet.isValid()) { + QTest::newRow("CET from day before") + << cet << QDate(2015, 3, 29) << QTime(2, 30) << 1 << 60; + QTest::newRow("CET from day after") + << cet << QDate(2015, 3, 29) << QTime(2, 30) << -1 << 120; + } + if (const QTimeZone eet("Europe/Helsinki"); eet.isValid()) { + QTest::newRow("EET from day before") + << eet << QDate(2015, 3, 29) << QTime(3, 30) << 1 << 120; + QTest::newRow("EET from day after") + << eet << QDate(2015, 3, 29) << QTime(3, 30) << -1 << 180; + } + if (const QTimeZone wet("Europe/Lisbon"); wet.isValid()) { + QTest::newRow("WET from day before") + << wet << QDate(2015, 3, 29) << QTime(1, 30) << 1 << 0; + QTest::newRow("WET from day after") + << wet << QDate(2015, 3, 29) << QTime(1, 30) << -1 << 60; + } + if (const QTimeZone pacific("America/Vancouver"); pacific.isValid()) { + QTest::newRow("PT from day before") + << pacific << QDate(2015, 3, 8) << QTime(2, 30) << 1 << -480; + QTest::newRow("PT from day after") + << pacific << QDate(2015, 3, 8) << QTime(2, 30) << -1 << -420; + } + if (const QTimeZone eastern("America/Ottawa"); eastern.isValid()) { + QTest::newRow("ET from day before") + << eastern << QDate(2015, 3, 8) << QTime(2, 30) << 1 << -300; + QTest::newRow("ET from day after") + << eastern << QDate(2015, 3, 8) << QTime(2, 30) << -1 << -240; } +#endif } void tst_QDateTime::springForward() { + QFETCH(QTimeZone, zone); QFETCH(QDate, day); QFETCH(QTime, time); QFETCH(int, step); QFETCH(int, adjust); - QDateTime direct = QDateTime(day.addDays(-step), time, Qt::LocalTime).addDays(step); - if (direct.isValid()) { // mktime() may deem a time in the gap invalid - QCOMPARE(direct.date(), day); - QCOMPARE(direct.time().minute(), time.minute()); - QCOMPARE(direct.time().second(), time.second()); - int off = direct.time().hour() - time.hour(); - QVERIFY(off == 1 || off == -1); - // Note: function doc claims always +1, but this should be reviewed ! - } - - // Repeat, but getting there via .toLocalTime(): - QDateTime detour = QDateTime(day.addDays(-step), - time.addSecs(-60 * adjust), - Qt::UTC).toLocalTime(); + QDateTime direct = QDateTime(day.addDays(-step), time, zone).addDays(step); + QVERIFY(direct.isValid()); + QCOMPARE(direct.date(), day); + QCOMPARE(direct.time().minute(), time.minute()); + QCOMPARE(direct.time().second(), time.second()); + const int off = step < 0 ? -1 : 1; + QCOMPARE(direct.time().hour() - time.hour(), off); + // adjust is the offset on the other side of the gap: + QCOMPARE(direct.offsetFromUtc(), (adjust + off * 60) * 60); + + // Repeat, but getting there via .toTimeZone(). Apply adjust to datetime, + // not time, as the time wraps round if the adjustment crosses midnight. + QDateTime detour = QDateTime(day.addDays(-step), time, + UTC).addSecs(-60 * adjust).toTimeZone(zone); QCOMPARE(detour.time(), time); detour = detour.addDays(step); // Insist on consistency: - if (direct.isValid()) - QCOMPARE(detour, direct); - else - QVERIFY(!detour.isValid()); + QCOMPARE(detour, direct); + QCOMPARE(detour.offsetFromUtc(), direct.offsetFromUtc()); } void tst_QDateTime::operator_eqeq_data() @@ -1942,14 +2414,14 @@ void tst_QDateTime::operator_eqeq_data() QDateTime dateTime1a = dateTime1.addMSecs(1); QDateTime dateTime2(QDate(2012, 20, 6), QTime(14, 33, 2, 500)); // Invalid QDateTime dateTime2a = dateTime2.addMSecs(-1); // Still invalid - QDateTime dateTime3(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC); // UTC epoch + QDateTime dateTime3(QDate(1970, 1, 1), QTime(0, 0), UTC); // UTC epoch QDateTime dateTime3a = dateTime3.addDays(1); QDateTime dateTime3b = dateTime3.addDays(-1); // Ensure that different times may be equal when considering timezone. QDateTime dateTime3c(dateTime3.addSecs(3600)); - dateTime3c.setOffsetFromUtc(3600); + dateTime3c.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(3600)); QDateTime dateTime3d(dateTime3.addSecs(-3600)); - dateTime3d.setOffsetFromUtc(-3600); + dateTime3d.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-3600)); QDateTime dateTime3e(dateTime3.date(), dateTime3.time()); // Local time's epoch QTest::newRow("data0") << dateTime1 << dateTime1 << true << false; @@ -1965,18 +2437,32 @@ void tst_QDateTime::operator_eqeq_data() QTest::newRow("data10") << dateTime3 << dateTime3c << true << false; QTest::newRow("data11") << dateTime3 << dateTime3d << true << false; QTest::newRow("data12") << dateTime3c << dateTime3d << true << false; - if (localTimeType == LocalTimeIsUtc) + if (epochTimeType == LocalTimeIsUtc) QTest::newRow("data13") << dateTime3 << dateTime3e << true << false; // ... but a zone (sometimes) ahead of or behind UTC (e.g. Europe/London) // might agree with UTC about the epoch, all the same. QTest::newRow("invalid == invalid") << QDateTime() << QDateTime() << true << false; - QTest::newRow("invalid == valid #1") << QDateTime() << dateTime1 << false << false; + QTest::newRow("invalid != valid #1") << QDateTime() << dateTime1 << false << false; if (zoneIsCET) { - QTest::newRow("data14") << QDateTime(QDate(2004, 1, 2), QTime(2, 2, 3), Qt::LocalTime) - << QDateTime(QDate(2004, 1, 2), QTime(1, 2, 3), Qt::UTC) << true << true; + QTest::newRow("data14") + << QDateTime(QDate(2004, 1, 2), QTime(2, 2, 3)) + << QDateTime(QDate(2004, 1, 2), QTime(1, 2, 3), UTC) << true << true; + QTest::newRow("local-fall-back") // Sun, 31 Oct 2004, 02:30, both ways round: + << QDateTime::fromMSecsSinceEpoch(Q_INT64_C(1099186200000)) + << QDateTime::fromMSecsSinceEpoch(Q_INT64_C(1099182600000)) + << false << false; + } +#if QT_CONFIG(timezone) + const QTimeZone CET("Europe/Oslo"); + if (CET.isValid()) { + QTest::newRow("CET-fall-back") // Sun, 31 Oct 2004, 02:30, both ways round: + << QDateTime::fromMSecsSinceEpoch(Q_INT64_C(1099186200000), CET) + << QDateTime::fromMSecsSinceEpoch(Q_INT64_C(1099182600000), CET) + << false << false; } +#endif } void tst_QDateTime::operator_eqeq() @@ -1986,23 +2472,16 @@ void tst_QDateTime::operator_eqeq() QFETCH(bool, expectEqual); QFETCH(bool, checkEuro); - QVERIFY(dt1 == dt1); - QVERIFY(!(dt1 != dt1)); - - QVERIFY(dt2 == dt2); - QVERIFY(!(dt2 != dt2)); + QT_TEST_EQUALITY_OPS(dt1, dt1, true); + QT_TEST_EQUALITY_OPS(dt2, dt2, true); + QT_TEST_EQUALITY_OPS(dt1, dt2, expectEqual); QVERIFY(dt1 != QDateTime::currentDateTime()); QVERIFY(dt2 != QDateTime::currentDateTime()); QVERIFY(dt1.toUTC() == dt1.toUTC()); - bool equal = dt1 == dt2; - QCOMPARE(equal, expectEqual); - bool notEqual = dt1 != dt2; - QCOMPARE(notEqual, !expectEqual); - - if (equal) + if (expectEqual) QVERIFY(qHash(dt1) == qHash(dt2)); if (checkEuro && zoneIsCET) { @@ -2011,6 +2490,64 @@ void tst_QDateTime::operator_eqeq() } } +void tst_QDateTime::ordering_data() +{ + QTest::addColumn<QDateTime>("left"); + QTest::addColumn<QDateTime>("right"); + QTest::addColumn<Qt::weak_ordering>("expectedOrdering"); + + Q_CONSTINIT static const auto constructName = [](const QDateTime &dt) -> QByteArray { + if (dt.isNull()) + return "null"; + if (!dt.isValid()) + return "invalid"; + return dt.toString(Qt::ISODateWithMs).toLatin1(); + }; + + Q_CONSTINIT static const auto generateRow = + [](const QDateTime &left, const QDateTime &right, Qt::weak_ordering ordering) { + const QByteArray leftStr = constructName(left); + const QByteArray rightStr = constructName(right); + QTest::addRow("%s_vs_%s", leftStr.constData(), rightStr.constData()) + << left << right << ordering; + }; + + QDateTime june(QDate(2012, 6, 20), QTime(14, 33, 2, 500)); + QDateTime juneLater = june.addMSecs(1); + QDateTime badDay(QDate(2012, 20, 6), QTime(14, 33, 2, 500)); // Invalid + QDateTime epoch(QDate(1970, 1, 1), QTime(0, 0), UTC); // UTC epoch + QDateTime nextDay = epoch.addDays(1); + QDateTime prevDay = epoch.addDays(-1); + // Ensure that different times may be equal when considering timezone. + QDateTime epochEast1h(epoch.addSecs(3600)); + epochEast1h.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(3600)); + QDateTime epochWest1h(epoch.addSecs(-3600)); + epochWest1h.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-3600)); + QDateTime local1970(epoch.date(), epoch.time()); // Local time's epoch + + generateRow(june, june, Qt::weak_ordering::equivalent); + generateRow(june, juneLater, Qt::weak_ordering::less); + generateRow(june, badDay, Qt::weak_ordering::greater); + generateRow(badDay, QDateTime(), Qt::weak_ordering::equivalent); + generateRow(june, QDateTime(), Qt::weak_ordering::greater); + generateRow(epoch, nextDay, Qt::weak_ordering::less); + generateRow(epoch, prevDay, Qt::weak_ordering::greater); + generateRow(epoch, epochEast1h, Qt::weak_ordering::equivalent); + generateRow(epoch, epochWest1h, Qt::weak_ordering::equivalent); + generateRow(epochEast1h, epochWest1h, Qt::weak_ordering::equivalent); + if (epochTimeType == LocalTimeIsUtc) + generateRow(epoch, local1970, Qt::weak_ordering::equivalent); +} + +void tst_QDateTime::ordering() +{ + QFETCH(QDateTime, left); + QFETCH(QDateTime, right); + QFETCH(Qt::weak_ordering, expectedOrdering); + + QT_TEST_ALL_COMPARISON_OPS(left, right, expectedOrdering); +} + Q_DECLARE_METATYPE(QDataStream::Version) void tst_QDateTime::operator_insert_extract_data() @@ -2050,7 +2587,7 @@ void tst_QDateTime::operator_insert_extract() TimeZoneRollback useZone(serialiseAs); // It is important that dateTime is created after the time zone shift - QDateTime dateTime(QDate(yearNumber, 8, 14), QTime(8, 0), Qt::LocalTime); + QDateTime dateTime(QDate(yearNumber, 8, 14), QTime(8, 0)); QDateTime dateTimeAsUTC(dateTime.toUTC()); QByteArray byteArray; @@ -2076,7 +2613,8 @@ void tst_QDateTime::operator_insert_extract() // Ensure that a change in timezone between serialisation and deserialisation // still results in identical UTC-converted datetimes. useZone.reset(deserialiseAs); - QDateTime expectedLocalTime(dateTimeAsUTC.toLocalTime()); + QDateTime expectedLocalTime(dateTimeAsUTC.toLocalTime()); // *After* resetting zone. + QCOMPARE(expectedLocalTime, dateTimeAsUTC); // Different description, same moment in time. { // Deserialise whole QDateTime at once. QDataStream dataStream(&byteArray, QIODevice::ReadOnly); @@ -2092,7 +2630,7 @@ void tst_QDateTime::operator_insert_extract() if (dataStreamVersion < QDataStream::Qt_4_0) { // Versions lower than Qt 4 don't serialise the timeSpec, instead // assuming that everything is LocalTime. - deserialised.setTimeSpec(Qt::UTC); + deserialised.setTimeZone(UTC); } // Qt 4.* versions do serialise the timeSpec, so we only need to convert from UTC here. deserialised = deserialised.toLocalTime(); @@ -2110,9 +2648,17 @@ void tst_QDateTime::operator_insert_extract() qint8 deserialisedSpec; if (dataStreamVersion >= QDataStream::Qt_4_0) dataStream >> deserialisedSpec; - deserialised = QDateTime(deserialisedDate, deserialisedTime, Qt::UTC); - if (dataStreamVersion >= QDataStream::Qt_4_0) - deserialised = deserialised.toTimeSpec(static_cast<Qt::TimeSpec>(deserialisedSpec)); + deserialised = QDateTime(deserialisedDate, deserialisedTime, UTC); + QCOMPARE(deserialised.toLocalTime(), deserialised); + const auto isLocalTime = [](qint8 spec) -> bool { + // The spec is in fact a QDateTimePrivate::Spec, not Qt::TimeSpec; + // and no offset or zone is stored, so only UTC and LocalTime are + // really supported. Fortunately this test only uses those. + const auto decoded = static_cast<QDateTimePrivate::Spec>(spec); + return decoded != QDateTimePrivate::UTC && decoded != QDateTimePrivate::OffsetFromUTC; + }; + if (dataStreamVersion >= QDataStream::Qt_4_0 && isLocalTime(deserialisedSpec)) + deserialised = deserialised.toTimeZone(QTimeZone::LocalTime); // Ensure local time is still correct. QCOMPARE(deserialised, expectedLocalTime); // Sanity check UTC times. @@ -2135,90 +2681,114 @@ void tst_QDateTime::fromStringDateFormat_data() QTest::addColumn<Qt::DateFormat>("dateFormat"); QTest::addColumn<QDateTime>("expected"); + // Fails 1970 start dates in western Mexico + // due to changing from PST to MST at the start of 1970. + const bool goodEpochStart = QDateTime(QDate(1970, 1, 1), QTime(0, 0)).isValid(); + // Test Qt::TextDate format. QTest::newRow("text date") << QString::fromLatin1("Tue Jun 17 08:00:10 2003") - << Qt::TextDate << QDateTime(QDate(2003, 6, 17), QTime(8, 0, 10, 0), Qt::LocalTime); + << Qt::TextDate << QDateTime(QDate(2003, 6, 17), QTime(8, 0, 10)); QTest::newRow("text date Year 0999") << QString::fromLatin1("Tue Jun 17 08:00:10 0999") - << Qt::TextDate << QDateTime(QDate(999, 6, 17), QTime(8, 0, 10, 0), Qt::LocalTime); + << Qt::TextDate << QDateTime(QDate(999, 6, 17), QTime(8, 0, 10)); QTest::newRow("text date Year 999") << QString::fromLatin1("Tue Jun 17 08:00:10 999") - << Qt::TextDate << QDateTime(QDate(999, 6, 17), QTime(8, 0, 10, 0), Qt::LocalTime); + << Qt::TextDate << QDateTime(QDate(999, 6, 17), QTime(8, 0, 10)); QTest::newRow("text date Year 12345") << QString::fromLatin1("Tue Jun 17 08:00:10 12345") - << Qt::TextDate << QDateTime(QDate(12345, 6, 17), QTime(8, 0, 10, 0), Qt::LocalTime); + << Qt::TextDate << QDateTime(QDate(12345, 6, 17), QTime(8, 0, 10)); QTest::newRow("text date Year -4712") << QString::fromLatin1("Tue Jan 1 00:01:02 -4712") - << Qt::TextDate << QDateTime(QDate(-4712, 1, 1), QTime(0, 1, 2, 0), Qt::LocalTime); - QTest::newRow("text data0") << QString::fromLatin1("Thu Jan 1 00:00:00 1970") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::LocalTime); + << Qt::TextDate << QDateTime(QDate(-4712, 1, 1), QTime(0, 1, 2)); QTest::newRow("text data1") << QString::fromLatin1("Thu Jan 2 12:34 1970") - << Qt::TextDate << QDateTime(QDate(1970, 1, 2), QTime(12, 34, 0), Qt::LocalTime); - QTest::newRow("text data2") << QString::fromLatin1("Thu Jan 1 00 1970") - << Qt::TextDate << QDateTime(); - QTest::newRow("text data3") << QString::fromLatin1("Thu Jan 1 00:00:00:00 1970") - << Qt::TextDate << QDateTime(); - QTest::newRow("text data4") << QString::fromLatin1("Thu 1. Jan 00:00:00 1970") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::LocalTime); - QTest::newRow("text data5") << QString::fromLatin1(" Thu Jan 1 00:00:00 1970 ") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::LocalTime); + << Qt::TextDate << QDateTime(QDate(1970, 1, 2), QTime(12, 34)); + if (goodEpochStart) { + QTest::newRow("text epoch year after time") + << QString::fromLatin1("Thu Jan 1 00:00:00 1970") << Qt::TextDate + << QDate(1970, 1, 1).startOfDay(); + QTest::newRow("text epoch spaced") + << QString::fromLatin1(" Thu Jan 1 00:00:00 1970 ") + << Qt::TextDate << QDate(1970, 1, 1).startOfDay(); + QTest::newRow("text epoch time after year") + << QString::fromLatin1("Thu Jan 1 1970 00:00:00") + << Qt::TextDate << QDate(1970, 1, 1).startOfDay(); + } + QTest::newRow("text epoch terse") + << QString::fromLatin1("Thu Jan 1 00 1970") << Qt::TextDate << QDateTime(); + QTest::newRow("text epoch stray :00") + << QString::fromLatin1("Thu Jan 1 00:00:00:00 1970") << Qt::TextDate << QDateTime(); QTest::newRow("text data6") << QString::fromLatin1("Thu Jan 1 00:00:00") << Qt::TextDate << QDateTime(); - QTest::newRow("text data7") << QString::fromLatin1("Thu Jan 1 1970 00:00:00") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 0), Qt::LocalTime); - QTest::newRow("text data8") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 GMT+foo") + QTest::newRow("text bad offset") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 UTC+foo") << Qt::TextDate << QDateTime(); - QTest::newRow("text data9") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 GMT") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); - QTest::newRow("text data10") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 GMT-0300") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(3, 12, 34), Qt::UTC); - QTest::newRow("text data11") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 GMT+0300") - << Qt::TextDate << QDateTime(QDate(1969, 12, 31), QTime(21, 12, 34), Qt::UTC); - QTest::newRow("text data12") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 gmt") - << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); - QTest::newRow("text data13") << QString::fromLatin1("Thu Jan 1 1970 00:12:34 GMT+0100") - << Qt::TextDate << QDateTime(QDate(1969, 12, 31), QTime(23, 12, 34), Qt::UTC); + QTest::newRow("text UTC early") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 UTC") + << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); + QTest::newRow("text UTC-3 early") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 UTC-0300") + << Qt::TextDate << QDateTime(QDate(1970, 1, 1), QTime(3, 12, 34), UTC); + QTest::newRow("text UTC+3 early") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 UTC+0300") + << Qt::TextDate << QDateTime(QDate(1969, 12, 31), QTime(21, 12, 34), UTC); + QTest::newRow("text UTC+1 early") << QString::fromLatin1("Thu Jan 1 1970 00:12:34 UTC+0100") + << Qt::TextDate << QDateTime(QDate(1969, 12, 31), QTime(23, 12, 34), UTC); + // We produce use GMT as prefix, so need to parse it: + QTest::newRow("text GMT early") + << QString::fromLatin1("Thu Jan 1 00:12:34 1970 GMT") << Qt::TextDate + << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); + QTest::newRow("text GMT+3 early") + << QString::fromLatin1("Thu Jan 1 00:12:34 1970 GMT+0300") << Qt::TextDate + << QDateTime(QDate(1969, 12, 31), QTime(21, 12, 34), UTC); + // ... and we match (only) it case-insensitively: + QTest::newRow("text gmt early") + << QString::fromLatin1("Thu Jan 1 00:12:34 1970 gmt") << Qt::TextDate + << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); + QTest::newRow("text empty") << QString::fromLatin1("") << Qt::TextDate << QDateTime(); - QTest::newRow("text too many parts") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 gmt +0100") + QTest::newRow("text too many parts") << QString::fromLatin1("Thu Jan 1 00:12:34 1970 UTC +0100") << Qt::TextDate << QDateTime(); QTest::newRow("text invalid month name") << QString::fromLatin1("Thu Jaz 1 1970 00:12:34") << Qt::TextDate << QDateTime(); QTest::newRow("text invalid date") << QString::fromLatin1("Thu Jan 32 1970 00:12:34") << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid day #1") << QString::fromLatin1("Thu Jan XX 1970 00:12:34") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid day #2") << QString::fromLatin1("Thu X. Jan 00:00:00 1970") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid day #3") << QString::fromLatin1("Thu 1 Jan 00:00:00 1970") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid year #1") << QString::fromLatin1("Thu 1. Jan 00:00:00 19X0") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid year #2") << QString::fromLatin1("Thu 1. Jan 19X0 00:00:00") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid hour") << QString::fromLatin1("Thu 1. Jan 1970 0X:00:00") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid minute") << QString::fromLatin1("Thu 1. Jan 1970 00:0X:00") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid second") << QString::fromLatin1("Thu 1. Jan 1970 00:00:0X") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid gmt specifier #1") << QString::fromLatin1("Thu 1. Jan 1970 00:00:00 DMT") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid gmt specifier #2") << QString::fromLatin1("Thu 1. Jan 1970 00:00:00 GMTx0200") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid gmt hour") << QString::fromLatin1("Thu 1. Jan 1970 00:00:00 GMT+0X00") - << Qt::TextDate << QDateTime(); - QTest::newRow("text invalid gmt minute") << QString::fromLatin1("Thu 1. Jan 1970 00:00:00 GMT+000X") - << Qt::TextDate << QDateTime(); - QTest::newRow("text second fraction") << QString::fromLatin1("Mon 6. May 2013 01:02:03.456") + QTest::newRow("text pre-5.2 MS-Win format") // Support dropped in 6.2 + << QString::fromLatin1("Thu 1. Jan 00:00:00 1970") << Qt::TextDate << QDateTime(); + QTest::newRow("text invalid day") + << QString::fromLatin1("Thu Jan XX 1970 00:12:34") << Qt::TextDate << QDateTime(); + QTest::newRow("text misplaced day") + << QString::fromLatin1("Thu 1 Jan 00:00:00 1970") << Qt::TextDate << QDateTime(); + QTest::newRow("text invalid year end") + << QString::fromLatin1("Thu Jan 1 00:00:00 19X0") << Qt::TextDate << QDateTime(); + QTest::newRow("text invalid year early") + << QString::fromLatin1("Thu Jan 1 19X0 00:00:00") << Qt::TextDate << QDateTime(); + QTest::newRow("text invalid hour") + << QString::fromLatin1("Thu Jan 1 1970 0X:00:00") << Qt::TextDate << QDateTime(); + QTest::newRow("text invalid minute") + << QString::fromLatin1("Thu Jan 1 1970 00:0X:00") << Qt::TextDate << QDateTime(); + QTest::newRow("text invalid second") + << QString::fromLatin1("Thu Jan 1 1970 00:00:0X") << Qt::TextDate << QDateTime(); + QTest::newRow("text non-UTC offset") + << QString::fromLatin1("Thu Jan 1 1970 00:00:00 DMT") << Qt::TextDate << QDateTime(); + QTest::newRow("text bad UTC offset") + << QString::fromLatin1("Thu Jan 1 1970 00:00:00 UTCx0200") << Qt::TextDate << QDateTime(); + QTest::newRow("text bad UTC hour") + << QString::fromLatin1("Thu Jan 1 1970 00:00:00 UTC+0X00") << Qt::TextDate << QDateTime(); + QTest::newRow("text bad UTC minute") + << QString::fromLatin1("Thu Jan 1 1970 00:00:00 UTC+000X") << Qt::TextDate << QDateTime(); + + QTest::newRow("text second fraction") + << QString::fromLatin1("Mon May 6 2013 01:02:03.456") << Qt::TextDate << QDateTime(QDate(2013, 5, 6), QTime(1, 2, 3, 456)); - - const QDateTime ref(QDate(1974, 12, 1), QTime(13, 2)); - QTest::newRow("day:,:month") - << QStringLiteral("Sun 1. Dec 13:02:00 1974") << Qt::TextDate << ref; - QTest::newRow("month:day") - << QStringLiteral("Sun Dec 1 13:02:00 1974") << Qt::TextDate << ref; + QTest::newRow("text max milli") + << QString::fromLatin1("Mon May 6 2013 01:02:03.999499999") + << Qt::TextDate << QDateTime(QDate(2013, 5, 6), QTime(1, 2, 3, 999)); + QTest::newRow("text milli wrap") + << QString::fromLatin1("Mon May 6 2013 01:02:03.9995") + << Qt::TextDate << QDateTime(QDate(2013, 5, 6), QTime(1, 2, 4)); + QTest::newRow("text last milli") // Special case, don't round up to invalid: + << QString::fromLatin1("Mon May 6 2013 23:59:59.9999999999") + << Qt::TextDate << QDateTime(QDate(2013, 5, 6), QTime(23, 59, 59, 999)); + QTest::newRow("text Sunday lunch") + << QStringLiteral("Sun Dec 1 13:02:00 1974") << Qt::TextDate + << QDateTime(QDate(1974, 12, 1), QTime(13, 2)); // Test Qt::ISODate format. QTest::newRow("trailing space") // QTBUG-80445 - << QString("2000-01-02 03:04:05.678 ") - << Qt::ISODate << QDateTime(QDate(2000, 1, 2), QTime(3, 4, 5, 678)); + << QString("2000-01-02 03:04:05.678 ") << Qt::ISODate << QDateTime(); // Invalid spaces (but keeping field widths correct): QTest::newRow("space before millis") @@ -2261,80 +2831,108 @@ void tst_QDateTime::fromStringDateFormat_data() // Normal usage: QTest::newRow("ISO +01:00") << QString::fromLatin1("1987-02-13T13:24:51+01:00") - << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("ISO +00:01") << QString::fromLatin1("1987-02-13T13:24:51+00:01") - << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(13, 23, 51), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(13, 23, 51), UTC); QTest::newRow("ISO -01:00") << QString::fromLatin1("1987-02-13T13:24:51-01:00") - << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), UTC); QTest::newRow("ISO -00:01") << QString::fromLatin1("1987-02-13T13:24:51-00:01") - << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(13, 25, 51), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(1987, 2, 13), QTime(13, 25, 51), UTC); QTest::newRow("ISO +0000") << QString::fromLatin1("1970-01-01T00:12:34+0000") - << Qt::ISODate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); QTest::newRow("ISO +00:00") << QString::fromLatin1("1970-01-01T00:12:34+00:00") - << Qt::ISODate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); QTest::newRow("ISO -03") << QString::fromLatin1("2014-12-15T12:37:09-03") - << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9), UTC); QTest::newRow("ISO zzz-03") << QString::fromLatin1("2014-12-15T12:37:09.745-03") - << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9, 745), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9, 745), UTC); QTest::newRow("ISO -3") << QString::fromLatin1("2014-12-15T12:37:09-3") - << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9), UTC); QTest::newRow("ISO zzz-3") << QString::fromLatin1("2014-12-15T12:37:09.745-3") - << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9, 745), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2014, 12, 15), QTime(15, 37, 9, 745), UTC); QTest::newRow("ISO lower-case") << QString::fromLatin1("2005-06-28T07:57:30.002z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 2), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 2), UTC); // No time specified - defaults to Qt::LocalTime. QTest::newRow("ISO data3") << QString::fromLatin1("2002-10-01") - << Qt::ISODate << QDateTime(QDate(2002, 10, 1), QTime(0, 0), Qt::LocalTime); + << Qt::ISODate << QDate(2002, 10, 1).startOfDay(); // Excess digits in milliseconds, round correctly: QTest::newRow("ISO") << QString::fromLatin1("2005-06-28T07:57:30.0010000000Z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), UTC); QTest::newRow("ISO rounding") << QString::fromLatin1("2005-06-28T07:57:30.0015Z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 2), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 2), UTC); // ... and accept comma as separator: QTest::newRow("ISO with comma 1") << QString::fromLatin1("2005-06-28T07:57:30,0040000000Z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 4), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 4), UTC); QTest::newRow("ISO with comma 2") << QString::fromLatin1("2005-06-28T07:57:30,0015Z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 2), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 2), UTC); QTest::newRow("ISO with comma 3") << QString::fromLatin1("2005-06-28T07:57:30,0014Z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), UTC); QTest::newRow("ISO with comma 4") << QString::fromLatin1("2005-06-28T07:57:30,1Z") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 100), Qt::UTC); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 100), UTC); QTest::newRow("ISO with comma 5") << QString::fromLatin1("2005-06-28T07:57:30,11") - << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 110), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 110)); // 24:00:00 Should be next day according to ISO 8601 section 4.2.3. QTest::newRow("ISO 24:00") << QString::fromLatin1("2012-06-04T24:00:00") - << Qt::ISODate << QDateTime(QDate(2012, 6, 5), QTime(0, 0), Qt::LocalTime); - QTest::newRow("ISO 24:00 end of month") << QString::fromLatin1("2012-06-30T24:00:00") - << Qt::ISODate << QDateTime(QDate(2012, 7, 1), QTime(0, 0), Qt::LocalTime); - QTest::newRow("ISO 24:00 end of year") << QString::fromLatin1("2012-12-31T24:00:00") - << Qt::ISODate << QDateTime(QDate(2013, 1, 1), QTime(0, 0), Qt::LocalTime); - QTest::newRow("ISO 24:00, fract ms") << QString::fromLatin1("2012-01-01T24:00:00.000") - << Qt::ISODate << QDateTime(QDate(2012, 1, 2), QTime(0, 0), Qt::LocalTime); - QTest::newRow("ISO 24:00 end of year, fract ms") << QString::fromLatin1("2012-12-31T24:00:00.000") - << Qt::ISODate << QDateTime(QDate(2013, 1, 1), QTime(0, 0), Qt::LocalTime); + << Qt::ISODate << QDate(2012, 6, 5).startOfDay(); +#if QT_CONFIG(timezone) + const QByteArray sysId = QTimeZone::systemTimeZoneId(); + const bool midnightSkip = sysId == "America/Sao_Paulo" || sysId == "America/Asuncion" + || sysId == "America/Cordoba" || sysId == "America/Argentina/Cordoba" + || sysId == "America/Campo_Grande" + || sysId == "America/Cuiaba" || sysId == "America/Buenos_Aires" + || sysId == "America/Argentina/Buenos_Aires" + || sysId == "America/Argentina/Tucuman" || sysId == "Brazil/East"; + QTest::newRow("ISO 24:00 in DST") // Midnight spring forward in some of South America. + << QString::fromLatin1("2008-10-18T24:00") << Qt::ISODate + << QDateTime(QDate(2008, 10, 19), QTime(midnightSkip ? 1 : 0, 0)); +#endif + QTest::newRow("ISO 24:00 end of month") + << QString::fromLatin1("2012-06-30T24:00:00") + << Qt::ISODate << QDate(2012, 7, 1).startOfDay(); + QTest::newRow("ISO 24:00 end of year") + << QString::fromLatin1("2012-12-31T24:00:00") + << Qt::ISODate << QDate(2013, 1, 1).startOfDay(); + QTest::newRow("ISO 24:00, fract ms") + << QString::fromLatin1("2012-01-01T24:00:00.000") + << Qt::ISODate << QDate(2012, 1, 2).startOfDay(); + QTest::newRow("ISO 24:00 end of year, fract ms") + << QString::fromLatin1("2012-12-31T24:00:00.000") + << Qt::ISODate << QDate(2013, 1, 1).startOfDay(); // Test fractional seconds. - QTest::newRow("ISO .0 of a second (period)") << QString::fromLatin1("2012-01-01T08:00:00.0") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); + QTest::newRow("ISO .0 of a second (period)") + << QString::fromLatin1("2012-01-01T08:00:00.0") + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0)); QTest::newRow("ISO .00 of a second (period)") << QString::fromLatin1("2012-01-01T08:00:00.00") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0)); QTest::newRow("ISO .000 of a second (period)") << QString::fromLatin1("2012-01-01T08:00:00.000") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0)); QTest::newRow("ISO .1 of a second (comma)") << QString::fromLatin1("2012-01-01T08:00:00,1") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 100), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 100)); QTest::newRow("ISO .99 of a second (comma)") << QString::fromLatin1("2012-01-01T08:00:00,99") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 990), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 990)); QTest::newRow("ISO .998 of a second (comma)") << QString::fromLatin1("2012-01-01T08:00:00,998") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 998), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 998)); QTest::newRow("ISO .999 of a second (comma)") << QString::fromLatin1("2012-01-01T08:00:00,999") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 999), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 999)); QTest::newRow("ISO .3335 of a second (comma)") << QString::fromLatin1("2012-01-01T08:00:00,3335") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 334), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 334)); QTest::newRow("ISO .333333 of a second (comma)") << QString::fromLatin1("2012-01-01T08:00:00,333333") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 333), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 333)); QTest::newRow("ISO .00009 of a second (period)") << QString::fromLatin1("2012-01-01T08:00:00.00009") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); - QTest::newRow("ISO no fract specified") << QString::fromLatin1("2012-01-01T08:00:00.") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0)); + QTest::newRow("ISO second fraction") << QString::fromLatin1("2013-05-06T01:02:03.456") + << Qt::ISODate << QDateTime(QDate(2013, 5, 6), QTime(1, 2, 3, 456)); + QTest::newRow("ISO max milli") + << QString::fromLatin1("2013-05-06T01:02:03.999499999") + << Qt::ISODate << QDateTime(QDate(2013, 5, 6), QTime(1, 2, 3, 999)); + QTest::newRow("ISO milli wrap") + << QString::fromLatin1("2013-05-06T01:02:03.9995") + << Qt::ISODate << QDateTime(QDate(2013, 5, 6), QTime(1, 2, 4)); + QTest::newRow("ISO last milli") // Does round up and overflow into new day: + << QString::fromLatin1("2013-05-06T23:59:59.9999999999") + << Qt::ISODate << QDate(2013, 5, 7).startOfDay(); + QTest::newRow("ISO no fraction specified") + << QString::fromLatin1("2012-01-01T08:00:00.") << Qt::ISODate << QDateTime(); // Test invalid characters (should ignore invalid characters at end of string). QTest::newRow("ISO invalid character at end") << QString::fromLatin1("2012-01-01T08:00:00!") << Qt::ISODate << QDateTime(); @@ -2348,17 +2946,17 @@ void tst_QDateTime::fromStringDateFormat_data() << Qt::ISODate << QDateTime(); // Test fractional minutes. QTest::newRow("ISO .0 of a minute (period)") << QString::fromLatin1("2012-01-01T08:00.0") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0)); QTest::newRow("ISO .8 of a minute (period)") << QString::fromLatin1("2012-01-01T08:00.8") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 48, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 48)); QTest::newRow("ISO .99999 of a minute (period)") << QString::fromLatin1("2012-01-01T08:00.99999") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 59, 999), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 59, 999)); QTest::newRow("ISO .0 of a minute (comma)") << QString::fromLatin1("2012-01-01T08:00,0") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 0, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0)); QTest::newRow("ISO .8 of a minute (comma)") << QString::fromLatin1("2012-01-01T08:00,8") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 48, 0), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 48)); QTest::newRow("ISO .99999 of a minute (comma)") << QString::fromLatin1("2012-01-01T08:00,99999") - << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 59, 999), Qt::LocalTime); + << Qt::ISODate << QDateTime(QDate(2012, 1, 1), QTime(8, 0, 59, 999)); QTest::newRow("ISO empty") << QString::fromLatin1("") << Qt::ISODate << QDateTime(); QTest::newRow("ISO short") << QString::fromLatin1("2017-07-01T") << Qt::ISODate << QDateTime(); QTest::newRow("ISO zoned date") @@ -2370,37 +2968,45 @@ void tst_QDateTime::fromStringDateFormat_data() // Test Qt::RFC2822Date format (RFC 2822). QTest::newRow("RFC 2822 +0100") << QString::fromLatin1("13 Feb 1987 13:24:51 +0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("RFC 2822 after space +0100") << QString::fromLatin1(" 13 Feb 1987 13:24:51 +0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("RFC 2822 with day +0100") << QString::fromLatin1("Fri, 13 Feb 1987 13:24:51 +0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("RFC 2822 with day after space +0100") << QString::fromLatin1(" Fri, 13 Feb 1987 13:24:51 +0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("RFC 2822 -0100") << QString::fromLatin1("13 Feb 1987 13:24:51 -0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), UTC); QTest::newRow("RFC 2822 with day -0100") << QString::fromLatin1("Fri, 13 Feb 1987 13:24:51 -0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), Qt::UTC); - QTest::newRow("RFC 2822 +0000") << QString::fromLatin1("01 Jan 1970 00:12:34 +0000") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); - QTest::newRow("RFC 2822 with day +0000") << QString::fromLatin1("Thu, 01 Jan 1970 00:12:34 +0000") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), UTC); QTest::newRow("RFC 2822 +0000") << QString::fromLatin1("01 Jan 1970 00:12:34 +0000") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); QTest::newRow("RFC 2822 with day +0000") << QString::fromLatin1("Thu, 01 Jan 1970 00:12:34 +0000") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); QTest::newRow("RFC 2822 missing space before +0100") << QString::fromLatin1("Thu, 01 Jan 1970 00:12:34+0100") << Qt::RFC2822Date << QDateTime(); // No timezone assume UTC QTest::newRow("RFC 2822 no timezone") << QString::fromLatin1("01 Jan 1970 00:12:34") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); // No time specified QTest::newRow("RFC 2822 date only") << QString::fromLatin1("01 Nov 2002") << Qt::RFC2822Date << QDateTime(); QTest::newRow("RFC 2822 with day date only") << QString::fromLatin1("Fri, 01 Nov 2002") << Qt::RFC2822Date << QDateTime(); + + QTest::newRow("RFC 2822 malformed time (truncated)") + << QString::fromLatin1("01 Nov 2002 0:") << Qt::RFC2822Date << QDateTime(); + QTest::newRow("RFC 2822 malformed time (hour)") + << QString::fromLatin1("01 Nov 2002 7:35:21") << Qt::RFC2822Date << QDateTime(); + QTest::newRow("RFC 2822 malformed time (minute)") + << QString::fromLatin1("01 Nov 2002 07:5:21") << Qt::RFC2822Date << QDateTime(); + QTest::newRow("RFC 2822 malformed time (second)") + << QString::fromLatin1("01 Nov 2002 07:35:1") << Qt::RFC2822Date << QDateTime(); + QTest::newRow("RFC 2822 malformed time (fraction-second)") + << QString::fromLatin1("01 Nov 2002 07:35:15.200") << Qt::RFC2822Date << QDateTime(); + // Test invalid month, day, year QTest::newRow("RFC 2822 invalid month name") << QString::fromLatin1("13 Fev 1987 13:24:51 +0100") << Qt::RFC2822Date << QDateTime(); @@ -2428,23 +3034,21 @@ void tst_QDateTime::fromStringDateFormat_data() // sure *it's* not what's invalid: QTest::newRow("RFC 2822 (not invalid)") << QString::fromLatin1("01 Jan 2012 08:00:00 +0100") - << Qt::RFC2822Date << QDateTime(QDate(2012, 1, 1), QTime(7, 0), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(2012, 1, 1), QTime(7, 0), UTC); // Test Qt::RFC2822Date format (RFC 850 and 1036, permissive). QTest::newRow("RFC 850 and 1036 +0100") << QString::fromLatin1("Fri Feb 13 13:24:51 1987 +0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("RFC 1036 after space +0100") << QString::fromLatin1(" Fri Feb 13 13:24:51 1987 +0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(12, 24, 51), UTC); QTest::newRow("RFC 850 and 1036 -0100") << QString::fromLatin1("Fri Feb 13 13:24:51 1987 -0100") - << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1987, 2, 13), QTime(14, 24, 51), UTC); QTest::newRow("RFC 850 and 1036 +0000") << QString::fromLatin1("Thu Jan 01 00:12:34 1970 +0000") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); - QTest::newRow("RFC 850 and 1036 +0000") << QString::fromLatin1("Thu Jan 01 00:12:34 1970 +0000") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); // No timezone assume UTC QTest::newRow("RFC 850 and 1036 no timezone") << QString::fromLatin1("Thu Jan 01 00:12:34 1970") - << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(1970, 1, 1), QTime(0, 12, 34), UTC); // No time specified QTest::newRow("RFC 850 and 1036 date only") << QString::fromLatin1("Fri Nov 01 2002") @@ -2468,7 +3072,7 @@ void tst_QDateTime::fromStringDateFormat_data() // Again, check the text in the "invalid character" tests isn't the source of invalidity: QTest::newRow("RFC 850 and 1036 (not invalid)") << QString::fromLatin1("Sun Jan 01 08:00:00 2012 +0100") - << Qt::RFC2822Date << QDateTime(QDate(2012, 1, 1), QTime(7, 0), Qt::UTC); + << Qt::RFC2822Date << QDateTime(QDate(2012, 1, 1), QTime(7, 0), UTC); QTest::newRow("RFC empty") << QString::fromLatin1("") << Qt::RFC2822Date << QDateTime(); } @@ -2488,210 +3092,274 @@ void tst_QDateTime::fromStringStringFormat_data() { QTest::addColumn<QString>("string"); QTest::addColumn<QString>("format"); + QTest::addColumn<int>("baseYear"); QTest::addColumn<QDateTime>("expected"); - const QDate defDate(1900, 1, 1); - QTest::newRow("data0") - << QString("101010") << QString("dMyy") << QDate(1910, 10, 10).startOfDay(); - QTest::newRow("data1") << QString("1020") << QString("sss") << QDateTime(); - QTest::newRow("data2") - << QString("1010") << QString("sss") << QDateTime(defDate, QTime(0, 0, 10)); - QTest::newRow("data3") << QString("10hello20") << QString("ss'hello'ss") << QDateTime(); - QTest::newRow("data4") << QString("10") << QString("''") << QDateTime(); - QTest::newRow("data5") << QString("10") << QString("'") << QDateTime(); - QTest::newRow("data6") << QString("pm") << QString("ap") << QDateTime(defDate, QTime(12, 0)); - QTest::newRow("data7") << QString("foo") << QString("ap") << QDateTime(); + // Indian/Cocos had a transition at the start of 1900, so its Jan 1st starts + // at 00:02:20 on that day; this leads to perverse results. QTBUG-77948. + if (const QDate defDate(1900, 1, 1); defDate.startOfDay().time() == QTime(0, 0)) { + QTest::newRow("dMyy-only:19") + << u"101010"_s << u"dMyy"_s << 1900 << QDate(1910, 10, 10).startOfDay(); + QTest::newRow("dMyy-only:20") + << u"101010"_s << u"dMyy"_s << 1911 << QDate(2010, 10, 10).startOfDay(); + QTest::newRow("secs-repeat-valid") + << u"1010"_s << u"sss"_s << 1900 << QDateTime(defDate, QTime(0, 0, 10)); + QTest::newRow("pm-only") + << u"pm"_s << u"ap"_s << 1900 << QDateTime(defDate, QTime(12, 0)); + QTest::newRow("date-only:19") + << u"10 Oct 10"_s << u"dd MMM yy"_s << 1900 << QDate(1910, 10, 10).startOfDay(); + QTest::newRow("date-only:20") + << u"10 Oct 10"_s << u"dd MMM yy"_s << 1950 << QDate(2010, 10, 10).startOfDay(); + QTest::newRow("dow-date-only") + << u"Fri December 3 2004"_s << u"ddd MMMM d yyyy"_s << 1900 + << QDate(2004, 12, 3).startOfDay(); + QTest::newRow("dow-mon-yr-only") + << u"Thu January 2004"_s << u"ddd MMMM yyyy"_s << 1900 + << QDate(2004, 1, 1).startOfDay(); + } + QTest::newRow("yy=24/Mar/20") // QTBUG-123579 + << u"Wed, 20 Mar 24 16:17:00"_s << u"ddd, dd MMM yy HH:mm:ss"_s << 1900 + << QDateTime(QDate(2024, 3, 20), QTime(16, 17)); + QTest::newRow("secs-conflict") << u"1020"_s << u"sss"_s << 1900 << QDateTime(); + QTest::newRow("secs-split-conflict") + << u"10hello20"_s << u"ss'hello'ss"_s << 1900 << QDateTime(); + QTest::newRow("nomatch-quote-twice") << u"10"_s << u"''"_s << 1900 << QDateTime(); + QTest::newRow("momatch-quote") << u"10"_s << u"'"_s << 1900 << QDateTime(); + QTest::newRow("nomatch-am-pm") << u"foo"_s << u"ap"_s << 1900 << QDateTime(); // Day non-conflict should not hide earlier year conflict (1963-03-01 was a // Friday; asking for Thursday moves this, without conflict, to the 7th): - QTest::newRow("data8") - << QString("77 03 1963 Thu") << QString("yy MM yyyy ddd") << QDateTime(); - QTest::newRow("data9") - << QString("101010") << QString("dMyy") << QDate(1910, 10, 10).startOfDay(); - QTest::newRow("data10") - << QString("101010") << QString("dMyy") << QDate(1910, 10, 10).startOfDay(); - QTest::newRow("data11") - << QString("10 Oct 10") << QString("dd MMM yy") << QDate(1910, 10, 10).startOfDay(); - QTest::newRow("data12") - << QString("Fri December 3 2004") << QString("ddd MMMM d yyyy") - << QDate(2004, 12, 3).startOfDay(); - QTest::newRow("data13") << QString("30.02.2004") << QString("dd.MM.yyyy") << QDateTime(); - QTest::newRow("data14") << QString("32.01.2004") << QString("dd.MM.yyyy") << QDateTime(); - QTest::newRow("data15") - << QString("Thu January 2004") << QString("ddd MMMM yyyy") - << QDate(2004, 1, 1).startOfDay(); - QTest::newRow("data16") << QString("2005-06-28T07:57:30.001Z") - << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2005, 06, 28), QTime(07, 57, 30, 1), Qt::UTC); + QTest::newRow("year-conflict") + << u"77 03 1963 Thu"_s << u"yy MM yyyy ddd"_s << 1900 << QDateTime(); + QTest::newRow("Feb-overflow") << u"30.02.2004"_s << u"dd.MM.yyyy"_s << 1900 << QDateTime(); + QTest::newRow("Jan-overflow") << u"32.01.2004"_s << u"dd.MM.yyyy"_s << 1900 << QDateTime(); + QTest::newRow("zulu-time-with-z-centisec") + << u"2005-06-28T07:57:30.01Z"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2005, 06, 28), QTime(07, 57, 30, 10), UTC); + QTest::newRow("zulu-time-with-zz-decisec") + << u"2005-06-28T07:57:30.1Z"_s << u"yyyy-MM-ddThh:mm:ss.zzt"_s << 1900 + << QDateTime(QDate(2005, 06, 28), QTime(07, 57, 30, 100), UTC); + QTest::newRow("zulu-time-with-zzz-centisec") + << u"2005-06-28T07:57:30.01Z"_s << u"yyyy-MM-ddThh:mm:ss.zzzt"_s << 1900 + << QDateTime(); // Invalid because too few digits for zzz + QTest::newRow("zulu-time-with-z-millisec") + << u"2005-06-28T07:57:30.001Z"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2005, 06, 28), QTime(07, 57, 30, 1), UTC); QTest::newRow("utc-time-spec-as:UTC+0") - << QString("2005-06-28T07:57:30.001UTC+0") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), Qt::UTC); + << u"2005-06-28T07:57:30.001UTC+0"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), UTC); QTest::newRow("utc-time-spec-as:UTC-0") - << QString("2005-06-28T07:57:30.001UTC-0") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), Qt::UTC); + << u"2005-06-28T07:57:30.001UTC-0"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), UTC); QTest::newRow("offset-from-utc:UTC+1") - << QString("2001-09-13T07:33:01.001 UTC+1") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(QDate(2001, 9, 13), QTime(7, 33, 1, 1), Qt::OffsetFromUTC, 3600); + << u"2001-09-13T07:33:01.001 UTC+1"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(QDate(2001, 9, 13), QTime(7, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(3600)); QTest::newRow("offset-from-utc:UTC-11:01") - << QString("2008-09-13T07:33:01.001 UTC-11:01") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(QDate(2008, 9, 13), QTime(7, 33, 1, 1), Qt::OffsetFromUTC, -39660); + << u"2008-09-13T07:33:01.001 UTC-11:01"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(QDate(2008, 9, 13), QTime(7, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(-39660)); QTest::newRow("offset-from-utc:UTC+02:57") - << QString("2001-09-15T09:33:01.001UTC+02:57") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), Qt::OffsetFromUTC, 10620); + << u"2001-09-15T09:33:01.001UTC+02:57"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(10620)); QTest::newRow("offset-from-utc:-03:00") // RFC 3339 offset format - << QString("2001-09-15T09:33:01.001-03:00") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), Qt::OffsetFromUTC, -10800); + << u"2001-09-15T09:33:01.001-03:00"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(-10800)); QTest::newRow("offset-from-utc:+0205") // ISO 8601 basic offset format - << QString("2001-09-15T09:33:01.001+0205") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), Qt::OffsetFromUTC, 7500); + << u"2001-09-15T09:33:01.001+0205"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(7500)); QTest::newRow("offset-from-utc:-0401") // ISO 8601 basic offset format - << QString("2001-09-15T09:33:01.001-0401") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), Qt::OffsetFromUTC, -14460); + << u"2001-09-15T09:33:01.001-0401"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(-14460)); QTest::newRow("offset-from-utc:+10") // ISO 8601 basic (hour-only) offset format - << QString("2001-09-15T09:33:01.001 +10") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), Qt::OffsetFromUTC, 36000); + << u"2001-09-15T09:33:01.001 +10"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(QDate(2001, 9, 15), QTime(9, 33, 1, 1), + QTimeZone::fromSecondsAheadOfUtc(36000)); QTest::newRow("offset-from-utc:UTC+10:00") // Time-spec specifier at the beginning - << QString("UTC+10:00 2008-10-13T07:33") << QString("t yyyy-MM-ddThh:mm") - << QDateTime(QDate(2008, 10, 13), QTime(7, 33), Qt::OffsetFromUTC, 36000); + << u"UTC+10:00 2008-10-13T07:33"_s << u"t yyyy-MM-ddThh:mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(7, 33), + QTimeZone::fromSecondsAheadOfUtc(36000)); QTest::newRow("offset-from-utc:UTC-03:30") // Time-spec specifier in the middle - << QString("2008-10-13 UTC-03:30 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, -12600); + << u"2008-10-13 UTC-03:30 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(-12600)); QTest::newRow("offset-from-utc:UTC-2") // Time-spec specifier joined with text/time - << QString("2008-10-13 UTC-2Z11.50") << QString("yyyy-MM-dd tZhh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, -7200); + << u"2008-10-13 UTC-2Z11.50"_s << u"yyyy-MM-dd tZhh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(-7200)); QTest::newRow("offset-from-utc:followed-by-colon") - << QString("2008-10-13 UTC-0100:11.50") << QString("yyyy-MM-dd t:hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, -3600); + << u"2008-10-13 UTC-0100:11.50"_s << u"yyyy-MM-dd t:hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(-3600)); QTest::newRow("offset-from-utc:late-colon") - << QString("2008-10-13 UTC+05T:11.50") << QString("yyyy-MM-dd tT:hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, 18000); + << u"2008-10-13 UTC+05T:11.50"_s << u"yyyy-MM-dd tT:hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(18000)); QTest::newRow("offset-from-utc:merged-with-time") - << QString("2008-10-13 UTC+010011.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, 3600); + << u"2008-10-13 UTC+010011.50"_s << u"yyyy-MM-dd thh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(3600)); QTest::newRow("offset-from-utc:double-colon-delimiter") - << QString("2008-10-13 UTC+12::11.50") << QString("yyyy-MM-dd t::hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, 43200); + << u"2008-10-13 UTC+12::11.50"_s << u"yyyy-MM-dd t::hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(43200)); QTest::newRow("offset-from-utc:3-digit-with-colon") - << QString("2008-10-13 -4:30 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, -16200); - QTest::newRow("offset-from-utc:merged-with-time") - << QString("2008-10-13 UTC+010011.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, 3600); + << u"2008-10-13 -4:30 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(-16200)); QTest::newRow("offset-from-utc:with-colon-merged-with-time") - << QString("2008-10-13 UTC+01:0011.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), Qt::OffsetFromUTC, 3600); + << u"2008-10-13 UTC+01:0011.50"_s << u"yyyy-MM-dd thh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + QTimeZone::fromSecondsAheadOfUtc(3600)); QTest::newRow("invalid-offset-from-utc:out-of-range") - << QString("2001-09-15T09:33:01.001-50") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(); + << u"2001-09-15T09:33:01.001-50"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:single-digit-format") - << QString("2001-09-15T09:33:01.001+5") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(); + << u"2001-09-15T09:33:01.001+5"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:three-digit-format") - << QString("2001-09-15T09:33:01.001-701") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(); + << u"2001-09-15T09:33:01.001-701"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:three-digit-minutes") - << QString("2001-09-15T09:33:01.001+11:570") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(); + << u"2001-09-15T09:33:01.001+11:570"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:single-digit-minutes") - << QString("2001-09-15T09:33:01.001+11:5") << QString("yyyy-MM-ddThh:mm:ss.zt") - << QDateTime(); + << u"2001-09-15T09:33:01.001+11:5"_s << u"yyyy-MM-ddThh:mm:ss.zt"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:invalid-sign-symbol") - << QString("2001-09-15T09:33:01.001 ~11:30") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 ~11:30"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:symbol-in-hours") - << QString("2001-09-15T09:33:01.001 UTC+o8:30") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 UTC+o8:30"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:symbol-in-minutes") - << QString("2001-09-15T09:33:01.001 UTC+08:3i") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 UTC+08:3i"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:UTC+123") // Invalid offset (UTC and 3 digit format) - << QString("2001-09-15T09:33:01.001 UTC+123") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 UTC+123"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:UTC+00005") // Invalid offset with leading zeroes - << QString("2001-09-15T09:33:01.001 UTC+00005") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 UTC+00005"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:three-digit-with-colon-delimiter") - << QString("2008-10-13 +123:11.50") << QString("yyyy-MM-dd t:hh.mm") - << QDateTime(); + << u"2008-10-13 +123:11.50"_s << u"yyyy-MM-dd t:hh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:double-colon-as-part-of-offset") - << QString("2008-10-13 UTC+12::11.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(); + << u"2008-10-13 UTC+12::11.50"_s << u"yyyy-MM-dd thh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:single-colon-as-part-of-offset") - << QString("2008-10-13 UTC+12::11.50") << QString("yyyy-MM-dd t:hh.mm") - << QDateTime(); + << u"2008-10-13 UTC+12::11.50"_s << u"yyyy-MM-dd t:hh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:starts-with-colon") - << QString("2008-10-13 UTC+:59 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(); + << u"2008-10-13 UTC+:59 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:empty-offset") - << QString("2008-10-13 UTC+ 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(); + << u"2008-10-13 UTC+ 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:time-section-instead-of-offset") - << QString("2008-10-13 UTC+11.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(); + << u"2008-10-13 UTC+11.50"_s << u"yyyy-MM-dd thh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:missing-minutes-if-colon") - << QString("2008-10-13 +05: 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(); + << u"2008-10-13 +05: 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:1-digit-minutes-if-colon") - << QString("2008-10-13 UTC+05:1 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(); + << u"2008-10-13 UTC+05:1 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-time-spec:random-symbol") - << QString("2001-09-15T09:33:01.001 $") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 $"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-time-spec:random-digit") - << QString("2001-09-15T09:33:01.001 1") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 1"_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 + << QDateTime(); QTest::newRow("invalid-offset-from-utc:merged-with-time") - << QString("2008-10-13 UTC+0111.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(); + << u"2008-10-13 UTC+0111.50"_s << u"yyyy-MM-dd thh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-offset-from-utc:with-colon-3-digit-merged-with-time") - << QString("2008-10-13 UTC+01:011.50") << QString("yyyy-MM-dd thh.mm") - << QDateTime(); + << u"2008-10-13 UTC+01:011.50"_s << u"yyyy-MM-dd thh.mm"_s << 1900 << QDateTime(); QTest::newRow("invalid-time-spec:empty") - << QString("2001-09-15T09:33:01.001 ") << QString("yyyy-MM-ddThh:mm:ss.z t") - << QDateTime(); + << u"2001-09-15T09:33:01.001 "_s << u"yyyy-MM-ddThh:mm:ss.z t"_s << 1900 << QDateTime(); #if QT_CONFIG(timezone) QTimeZone southBrazil("America/Sao_Paulo"); if (southBrazil.isValid()) { QTest::newRow("spring-forward-midnight") - << QString("2008-10-19 23:45.678 America/Sao_Paulo") << QString("yyyy-MM-dd mm:ss.zzz t") - // That's in the hour skipped - expect the matching time after the spring-forward, in DST: - << QDateTime(QDate(2008, 10, 19), QTime(1, 23, 45, 678), southBrazil); + // NB: no hour field, so hour takes its default, 0, so that + // default can be over-ridden: + << u"2008-10-19 23:45.678 America/Sao_Paulo"_s << u"yyyy-MM-dd mm:ss.zzz t"_s << 1900 + // That's in the hour skipped - expect the matching time after + // the spring-forward, in DST: + << QDateTime(QDate(2008, 10, 19), QTime(1, 23, 45, 678), southBrazil); + } + + QTimeZone berlintz("Europe/Berlin"); + if (berlintz.isValid()) { + QTest::newRow("begin-of-high-summer-time-with-tz") + << u"1947-05-11 03:23:45.678 Europe/Berlin"_s << u"yyyy-MM-dd hh:mm:ss.zzz t"_s + // That's in the hour skipped - expecting an invalid DateTime + << 1900 << QDateTime(QDate(1947, 5, 11), QTime(3, 23, 45, 678), berlintz); } #endif - QTest::newRow("late") << QString("9999-12-31T23:59:59.999Z") - << QString("yyyy-MM-ddThh:mm:ss.zZ") - << QDateTime(QDate(9999, 12, 31), QTime(23, 59, 59, 999)); + QTest::newRow("late") + << u"9999-12-31T23:59:59.999Z"_s << u"yyyy-MM-ddThh:mm:ss.zZ"_s << 1900 + << QDateTime(QDate(9999, 12, 31), QTime(23, 59, 59, 999)); // Separators match /([^aAdhHMmstyz]*)/ QTest::newRow("oddly-separated") // To show broken-separator's format is valid. - << QStringLiteral("2018 wilful long working block relief 12-19T21:09 cruel blurb encore flux") - << QStringLiteral("yyyy wilful long working block relief MM-ddThh:mm cruel blurb encore flux") - << QDateTime(QDate(2018, 12, 19), QTime(21, 9)); + << u"2018 wilful long working block relief 12-19T21:09 cruel blurb encore flux"_s + << u"yyyy wilful long working block relief MM-ddThh:mm cruel blurb encore flux"_s + << 1900 << QDateTime(QDate(2018, 12, 19), QTime(21, 9)); QTest::newRow("broken-separator") - << QStringLiteral("2018 wilful") - << QStringLiteral("yyyy wilful long working block relief MM-ddThh:mm cruel blurb encore flux") - << QDateTime(); + << u"2018 wilful"_s + << u"yyyy wilful long working block relief MM-ddThh:mm cruel blurb encore flux"_s + << 1900 << QDateTime(); QTest::newRow("broken-terminator") - << QStringLiteral("2018 wilful long working block relief 12-19T21:09 cruel") - << QStringLiteral("yyyy wilful long working block relief MM-ddThh:mm cruel blurb encore flux") - << QDateTime(); + << u"2018 wilful long working block relief 12-19T21:09 cruel"_s + << u"yyyy wilful long working block relief MM-ddThh:mm cruel blurb encore flux"_s + << 1900 << QDateTime(); + + // test unicode + QTest::newRow("unicode handling") + << QString(u8"2005🤣06🤣28T07🤣57🤣30.001Z") + << QString(u8"yyyy🤣MM🤣ddThh🤣mm🤣ss.zt") << 1900 + << QDateTime(QDate(2005, 6, 28), QTime(7, 57, 30, 1), UTC); + + // Two tests derived from malformed ASN.1 strings (QTBUG-84349): + QTest::newRow("curft+ASN.1:UTC") + << u"22+221102233Z"_s << u"yyMMddHHmmsst"_s << 1900 << QDateTime(); + QTest::newRow("curft+ASN.1:Generalized") + << u"9922+221102233Z"_s << u"yyyyMMddHHmmsst"_s << 1900 << QDateTime(); + // Verify baseYear needed by plain ASN.1 works: + QTest::newRow("ASN.1:UTC-start") + << u"500101000000Z"_s << u"yyMMddHHmmsst"_s << 1950 + << QDate(1950, 1, 1).startOfDay(QTimeZone::UTC); + QTest::newRow("ASN.1:UTC-end") + << u"491231235959Z"_s << u"yyMMddHHmmsst"_s << 1950 + << QDate(2049, 12, 31).endOfDay(QTimeZone::UTC).addMSecs(-999); + + // fuzzer test + QTest::newRow("integer overflow found by fuzzer") + << u"EEE1200000MUB"_s << u"t"_s << 1900 << QDateTime(); + + // Rich time-zone specifiers (QTBUG-95966): + const auto east3hours = QTimeZone::fromSecondsAheadOfUtc(10800); + QTest::newRow("timezone-tt-with-offset:+0300") + << u"2008-10-13 +0300 11.50"_s << u"yyyy-MM-dd tt hh.mm"_s + << 1900 << QDateTime(QDate(2008, 10, 13), QTime(11, 50), east3hours); + QTest::newRow("timezone-ttt-with-offset:+03:00") + << u"2008-10-13 +03:00 11.50"_s << u"yyyy-MM-dd ttt hh.mm"_s + << 1900 << QDateTime(QDate(2008, 10, 13), QTime(11, 50), east3hours); + QTest::newRow("timezone-tttt-with-offset:+03:00") + << u"2008-10-13 +03:00 11.50"_s << u"yyyy-MM-dd tttt hh.mm"_s + << 1900 << QDateTime(); // Offset not valid when zone name expected. } void tst_QDateTime::fromStringStringFormat() { QFETCH(QString, string); QFETCH(QString, format); + QFETCH(int, baseYear); QFETCH(QDateTime, expected); - QDateTime dt = QDateTime::fromString(string, format); + QDateTime dt = QDateTime::fromString(string, format, baseYear); QCOMPARE(dt, expected); if (expected.isValid()) { QCOMPARE(dt.timeSpec(), expected.timeSpec()); -#if QT_CONFIG(timezone) - if (expected.timeSpec() == Qt::TimeZone) - QCOMPARE(dt.timeZone(), expected.timeZone()); -#endif - // OffsetFromUTC needs an offset check - we may as well do it for all: - QCOMPARE(dt.offsetFromUtc(), expected.offsetFromUtc()); + QCOMPARE(dt.timeRepresentation(), dt.timeRepresentation()); + } else { + QCOMPARE(dt.isValid(), expected.isValid()); + QCOMPARE(dt.toMSecsSinceEpoch(), expected.toMSecsSinceEpoch()); } } @@ -2700,27 +3368,73 @@ void tst_QDateTime::fromStringStringFormat_localTimeZone_data() QTest::addColumn<QByteArray>("localTimeZone"); QTest::addColumn<QString>("string"); QTest::addColumn<QString>("format"); + QTest::addColumn<int>("baseYear"); QTest::addColumn<QDateTime>("expected"); #if QT_CONFIG(timezone) + bool lacksRows = true; + // Note that the localTimeZone needn't match the zone used in the string and + // expected date-time; indeed, having them different is probably best. + // Both zones need to be valid; GMT always is, so is a safe one to use for + // whichever the test-case doesn't care about (if that applies to either). QTimeZone etcGmtWithOffset("Etc/GMT+3"); if (etcGmtWithOffset.isValid()) { - QTest::newRow("local-timezone-with-offset:Etc/GMT+3") << QByteArrayLiteral("GMT") - << QString("2008-10-13 Etc/GMT+3 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), etcGmtWithOffset); + lacksRows = false; + QTest::newRow("local-timezone-t-with-zone:Etc/GMT+3") + << "GMT"_ba << u"2008-10-13 Etc/GMT+3 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), etcGmtWithOffset); + QTest::newRow("local-timezone-tttt-with-zone:Etc/GMT+3") + << "GMT"_ba << u"2008-10-13 Etc/GMT+3 11.50"_s << u"yyyy-MM-dd tttt hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), etcGmtWithOffset); } + QTest::newRow("local-timezone-tt-with-zone:Etc/GMT+3") + << "GMT"_ba << u"2008-10-13 Etc/GMT+3 11.50"_s << u"yyyy-MM-dd tt hh.mm"_s << 1900 + << QDateTime(); // Zone name not valid when offset expected + QTest::newRow("local-timezone-ttt-with-zone:Etc/GMT+3") + << "GMT"_ba << u"2008-10-13 Etc/GMT+3 11.50"_s << u"yyyy-MM-dd ttt hh.mm"_s << 1900 + << QDateTime(); // Zone name not valid when offset expected QTimeZone gmtWithOffset("GMT-2"); if (gmtWithOffset.isValid()) { - QTest::newRow("local-timezone-with-offset:GMT-2") << QByteArrayLiteral("GMT") - << QString("2008-10-13 GMT-2 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), gmtWithOffset); + lacksRows = false; + QTest::newRow("local-timezone-with-offset:GMT-2") + << "GMT"_ba << u"2008-10-13 GMT-2 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), gmtWithOffset); } QTimeZone gmt("GMT"); if (gmt.isValid()) { - QTest::newRow("local-timezone-with-offset:GMT") << QByteArrayLiteral("GMT") - << QString("2008-10-13 GMT 11.50") << QString("yyyy-MM-dd t hh.mm") - << QDateTime(QDate(2008, 10, 13), QTime(11, 50), gmt); + lacksRows = false; + const bool fullyLocal = ([]() { + TimeZoneRollback useZone("GMT"); + return qTzName(0) == u"GMT"_s; + })(); + QTest::newRow("local-timezone-with-offset:GMT") + << "GMT"_ba << u"2008-10-13 GMT 11.50"_s << u"yyyy-MM-dd t hh.mm"_s << 1900 + << QDateTime(QDate(2008, 10, 13), QTime(11, 50), + fullyLocal ? QTimeZone(QTimeZone::LocalTime) : gmt); } + QTimeZone helsinki("Europe/Helsinki"); + if (helsinki.isValid()) { + lacksRows = false; + // QTBUG-96861: QAsn1Element::toDateTime() tripped over an assert due to + // the first 20m 11s of 1921-05-01 being skipped, so the parser's + // attempt to construct a local time after scanning yyMM tripped up on + // the start of the day, when the zone backend lacked transition data. + // (Because QDTP tries to use local time until it reads the final zone + // field, constructing a new QDT after reading each field, hence + // transiently wanting 1921-05-01 00:00:00 before reading the dd field.) + QTest::newRow("Helsinki-joins-EET:19") + << "Europe/Helsinki"_ba << u"210506000000Z"_s << u"yyMMddHHmmsst"_s << 1900 + << QDateTime(QDate(1921, 5, 6), QTime(0, 0), UTC); + // Strictly, ASN.1 wants us to parse that with a different baseYear, so + // check that, too, but tweak to match the 1921 transition's mid-point: + QTest::newRow("Helsinki-joins-EET:20") + << "Europe/Helsinki"_ba << u"210501001006Z"_s << u"yyMMddHHmmsst"_s << 1950 + << QDateTime(QDate(2021, 5, 1), QTime(0, 10, 6), UTC); + } + if (lacksRows) + QSKIP("Testcases all use zones unsupported on this platform"); +#else + QSKIP("Test only possible with timezone support enabled"); #endif } @@ -2739,29 +3453,31 @@ void tst_QDateTime::offsetFromUtc() QCOMPARE(QDateTime().offsetFromUtc(), 0); // Offset constructor - QDateTime dt1(QDate(2013, 1, 1), QTime(1, 0), Qt::OffsetFromUTC, 60 * 60); + QDateTime dt1(QDate(2013, 1, 1), QTime(1, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); QCOMPARE(dt1.offsetFromUtc(), 60 * 60); + QVERIFY(dt1.timeRepresentation().isValid()); #if QT_CONFIG(timezone) QVERIFY(dt1.timeZone().isValid()); #endif - dt1 = QDateTime(QDate(2013, 1, 1), QTime(1, 0), Qt::OffsetFromUTC, -60 * 60); + dt1 = QDateTime(QDate(2013, 1, 1), QTime(1, 0), QTimeZone::fromSecondsAheadOfUtc(-60 * 60)); QCOMPARE(dt1.offsetFromUtc(), -60 * 60); // UTC should be 0 offset - QDateTime dt2(QDate(2013, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime dt2(QDate(2013, 1, 1), QTime(0, 0), UTC); QCOMPARE(dt2.offsetFromUtc(), 0); // LocalTime should vary if (zoneIsCET) { // Time definitely in Standard Time so 1 hour ahead - QDateTime dt3(QDate(2013, 1, 1), QTime(0, 0), Qt::LocalTime); + QDateTime dt3 = QDate(2013, 1, 1).startOfDay(); QCOMPARE(dt3.offsetFromUtc(), 1 * 60 * 60); // Time definitely in Daylight Time so 2 hours ahead - QDateTime dt4(QDate(2013, 6, 1), QTime(0, 0), Qt::LocalTime); + QDateTime dt4 = QDate(2013, 6, 1).startOfDay(); QCOMPARE(dt4.offsetFromUtc(), 2 * 60 * 60); - } else { - QSKIP("You must test using Central European (CET/CEST) time zone, e.g. TZ=Europe/Oslo"); - } + } else { + qDebug("Skipped some tests specific to Central European Time " + "(CET/CEST), e.g. TZ=Europe/Oslo"); + } #if QT_CONFIG(timezone) QDateTime dt5(QDate(2013, 1, 1), QTime(0, 0), QTimeZone("Pacific/Auckland")); @@ -2772,6 +3488,9 @@ void tst_QDateTime::offsetFromUtc() #endif } +#if QT_DEPRECATED_SINCE(6, 9) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED void tst_QDateTime::setOffsetFromUtc() { /* Basic tests. */ @@ -2847,7 +3566,7 @@ void tst_QDateTime::setOffsetFromUtc() void tst_QDateTime::toOffsetFromUtc() { - QDateTime dt1(QDate(2013, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime dt1(QDate(2013, 1, 1), QTime(0, 0), QTimeZone::UTC); QDateTime dt2 = dt1.toOffsetFromUtc(60 * 60); QCOMPARE(dt2, dt1); @@ -2867,6 +3586,8 @@ void tst_QDateTime::toOffsetFromUtc() QCOMPARE(dt2.date(), QDate(2013, 1, 1)); QCOMPARE(dt2.time(), QTime(0, 0)); } +QT_WARNING_POP +#endif // 6.9 deprecation void tst_QDateTime::zoneAtTime_data() { @@ -2886,15 +3607,15 @@ void tst_QDateTime::zoneAtTime_data() ADDROW("epoch:EST", "America/New_York", epoch, -5 * 3600); } { - // QDateTime deliberately ignores DST before the epoch. + // QDateTime now takes account of DST even before the epoch. QDate summer69(1969, 8, 15); // Woodstock started ADDROW("summer69:UTC", "UTC", summer69, 0); - ADDROW("summer69:CET", "Europe/Rome", summer69, 3600); - ADDROW("summer69:PST", "America/Vancouver", summer69, -8 * 3600); - ADDROW("summer69:EST", "America/New_York", summer69, -5 * 3600); + ADDROW("summer69:CET", "Europe/Rome", summer69, 2 * 3600); + ADDROW("summer69:PST", "America/Vancouver", summer69, -7 * 3600); + ADDROW("summer69:EST", "America/New_York", summer69, -4 * 3600); } { - // ... but takes it into account after: + // ... and has always taken it into account since: QDate summer70(1970, 8, 26); // Isle of Wight festival ADDROW("summer70:UTC", "UTC", summer70, 0); ADDROW("summer70:CET", "Europe/Rome", summer70, 2 * 3600); @@ -2934,10 +3655,7 @@ void tst_QDateTime::zoneAtTime() QTimeZone zone(ianaID); QVERIFY(zone.isValid()); QCOMPARE(QDateTime(date, noon, zone).offsetFromUtc(), offset); - if (date.year() < 1970) - QCOMPARE(zone.standardTimeOffset(QDateTime(date, noon, zone)), offset); - else // zone.offsetFromUtc *does* include DST, even before epoch - QCOMPARE(zone.offsetFromUtc(QDateTime(date, noon, zone)), offset); + QCOMPARE(zone.offsetFromUtc(QDateTime(date, noon, zone)), offset); #else QSKIP("Needs timezone feature enabled"); #endif @@ -2945,28 +3663,46 @@ void tst_QDateTime::zoneAtTime() void tst_QDateTime::timeZoneAbbreviation() { - QDateTime dt1(QDate(2013, 1, 1), QTime(1, 0), Qt::OffsetFromUTC, 60 * 60); + QDateTime dt1(QDate(2013, 1, 1), QTime(1, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); QCOMPARE(dt1.timeZoneAbbreviation(), QString("UTC+01:00")); - QDateTime dt2(QDate(2013, 1, 1), QTime(1, 0), Qt::OffsetFromUTC, -60 * 60); + QDateTime dt2(QDate(2013, 1, 1), QTime(1, 0), QTimeZone::fromSecondsAheadOfUtc(-60 * 60)); QCOMPARE(dt2.timeZoneAbbreviation(), QString("UTC-01:00")); - QDateTime dt3(QDate(2013, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime dt3(QDate(2013, 1, 1), QTime(0, 0), UTC); QCOMPARE(dt3.timeZoneAbbreviation(), QString("UTC")); // LocalTime should vary if (zoneIsCET) { // Time definitely in Standard Time - QDateTime dt4(QDate(2013, 1, 1), QTime(0, 0), Qt::LocalTime); + QDateTime dt4 = QDate(2013, 1, 1).startOfDay(); + /* Note that MET is functionally an alias for CET (their zoneinfo files + differ only in the first letter of the abbreviations), unlike the + various zones that give CET as their abbreviation. + */ + { + const auto abbrev = dt4.timeZoneAbbreviation(); + auto reporter = qScopeGuard([abbrev]() { + qDebug() << "Unexpected abbreviation" << abbrev; + }); #ifdef Q_OS_WIN - QEXPECT_FAIL("", "Windows only reports long name (QTBUG-32759)", Continue); + QEXPECT_FAIL("", "Windows only reports long name (QTBUG-32759)", Continue); #endif - QCOMPARE(dt4.timeZoneAbbreviation(), QStringLiteral("CET")); + QVERIFY(abbrev == u"CET"_s || abbrev == u"MET"_s); + reporter.dismiss(); + } // Time definitely in Daylight Time - QDateTime dt5(QDate(2013, 6, 1), QTime(0, 0), Qt::LocalTime); + QDateTime dt5 = QDate(2013, 6, 1).startOfDay(); + { + const auto abbrev = dt5.timeZoneAbbreviation(); + auto reporter = qScopeGuard([abbrev]() { + qDebug() << "Unexpected abbreviation" << abbrev; + }); #ifdef Q_OS_WIN - QEXPECT_FAIL("", "Windows only reports long name (QTBUG-32759)", Continue); + QEXPECT_FAIL("", "Windows only reports long name (QTBUG-32759)", Continue); #endif - QCOMPARE(dt5.timeZoneAbbreviation(), QStringLiteral("CEST")); + QVERIFY(abbrev == u"CEST"_s || abbrev == u"MEST"_s); + reporter.dismiss(); + } } else { qDebug("(Skipped some CET-only tests)"); } @@ -3059,8 +3795,8 @@ void tst_QDateTime::utcOffsetLessThan() const QDateTime dt1(QDate(2002, 10, 10), QTime(0, 0)); QDateTime dt2(dt1); - dt1.setOffsetFromUtc(-(2 * 60 * 60)); // Minus two hours. - dt2.setOffsetFromUtc(-(3 * 60 * 60)); // Minus three hours. + dt1.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-(2 * 60 * 60))); // Minus two hours. + dt2.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-(3 * 60 * 60))); // Minus three hours. QVERIFY(dt1 != dt2); QVERIFY(!(dt1 == dt2)); @@ -3070,14 +3806,14 @@ void tst_QDateTime::utcOffsetLessThan() const void tst_QDateTime::isDaylightTime() const { - QDateTime utc1(QDate(2012, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime utc1(QDate(2012, 1, 1), QTime(0, 0), UTC); QVERIFY(!utc1.isDaylightTime()); - QDateTime utc2(QDate(2012, 6, 1), QTime(0, 0), Qt::UTC); + QDateTime utc2(QDate(2012, 6, 1), QTime(0, 0), UTC); QVERIFY(!utc2.isDaylightTime()); - QDateTime offset1(QDate(2012, 1, 1), QTime(0, 0), Qt::OffsetFromUTC, 1 * 60 * 60); + QDateTime offset1(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); QVERIFY(!offset1.isDaylightTime()); - QDateTime offset2(QDate(2012, 6, 1), QTime(0, 0), Qt::OffsetFromUTC, 1 * 60 * 60); + QDateTime offset2(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::fromSecondsAheadOfUtc(60 * 60)); QVERIFY(!offset2.isDaylightTime()); if (zoneIsCET) { @@ -3086,379 +3822,427 @@ void tst_QDateTime::isDaylightTime() const QDateTime cet2(QDate(2012, 6, 1), QTime(0, 0)); QVERIFY(cet2.isDaylightTime()); } else { - QSKIP("You must test using Central European (CET/CEST) time zone, e.g. TZ=Europe/Oslo"); + qDebug("Skipped some tests specific to Central European Time " + "(CET/CEST), e.g. TZ=Europe/Oslo"); } } void tst_QDateTime::daylightTransitions() const { - if (zoneIsCET) { - // CET transitions occur at 01:00:00 UTC on last Sunday in March and October - // 2011-03-27 02:00:00 CET became 03:00:00 CEST at msecs = 1301187600000 - // 2011-10-30 03:00:00 CEST became 02:00:00 CET at msecs = 1319936400000 - // 2012-03-25 02:00:00 CET became 03:00:00 CEST at msecs = 1332637200000 - // 2012-10-28 03:00:00 CEST became 02:00:00 CET at msecs = 1351386000000 - const qint64 daylight2012 = 1332637200000; - const qint64 standard2012 = 1351386000000; - const qint64 msecsOneHour = 3600000; - - // Test for correct behviour for StandardTime -> DaylightTime transition, i.e. missing hour - - // Test setting date, time in missing hour will be invalid - - QDateTime before(QDate(2012, 3, 25), QTime(1, 59, 59, 999)); - QVERIFY(before.isValid()); - QCOMPARE(before.date(), QDate(2012, 3, 25)); - QCOMPARE(before.time(), QTime(1, 59, 59, 999)); - QCOMPARE(before.toMSecsSinceEpoch(), daylight2012 - 1); - - QDateTime missing(QDate(2012, 3, 25), QTime(2, 0)); - QVERIFY(!missing.isValid()); - QCOMPARE(missing.date(), QDate(2012, 3, 25)); - QCOMPARE(missing.time(), QTime(2, 0)); - - QDateTime after(QDate(2012, 3, 25), QTime(3, 0)); - QVERIFY(after.isValid()); - QCOMPARE(after.date(), QDate(2012, 3, 25)); - QCOMPARE(after.time(), QTime(3, 0)); - QCOMPARE(after.toMSecsSinceEpoch(), daylight2012); - - // Test round-tripping of msecs - - before.setMSecsSinceEpoch(daylight2012 - 1); - QVERIFY(before.isValid()); - QCOMPARE(before.date(), QDate(2012, 3, 25)); - QCOMPARE(before.time(), QTime(1, 59, 59, 999)); - QCOMPARE(before.toMSecsSinceEpoch(), daylight2012 -1); - - after.setMSecsSinceEpoch(daylight2012); - QVERIFY(after.isValid()); - QCOMPARE(after.date(), QDate(2012, 3, 25)); - QCOMPARE(after.time(), QTime(3, 0)); - QCOMPARE(after.toMSecsSinceEpoch(), daylight2012); - - // Test changing time spec re-validates the date/time - - QDateTime utc(QDate(2012, 3, 25), QTime(2, 00, 0), Qt::UTC); - QVERIFY(utc.isValid()); - QCOMPARE(utc.date(), QDate(2012, 3, 25)); - QCOMPARE(utc.time(), QTime(2, 0)); - utc.setTimeSpec(Qt::LocalTime); - QVERIFY(!utc.isValid()); - QCOMPARE(utc.date(), QDate(2012, 3, 25)); - QCOMPARE(utc.time(), QTime(2, 0)); - utc.setTimeSpec(Qt::UTC); - QVERIFY(utc.isValid()); - QCOMPARE(utc.date(), QDate(2012, 3, 25)); - QCOMPARE(utc.time(), QTime(2, 0)); - - // Test date maths, if result falls in missing hour then becomes next - // hour (or is always invalid; mktime() may reject gap-times). - - QDateTime test(QDate(2011, 3, 25), QTime(2, 0)); - QVERIFY(test.isValid()); - test = test.addYears(1); - const bool handled = test.isValid(); -#define CHECK_SPRING_FORWARD(test) \ - if (test.isValid()) { \ - QCOMPARE(test.date(), QDate(2012, 3, 25)); \ - QCOMPARE(test.time(), QTime(3, 0)); \ - } else { \ - QVERIFY(!handled); \ - } - CHECK_SPRING_FORWARD(test); - - test = QDateTime(QDate(2012, 2, 25), QTime(2, 0)); - QVERIFY(test.isValid()); - test = test.addMonths(1); - CHECK_SPRING_FORWARD(test); - - test = QDateTime(QDate(2012, 3, 24), QTime(2, 0)); - QVERIFY(test.isValid()); - test = test.addDays(1); - CHECK_SPRING_FORWARD(test); - - test = QDateTime(QDate(2012, 3, 25), QTime(1, 0)); - QVERIFY(test.isValid()); - QCOMPARE(test.toMSecsSinceEpoch(), daylight2012 - msecsOneHour); - test = test.addMSecs(msecsOneHour); - CHECK_SPRING_FORWARD(test); - if (handled) - QCOMPARE(test.toMSecsSinceEpoch(), daylight2012); -#undef CHECK_SPRING_FORWARD - - // Test for correct behviour for DaylightTime -> StandardTime transition, i.e. second occurrence - - // Test setting date and time in first and second occurrence will be valid - - // 1 hour before transition is 2:00:00 FirstOccurrence - QDateTime hourBefore(QDate(2012, 10, 28), QTime(2, 0)); - QVERIFY(hourBefore.isValid()); - QCOMPARE(hourBefore.date(), QDate(2012, 10, 28)); - QCOMPARE(hourBefore.time(), QTime(2, 0)); -#ifdef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(hourBefore.toMSecsSinceEpoch(), standard2012 - msecsOneHour); - - // 1 msec before transition is 2:59:59.999 FirstOccurrence - QDateTime msecBefore(QDate(2012, 10, 28), QTime(2, 59, 59, 999)); - QVERIFY(msecBefore.isValid()); - QCOMPARE(msecBefore.date(), QDate(2012, 10, 28)); - QCOMPARE(msecBefore.time(), QTime(2, 59, 59, 999)); -#if defined(Q_OS_DARWIN) || defined(Q_OS_WIN) || defined(Q_OS_QNX) || defined(Q_OS_ANDROID) - // Win and Mac uses SecondOccurrence here - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_MAC - QCOMPARE(msecBefore.toMSecsSinceEpoch(), standard2012 - 1); - - // At transition is 2:00:00 SecondOccurrence - QDateTime atTran(QDate(2012, 10, 28), QTime(2, 0)); - QVERIFY(atTran.isValid()); - QCOMPARE(atTran.date(), QDate(2012, 10, 28)); - QCOMPARE(atTran.time(), QTime(2, 0)); -#ifndef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(atTran.toMSecsSinceEpoch(), standard2012); - - // 59:59.999 after transition is 2:59:59.999 SecondOccurrence - QDateTime afterTran(QDate(2012, 10, 28), QTime(2, 59, 59, 999)); - QVERIFY(afterTran.isValid()); - QCOMPARE(afterTran.date(), QDate(2012, 10, 28)); - QCOMPARE(afterTran.time(), QTime(2, 59, 59, 999)); -#ifdef __GLIBCXX__ - // Linux (i.e. glibc) mktime bug reuses last calculation - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_UNIX - QCOMPARE(afterTran.toMSecsSinceEpoch(), standard2012 + msecsOneHour - 1); - - // 1 hour after transition is 3:00:00 FirstOccurrence - QDateTime hourAfter(QDate(2012, 10, 28), QTime(3, 0)); - QVERIFY(hourAfter.isValid()); - QCOMPARE(hourAfter.date(), QDate(2012, 10, 28)); - QCOMPARE(hourAfter.time(), QTime(3, 0)); - QCOMPARE(hourAfter.toMSecsSinceEpoch(), standard2012 + msecsOneHour); - - // Test round-tripping of msecs - - // 1 hour before transition is 2:00:00 FirstOccurrence - hourBefore.setMSecsSinceEpoch(standard2012 - msecsOneHour); - QVERIFY(hourBefore.isValid()); - QCOMPARE(hourBefore.date(), QDate(2012, 10, 28)); - QCOMPARE(hourBefore.time(), QTime(2, 0)); - QCOMPARE(hourBefore.toMSecsSinceEpoch(), standard2012 - msecsOneHour); - - // 1 msec before transition is 2:59:59.999 FirstOccurrence - msecBefore.setMSecsSinceEpoch(standard2012 - 1); - QVERIFY(msecBefore.isValid()); - QCOMPARE(msecBefore.date(), QDate(2012, 10, 28)); - QCOMPARE(msecBefore.time(), QTime(2, 59, 59, 999)); - QCOMPARE(msecBefore.toMSecsSinceEpoch(), standard2012 - 1); - - // At transition is 2:00:00 SecondOccurrence - atTran.setMSecsSinceEpoch(standard2012); - QVERIFY(atTran.isValid()); - QCOMPARE(atTran.date(), QDate(2012, 10, 28)); - QCOMPARE(atTran.time(), QTime(2, 0)); - QCOMPARE(atTran.toMSecsSinceEpoch(), standard2012); - - // 59:59.999 after transition is 2:59:59.999 SecondOccurrence - afterTran.setMSecsSinceEpoch(standard2012 + msecsOneHour - 1); - QVERIFY(afterTran.isValid()); - QCOMPARE(afterTran.date(), QDate(2012, 10, 28)); - QCOMPARE(afterTran.time(), QTime(2, 59, 59, 999)); - QCOMPARE(afterTran.toMSecsSinceEpoch(), standard2012 + msecsOneHour - 1); - - // 1 hour after transition is 3:00:00 FirstOccurrence - hourAfter.setMSecsSinceEpoch(standard2012 + msecsOneHour); - QVERIFY(hourAfter.isValid()); - QCOMPARE(hourAfter.date(), QDate(2012, 10, 28)); - QCOMPARE(hourAfter.time(), QTime(3, 0)); - QCOMPARE(hourAfter.toMSecsSinceEpoch(), standard2012 + msecsOneHour); - - // Test date maths, result is always FirstOccurrence - - // Add year to get to tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 28), QTime(2, 0)); - test = test.addYears(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(2, 0)); -#ifdef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 - msecsOneHour); - - // Add year to get to after tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 28), QTime(3, 0)); - test = test.addYears(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(3, 0)); - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 + msecsOneHour); - - // Add year to tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(2, 0)); - test = test.addYears(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 30)); - QCOMPARE(test.time(), QTime(2, 0)); - - // Add year to tran SecondOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(2, 0)); // TODO SecondOccurrence - test = test.addYears(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 30)); - QCOMPARE(test.time(), QTime(2, 0)); - - // Add year to after tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)); - test = test.addYears(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 30)); - QCOMPARE(test.time(), QTime(3, 0)); - - - // Add month to get to tran FirstOccurrence - test = QDateTime(QDate(2012, 9, 28), QTime(2, 0)); - test = test.addMonths(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(2, 0)); -#ifdef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 - msecsOneHour); - - // Add month to get to after tran FirstOccurrence - test = QDateTime(QDate(2012, 9, 28), QTime(3, 0)); - test = test.addMonths(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(3, 0)); - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 + msecsOneHour); - - // Add month to tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(2, 0)); - test = test.addMonths(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2011, 11, 30)); - QCOMPARE(test.time(), QTime(2, 0)); - - // Add month to tran SecondOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(2, 0)); // TODO SecondOccurrence - test = test.addMonths(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2011, 11, 30)); - QCOMPARE(test.time(), QTime(2, 0)); - - // Add month to after tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)); - test = test.addMonths(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2011, 11, 30)); - QCOMPARE(test.time(), QTime(3, 0)); - - - // Add day to get to tran FirstOccurrence - test = QDateTime(QDate(2012, 10, 27), QTime(2, 0)); - test = test.addDays(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(2, 0)); -#ifdef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 - msecsOneHour); - - // Add day to get to after tran FirstOccurrence - test = QDateTime(QDate(2012, 10, 27), QTime(3, 0)); - test = test.addDays(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(3, 0)); - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 + msecsOneHour); - - // Add day to tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(2, 0)); - test = test.addDays(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2011, 10, 31)); - QCOMPARE(test.time(), QTime(2, 0)); - - // Add day to tran SecondOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(2, 0)); // TODO SecondOccurrence - test = test.addDays(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2011, 10, 31)); - QCOMPARE(test.time(), QTime(2, 0)); - - // Add day to after tran FirstOccurrence - test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)); - test = test.addDays(1); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2011, 10, 31)); - QCOMPARE(test.time(), QTime(3, 0)); - - - // Add hour to get to tran FirstOccurrence - test = QDateTime(QDate(2012, 10, 28), QTime(1, 0)); - test = test.addMSecs(msecsOneHour); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); - QCOMPARE(test.time(), QTime(2, 0)); - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 - msecsOneHour); - - // Add hour to tran FirstOccurrence to get to tran SecondOccurrence - test = QDateTime(QDate(2012, 10, 28), QTime(2, 0)); - test = test.addMSecs(msecsOneHour); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); -#ifdef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.time(), QTime(2, 0)); -#ifdef Q_OS_WIN - // Windows uses SecondOccurrence - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.toMSecsSinceEpoch(), standard2012); - - // Add hour to tran SecondOccurrence to get to after tran FirstOccurrence - test = QDateTime(QDate(2012, 10, 28), QTime(2, 0)); // TODO SecondOccurrence - test = test.addMSecs(msecsOneHour); - QVERIFY(test.isValid()); - QCOMPARE(test.date(), QDate(2012, 10, 28)); -#if defined(Q_OS_DARWIN) || defined(Q_OS_QNX) || defined(Q_OS_ANDROID) - // Mac uses FirstOccurrence, Windows uses SecondOccurrence, Linux uses last calculation - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.time(), QTime(3, 0)); -#if defined(Q_OS_DARWIN) || defined(Q_OS_QNX) || defined(Q_OS_ANDROID) - // Mac uses FirstOccurrence, Windows uses SecondOccurrence, Linux uses last calculation - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); -#endif // Q_OS_WIN - QCOMPARE(test.toMSecsSinceEpoch(), standard2012 + msecsOneHour); - - } else { + if (!zoneIsCET) QSKIP("You must test using Central European (CET/CEST) time zone, e.g. TZ=Europe/Oslo"); + + // CET transitions occur at 01:00:00 UTC on last Sunday in March and October + // 2011-03-27 02:00:00 CET became 03:00:00 CEST at msecs = 1301187600000 + // 2011-10-30 03:00:00 CEST became 02:00:00 CET at msecs = 1319936400000 + // 2012-03-25 02:00:00 CET became 03:00:00 CEST at msecs = 1332637200000 + // 2012-10-28 03:00:00 CEST became 02:00:00 CET at msecs = 1351386000000 + QCOMPARE(QDate(2012, 3, 25).dayOfWeek(), 7); + QCOMPARE(QDate(2012, 10, 28).dayOfWeek(), 7); + const qint64 spring2012 = 1332637200000; + const qint64 autumn2012 = 1351386000000; + const qint64 msecsOneHour = 3600000; + QCOMPARE(spring2012, QDateTime(QDate(2012, 3, 25), QTime(1, 0), UTC).toMSecsSinceEpoch()); + QCOMPARE(autumn2012, QDateTime(QDate(2012, 10, 28), QTime(1, 0), UTC).toMSecsSinceEpoch()); + + // Test for correct behviour for StandardTime -> DaylightTime transition, i.e. missing hour + + // Test setting date, time in missing hour will be invalid + + QDateTime before(QDate(2012, 3, 25), QTime(1, 59, 59, 999)); + QVERIFY(before.isValid()); + QVERIFY(!before.isDaylightTime()); + QCOMPARE(before.date(), QDate(2012, 3, 25)); + QCOMPARE(before.time(), QTime(1, 59, 59, 999)); + QCOMPARE(before.toMSecsSinceEpoch(), spring2012 - 1); + + QDateTime entering(QDate(2012, 3, 25), QTime(2, 0), + QDateTime::TransitionResolution::PreferBefore); + QVERIFY(entering.isValid()); + QVERIFY(!entering.isDaylightTime()); + QCOMPARE(entering.date(), QDate(2012, 3, 25)); + QCOMPARE(entering.time(), QTime(1, 0)); + // QDateTimeParser relies on toMSecsSinceEpoch() to still work: + QCOMPARE(entering.toMSecsSinceEpoch(), spring2012 - msecsOneHour); + + QDateTime leaving(QDate(2012, 3, 25), QTime(2, 0), + QDateTime::TransitionResolution::PreferAfter); + QVERIFY(leaving.isValid()); + QVERIFY(leaving.isDaylightTime()); + QCOMPARE(leaving.date(), QDate(2012, 3, 25)); + QCOMPARE(leaving.time(), QTime(3, 0)); + // QDateTimeParser relies on toMSecsSinceEpoch to still work: + QCOMPARE(leaving.toMSecsSinceEpoch(), spring2012); + + QDateTime after(QDate(2012, 3, 25), QTime(3, 0)); + QVERIFY(after.isValid()); + QVERIFY(after.isDaylightTime()); + QCOMPARE(after.date(), QDate(2012, 3, 25)); + QCOMPARE(after.time(), QTime(3, 0)); + QCOMPARE(after.toMSecsSinceEpoch(), spring2012); + + // Test round-tripping of msecs + + before.setMSecsSinceEpoch(spring2012 - 1); + QVERIFY(before.isValid()); + QCOMPARE(before.date(), QDate(2012, 3, 25)); + QCOMPARE(before.time(), QTime(1, 59, 59, 999)); + QCOMPARE(before.toMSecsSinceEpoch(), spring2012 -1); + + after.setMSecsSinceEpoch(spring2012); + QVERIFY(after.isValid()); + QCOMPARE(after.date(), QDate(2012, 3, 25)); + QCOMPARE(after.time(), QTime(3, 0)); + QCOMPARE(after.toMSecsSinceEpoch(), spring2012); + + // Test changing time spec re-validates the date/time + QDateTime utc(QDate(2012, 3, 25), QTime(2, 0), UTC); + QVERIFY(utc.isValid()); + QCOMPARE(utc.date(), QDate(2012, 3, 25)); + QCOMPARE(utc.time(), QTime(2, 0)); + utc.setTimeZone(QTimeZone::LocalTime); // Resolved to RelativeToBefore. + QVERIFY(utc.isValid()); + QCOMPARE(utc.date(), QDate(2012, 3, 25)); + QCOMPARE(utc.time(), QTime(3, 0)); + utc.setTimeZone(UTC); // Preserves the changed time(). + QVERIFY(utc.isValid()); + QCOMPARE(utc.date(), QDate(2012, 3, 25)); + QCOMPARE(utc.time(), QTime(3, 0)); + + // Test date maths, if result falls in missing hour then becomes next + // hour (or is always invalid; mktime() may reject gap-times). + + QDateTime test(QDate(2011, 3, 25), QTime(2, 0)); + QVERIFY(test.isValid()); + test = test.addYears(1); + const bool handled = test.isValid(); +#define CHECK_SPRING_FORWARD(test) \ + if (test.isValid()) { \ + QCOMPARE(test.date(), QDate(2012, 3, 25)); \ + QCOMPARE(test.time(), QTime(3, 0)); \ + } else { \ + QVERIFY(!handled); \ } + CHECK_SPRING_FORWARD(test); + + test = QDateTime(QDate(2012, 2, 25), QTime(2, 0)); + QVERIFY(test.isValid()); + test = test.addMonths(1); + CHECK_SPRING_FORWARD(test); + + test = QDateTime(QDate(2012, 3, 24), QTime(2, 0)); + QVERIFY(test.isValid()); + test = test.addDays(1); + CHECK_SPRING_FORWARD(test); + + test = QDateTime(QDate(2012, 3, 25), QTime(1, 0)); + QVERIFY(test.isValid()); + QCOMPARE(test.toMSecsSinceEpoch(), spring2012 - msecsOneHour); + test = test.addMSecs(msecsOneHour); + CHECK_SPRING_FORWARD(test); + if (handled) + QCOMPARE(test.toMSecsSinceEpoch(), spring2012); +#undef CHECK_SPRING_FORWARD + + // Test for correct behviour for DaylightTime -> StandardTime transition, fall-back + + QDateTime autumnMidnight = QDate(2012, 10, 28).startOfDay(); + QVERIFY(autumnMidnight.isValid()); + QCOMPARE(autumnMidnight.date(), QDate(2012, 10, 28)); + QCOMPARE(autumnMidnight.time(), QTime(0, 0)); + QCOMPARE(autumnMidnight.toMSecsSinceEpoch(), autumn2012 - 3 * msecsOneHour); + + QDateTime startFirst = autumnMidnight.addMSecs(2 * msecsOneHour); + QVERIFY(startFirst.isValid()); + QCOMPARE(startFirst, QDateTime(QDate(2012, 10, 28), QTime(2, 0), + QDateTime::TransitionResolution::PreferBefore)); + QCOMPARE(startFirst.date(), QDate(2012, 10, 28)); + QCOMPARE(startFirst.time(), QTime(2, 0)); + QCOMPARE(startFirst.toMSecsSinceEpoch(), autumn2012 - msecsOneHour); + + // 1 msec before transition is 2:59:59.999 FirstOccurrence + QDateTime endFirst = startFirst.addMSecs(msecsOneHour - 1); + QVERIFY(endFirst.isValid()); + QCOMPARE(endFirst, + QDateTime(QDate(2012, 10, 28), QTime(2, 59, 59, 999), + QDateTime::TransitionResolution::PreferBefore)); + QCOMPARE(endFirst.date(), QDate(2012, 10, 28)); + QCOMPARE(endFirst.time(), QTime(2, 59, 59, 999)); + QCOMPARE(endFirst.toMSecsSinceEpoch(), autumn2012 - 1); + + // At the transition, starting the second pass + QDateTime startRepeat = endFirst.addMSecs(1); + QVERIFY(startRepeat.isValid()); + QCOMPARE(startRepeat, QDateTime(QDate(2012, 10, 28), QTime(2, 0), + QDateTime::TransitionResolution::PreferAfter)); + QCOMPARE(startRepeat.date(), QDate(2012, 10, 28)); + QCOMPARE(startRepeat.time(), QTime(2, 0)); + QCOMPARE(startRepeat.toMSecsSinceEpoch(), autumn2012); + + // 59:59.999 after transition is 2:59:59.999 SecondOccurrence + QDateTime endRepeat = endFirst.addMSecs(msecsOneHour); + QVERIFY(endRepeat.isValid()); + QCOMPARE(endRepeat, + QDateTime(QDate(2012, 10, 28), QTime(2, 59, 59, 999), + QDateTime::TransitionResolution::PreferAfter)); + QCOMPARE(endRepeat.date(), QDate(2012, 10, 28)); + QCOMPARE(endRepeat.time(), QTime(2, 59, 59, 999)); + QCOMPARE(endRepeat.toMSecsSinceEpoch(), autumn2012 + msecsOneHour - 1); + + // 1 hour after transition is 3:00:00 (not ambiguous) + QDateTime hourAfter = endRepeat.addMSecs(1); + QVERIFY(hourAfter.isValid()); + QCOMPARE(hourAfter, QDateTime(QDate(2012, 10, 28), QTime(3, 0))); + QCOMPARE(hourAfter.date(), QDate(2012, 10, 28)); + QCOMPARE(hourAfter.time(), QTime(3, 0)); + QCOMPARE(hourAfter.toMSecsSinceEpoch(), autumn2012 + msecsOneHour); + + // Test round-tripping of msecs + + // 1 hour before transition is 2:00:00 FirstOccurrence + startFirst.setMSecsSinceEpoch(autumn2012 - msecsOneHour); + QVERIFY(startFirst.isValid()); + QCOMPARE(startFirst.date(), QDate(2012, 10, 28)); + QCOMPARE(startFirst.time(), QTime(2, 0)); + QCOMPARE(startFirst.toMSecsSinceEpoch(), autumn2012 - msecsOneHour); + + // 1 msec before transition is 2:59:59.999 FirstOccurrence + endFirst.setMSecsSinceEpoch(autumn2012 - 1); + QVERIFY(endFirst.isValid()); + QCOMPARE(endFirst.date(), QDate(2012, 10, 28)); + QCOMPARE(endFirst.time(), QTime(2, 59, 59, 999)); + QCOMPARE(endFirst.toMSecsSinceEpoch(), autumn2012 - 1); + + // At transition is 2:00:00 SecondOccurrence + startRepeat.setMSecsSinceEpoch(autumn2012); + QVERIFY(startRepeat.isValid()); + QCOMPARE(startRepeat.date(), QDate(2012, 10, 28)); + QCOMPARE(startRepeat.time(), QTime(2, 0)); + QCOMPARE(startRepeat.toMSecsSinceEpoch(), autumn2012); + + // 59:59.999 after transition is 2:59:59.999 SecondOccurrence + endRepeat.setMSecsSinceEpoch(autumn2012 + msecsOneHour - 1); + QVERIFY(endRepeat.isValid()); + QCOMPARE(endRepeat.date(), QDate(2012, 10, 28)); + QCOMPARE(endRepeat.time(), QTime(2, 59, 59, 999)); + QCOMPARE(endRepeat.toMSecsSinceEpoch(), autumn2012 + msecsOneHour - 1); + + // 1 hour after transition is 3:00:00 (unambiguous) + hourAfter.setMSecsSinceEpoch(autumn2012 + msecsOneHour); + QVERIFY(hourAfter.isValid()); + QCOMPARE(hourAfter.date(), QDate(2012, 10, 28)); + QCOMPARE(hourAfter.time(), QTime(3, 0)); + QCOMPARE(hourAfter.toMSecsSinceEpoch(), autumn2012 + msecsOneHour); + + // Test date maths + + // Add year to a DST moment to hit start of first pass: + test = QDateTime(QDate(2011, 10, 28), QTime(2, 0)); + QVERIFY(test.isDaylightTime()); // Before last Sunday in month + test = test.addYears(1); + QVERIFY(test.isValid()); + QVERIFY(test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(2, 0)); + // QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(2, 0), Prior)); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 - msecsOneHour); + + // Subtract year from post-tran time to hit start of second pass: + test = QDateTime(QDate(2013, 10, 28), QTime(2, 0)); + QVERIFY(!test.isDaylightTime()); // After last Sundy in month + test = test.addYears(-1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(2, 0)); + // QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(2, 0), Post)); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012); + + // Add year to get to after the repeated hour + test = QDateTime(QDate(2011, 10, 28), QTime(3, 0)); + QVERIFY(test.isDaylightTime()); // Before last Sunday in month + test = test.addYears(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(3, 0))); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 + msecsOneHour); + + // Add year to start of first pass: + test = QDateTime(QDate(2011, 10, 30), QTime(1, 0)).addMSecs(msecsOneHour); + QVERIFY(test.isDaylightTime()); + test = test.addYears(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); // After last Sunday in month + QCOMPARE(test.date(), QDate(2012, 10, 30)); + QCOMPARE(test.time(), QTime(2, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 30), QTime(2, 0))); + + // Add year to start of second pass: + test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)).addMSecs(-msecsOneHour); + QVERIFY(!test.isDaylightTime()); + test = test.addYears(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); // Same as before + QCOMPARE(test.date(), QDate(2012, 10, 30)); + QCOMPARE(test.time(), QTime(2, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 30), QTime(2, 0))); + + // Add year to after second pass: + test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)); + QVERIFY(!test.isDaylightTime()); + test = test.addYears(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 30)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 30), QTime(3, 0))); + + + // Add month to get to start of first pass + test = QDateTime(QDate(2012, 9, 28), QTime(2, 0)); + QVERIFY(test.isDaylightTime()); + test = test.addMonths(1); + QVERIFY(test.isValid()); + QVERIFY(test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(2, 0)); + // QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(2, 0), Prior)); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 - msecsOneHour); + + // Add month to get to after second pass (unambiguous) + test = QDateTime(QDate(2012, 9, 28), QTime(3, 0)); + QVERIFY(test.isDaylightTime()); + test = test.addMonths(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(3, 0))); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 + msecsOneHour); + + // Add month to start of first pass + test = QDateTime(QDate(2011, 10, 30), QTime(1, 0)).addMSecs(msecsOneHour); + QVERIFY(test.isDaylightTime()); + test = test.addMonths(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2011, 11, 30)); + QCOMPARE(test.time(), QTime(2, 0)); + QCOMPARE(test, QDateTime(QDate(2011, 11, 30), QTime(2, 0))); + + // Add month to end of second pass + test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)).addMSecs(-msecsOneHour); + QVERIFY(!test.isDaylightTime()); + test = test.addMonths(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2011, 11, 30)); + QCOMPARE(test.time(), QTime(2, 0)); + QCOMPARE(test, QDateTime(QDate(2011, 11, 30), QTime(2, 0))); + + // Add month to after after second pass (unambiguous) + test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)); + QVERIFY(!test.isDaylightTime()); + test = test.addMonths(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2011, 11, 30)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2011, 11, 30), QTime(3, 0))); + + + // Add day to get to start of first pass + test = QDateTime(QDate(2012, 10, 27), QTime(2, 0)); + QVERIFY(test.isDaylightTime()); + test = test.addDays(1); + QVERIFY(test.isValid()); + QVERIFY(test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(2, 0)); + // QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(2, 0), Prior)); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 - msecsOneHour); + + // Add day to get to after second pass (unambiguous) + test = QDateTime(QDate(2012, 10, 27), QTime(3, 0)); + QVERIFY(test.isDaylightTime()); + test = test.addDays(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(3, 0))); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 + msecsOneHour); + + // Add day to start of first pass + test = QDateTime(QDate(2011, 10, 30), QTime(1, 0)).addMSecs(msecsOneHour); + QVERIFY(test.isDaylightTime()); + test = test.addDays(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2011, 10, 31)); + QCOMPARE(test.time(), QTime(2, 0)); + QCOMPARE(test, QDateTime(QDate(2011, 10, 31), QTime(2, 0))); + + // Add day to start of second pass + test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)).addMSecs(-msecsOneHour); + QVERIFY(!test.isDaylightTime()); + test = test.addDays(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2011, 10, 31)); + QCOMPARE(test.time(), QTime(2, 0)); + QCOMPARE(test, QDateTime(QDate(2011, 10, 31), QTime(2, 0))); + + // Add day to after second pass (unambiguous) + test = QDateTime(QDate(2011, 10, 30), QTime(3, 0)); + QVERIFY(!test.isDaylightTime()); + test = test.addDays(1); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2011, 10, 31)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2011, 10, 31), QTime(3, 0))); + + + // Add hour to get to start of first pass + test = QDateTime(QDate(2012, 10, 28), QTime(1, 0)); + QVERIFY(test.isDaylightTime()); + test = test.addMSecs(msecsOneHour); + QVERIFY(test.isValid()); + QVERIFY(test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(2, 0)); + // QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(2, 0), Prior)); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 - msecsOneHour); + + // Add hour to start of first pass to get to start of second pass + test = test.addMSecs(msecsOneHour); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(2, 0)); + // QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(2, 0), Post)); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012); + + // Add hour to start of second pass to get to after second pass + test = test.addMSecs(msecsOneHour); + QVERIFY(test.isValid()); + QVERIFY(!test.isDaylightTime()); + QCOMPARE(test.date(), QDate(2012, 10, 28)); + QCOMPARE(test.time(), QTime(3, 0)); + QCOMPARE(test, QDateTime(QDate(2012, 10, 28), QTime(3, 0))); + QCOMPARE(test.toMSecsSinceEpoch(), autumn2012 + msecsOneHour); } void tst_QDateTime::timeZones() const { #if QT_CONFIG(timezone) QTimeZone invalidTz = QTimeZone("Vulcan/ShiKahr"); - QCOMPARE(invalidTz.isValid(), false); + QVERIFY(!invalidTz.isValid()); QDateTime invalidDateTime = QDateTime(QDate(2000, 1, 1), QTime(0, 0), invalidTz); - QCOMPARE(invalidDateTime.isValid(), false); + QVERIFY(!invalidDateTime.isValid()); QCOMPARE(invalidDateTime.date(), QDate(2000, 1, 1)); QCOMPARE(invalidDateTime.time(), QTime(0, 0)); @@ -3466,39 +4250,39 @@ void tst_QDateTime::timeZones() const QTimeZone nzTzOffset = QTimeZone(12 * 3600); // During Standard Time NZ is +12:00 - QDateTime utcStd(QDate(2012, 6, 1), QTime(0, 0), Qt::UTC); + QDateTime utcStd(QDate(2012, 6, 1), QTime(0, 0), UTC); QDateTime nzStd(QDate(2012, 6, 1), QTime(12, 0), nzTz); QDateTime nzStdOffset(QDate(2012, 6, 1), QTime(12, 0), nzTzOffset); - QCOMPARE(nzStd.isValid(), true); + QVERIFY(nzStd.isValid()); QCOMPARE(nzStd.timeSpec(), Qt::TimeZone); QCOMPARE(nzStd.date(), QDate(2012, 6, 1)); QCOMPARE(nzStd.time(), QTime(12, 0)); QVERIFY(nzStd.timeZone() == nzTz); QCOMPARE(nzStd.timeZone().id(), QByteArray("Pacific/Auckland")); QCOMPARE(nzStd.offsetFromUtc(), 43200); - QCOMPARE(nzStd.isDaylightTime(), false); + QVERIFY(!nzStd.isDaylightTime()); QCOMPARE(nzStd.toMSecsSinceEpoch(), utcStd.toMSecsSinceEpoch()); - QCOMPARE(nzStdOffset.isValid(), true); + QVERIFY(nzStdOffset.isValid()); QCOMPARE(nzStdOffset.timeSpec(), Qt::TimeZone); QCOMPARE(nzStdOffset.date(), QDate(2012, 6, 1)); QCOMPARE(nzStdOffset.time(), QTime(12, 0)); QVERIFY(nzStdOffset.timeZone() == nzTzOffset); QCOMPARE(nzStdOffset.timeZone().id(), QByteArray("UTC+12:00")); QCOMPARE(nzStdOffset.offsetFromUtc(), 43200); - QCOMPARE(nzStdOffset.isDaylightTime(), false); + QVERIFY(!nzStdOffset.isDaylightTime()); QCOMPARE(nzStdOffset.toMSecsSinceEpoch(), utcStd.toMSecsSinceEpoch()); // During Daylight Time NZ is +13:00 - QDateTime utcDst(QDate(2012, 1, 1), QTime(0, 0), Qt::UTC); + QDateTime utcDst(QDate(2012, 1, 1), QTime(0, 0), UTC); QDateTime nzDst(QDate(2012, 1, 1), QTime(13, 0), nzTz); - QCOMPARE(nzDst.isValid(), true); + QVERIFY(nzDst.isValid()); QCOMPARE(nzDst.date(), QDate(2012, 1, 1)); QCOMPARE(nzDst.time(), QTime(13, 0)); QCOMPARE(nzDst.offsetFromUtc(), 46800); - QCOMPARE(nzDst.isDaylightTime(), true); + QVERIFY(nzDst.isDaylightTime()); QCOMPARE(nzDst.toMSecsSinceEpoch(), utcDst.toMSecsSinceEpoch()); QDateTime utc = nzStd.toUTC(); @@ -3518,7 +4302,7 @@ void tst_QDateTime::timeZones() const QCOMPARE(aus.date(), QDate(2012, 6, 1)); QCOMPARE(aus.time(), QTime(10, 0)); - QDateTime dt1(QDate(2012, 6, 1), QTime(0, 0), Qt::UTC); + QDateTime dt1(QDate(2012, 6, 1), QTime(0, 0), UTC); QCOMPARE(dt1.timeSpec(), Qt::UTC); dt1.setTimeZone(nzTz); QCOMPARE(dt1.timeSpec(), Qt::TimeZone); @@ -3530,13 +4314,13 @@ void tst_QDateTime::timeZones() const QCOMPARE(dt2.date(), dt1.date()); QCOMPARE(dt2.time(), dt1.time()); QCOMPARE(dt2.timeSpec(), dt1.timeSpec()); - QCOMPARE(dt2.timeZone(), dt1.timeZone()); + QCOMPARE(dt2.timeRepresentation(), dt1.timeRepresentation()); QDateTime dt3 = QDateTime::fromMSecsSinceEpoch(1338465600000, nzTz); QCOMPARE(dt3.date(), dt1.date()); QCOMPARE(dt3.time(), dt1.time()); QCOMPARE(dt3.timeSpec(), dt1.timeSpec()); - QCOMPARE(dt3.timeZone(), dt1.timeZone()); + QCOMPARE(dt3.timeRepresentation(), dt1.timeRepresentation()); // The start of year 1 should be *describable* in any zone (QTBUG-78051) dt3 = QDateTime(QDate(1, 1, 1), QTime(0, 0), ausTz); @@ -3565,85 +4349,132 @@ void tst_QDateTime::timeZones() const QTimeZone cet("Europe/Oslo"); // Standard Time to Daylight Time 2013 on 2013-03-31 is 2:00 local time / 1:00 UTC - qint64 stdToDstMSecs = 1364691600000; + const qint64 gapMSecs = 1364691600000; + QCOMPARE(gapMSecs, QDateTime(QDate(2013, 3, 31), QTime(1, 0), UTC).toMSecsSinceEpoch()); // Test MSecs to local // - Test 1 msec before tran = 01:59:59.999 - QDateTime beforeDst = QDateTime::fromMSecsSinceEpoch(stdToDstMSecs - 1, cet); - QCOMPARE(beforeDst.date(), QDate(2013, 3, 31)); - QCOMPARE(beforeDst.time(), QTime(1, 59, 59, 999)); + QDateTime beforeGap = QDateTime::fromMSecsSinceEpoch(gapMSecs - 1, cet); + QCOMPARE(beforeGap.date(), QDate(2013, 3, 31)); + QCOMPARE(beforeGap.time(), QTime(1, 59, 59, 999)); // - Test at tran = 03:00:00 - QDateTime atDst = QDateTime::fromMSecsSinceEpoch(stdToDstMSecs, cet); - QCOMPARE(atDst.date(), QDate(2013, 3, 31)); - QCOMPARE(atDst.time(), QTime(3, 0)); + QDateTime atGap = QDateTime::fromMSecsSinceEpoch(gapMSecs, cet); + QCOMPARE(atGap.date(), QDate(2013, 3, 31)); + QCOMPARE(atGap.time(), QTime(3, 0)); // Test local to MSecs // - Test 1 msec before tran = 01:59:59.999 - beforeDst = QDateTime(QDate(2013, 3, 31), QTime(1, 59, 59, 999), cet); - QCOMPARE(beforeDst.toMSecsSinceEpoch(), stdToDstMSecs - 1); + beforeGap = QDateTime(QDate(2013, 3, 31), QTime(1, 59, 59, 999), cet); + QCOMPARE(beforeGap.toMSecsSinceEpoch(), gapMSecs - 1); // - Test at tran = 03:00:00 - atDst = QDateTime(QDate(2013, 3, 31), QTime(3, 0), cet); - QCOMPARE(atDst.toMSecsSinceEpoch(), stdToDstMSecs); + atGap = QDateTime(QDate(2013, 3, 31), QTime(3, 0), cet); + QCOMPARE(atGap.toMSecsSinceEpoch(), gapMSecs); // - Test transition hole, setting 03:00:00 is valid - atDst = QDateTime(QDate(2013, 3, 31), QTime(3, 0), cet); - QVERIFY(atDst.isValid()); - QCOMPARE(atDst.date(), QDate(2013, 3, 31)); - QCOMPARE(atDst.time(), QTime(3, 0)); - QCOMPARE(atDst.toMSecsSinceEpoch(), stdToDstMSecs); + atGap = QDateTime(QDate(2013, 3, 31), QTime(3, 0), cet); + QVERIFY(atGap.isValid()); + QCOMPARE(atGap.date(), QDate(2013, 3, 31)); + QCOMPARE(atGap.time(), QTime(3, 0)); + QCOMPARE(atGap.toMSecsSinceEpoch(), gapMSecs); // - Test transition hole, setting 02:00:00 is invalid - atDst = QDateTime(QDate(2013, 3, 31), QTime(2, 0), cet); - QVERIFY(!atDst.isValid()); - QCOMPARE(atDst.date(), QDate(2013, 3, 31)); - QCOMPARE(atDst.time(), QTime(2, 0)); - // - Test transition hole, setting 02:59:59.999 is invalid - atDst = QDateTime(QDate(2013, 3, 31), QTime(2, 59, 59, 999), cet); - QVERIFY(!atDst.isValid()); - QCOMPARE(atDst.date(), QDate(2013, 3, 31)); - QCOMPARE(atDst.time(), QTime(2, 59, 59, 999)); + QDateTime inGap = QDateTime(QDate(2013, 3, 31), QTime(2, 0), cet); + QVERIFY(inGap.isValid()); + QCOMPARE(inGap.date(), QDate(2013, 3, 31)); + QCOMPARE(inGap.time(), QTime(3, 0)); + QCOMPARE(inGap.offsetFromUtc(), 7200); + // - Test transition hole, 02:59:59.999 was skipped: + inGap = QDateTime(QDate(2013, 3, 31), QTime(2, 59, 59, 999), cet); + QVERIFY(inGap.isValid()); + QCOMPARE(inGap.date(), QDate(2013, 3, 31)); + QCOMPARE(inGap.time(), QTime(3, 59, 59, 999)); + QCOMPARE(inGap.offsetFromUtc(), 7200); + // Test similar for local time, if it's CET: + if (zoneIsCET) { + inGap = QDateTime(QDate(2013, 3, 31), QTime(2, 30)); + QVERIFY(inGap.isValid()); + QCOMPARE(inGap.date(), QDate(2013, 3, 31)); + QCOMPARE(inGap.offsetFromUtc(), 7200); + QCOMPARE(inGap.time(), QTime(3, 30)); + } + + // Test a gap more than 1'141'707.91-years from 1970, outside ShortData's range, + // The zone version is non-short in any case, but check it anyway. + // However, we can only test this if the underlying OS believes CET continues + // exercising DST indefinitely; Darwin, for example, assumes we'll have all + // kicked the habit by the end of 2100. + constexpr int longYear = 1'143'678; + constexpr qint64 millisInWeek = qint64(7) * 24 * 60 * 60 * 1000; + if (QDateTime(QDate(longYear, 3, 24), QTime(12, 0), cet).msecsTo( + QDateTime(QDate(longYear, 3, 31), QTime(12, 0), cet)) < millisInWeek) { + inGap = QDateTime(QDate(longYear, 3, 27), QTime(2, 30), cet); + QVERIFY(inGap.isValid()); + QCOMPARE(inGap.date(), QDate(longYear, 3, 27)); + QCOMPARE(inGap.time(), QTime(3, 30)); + QCOMPARE(inGap.offsetFromUtc(), 7200); + } else { + qDebug("Skipping far-future check beyond zoned end of DST"); + } + if (zoneIsCET && QDateTime(QDate(longYear, 3, 24), QTime(12, 0)).msecsTo( + QDateTime(QDate(longYear, 3, 31), QTime(12, 0))) < millisInWeek) { + inGap = QDateTime(QDate(longYear, 3, 27), QTime(2, 30)); + QVERIFY(inGap.isValid()); + QCOMPARE(inGap.date(), QDate(longYear, 3, 27)); + QCOMPARE(inGap.offsetFromUtc(), 7200); + QCOMPARE(inGap.time(), QTime(3, 30)); + } else { + qDebug(zoneIsCET ? "Skipping far-future check beyond local end of DST" + : "Skipping CET-specific test"); + } // Standard Time to Daylight Time 2013 on 2013-10-27 is 3:00 local time / 1:00 UTC - qint64 dstToStdMSecs = 1382835600000; + const qint64 replayMSecs = 1382835600000; + QCOMPARE(replayMSecs, QDateTime(QDate(2013, 10, 27), QTime(1, 0), UTC).toMSecsSinceEpoch()); // Test MSecs to local // - Test 1 hour before tran = 02:00:00 local first occurrence - QDateTime hourBeforeStd = QDateTime::fromMSecsSinceEpoch(dstToStdMSecs - 3600000, cet); - QCOMPARE(hourBeforeStd.date(), QDate(2013, 10, 27)); - QCOMPARE(hourBeforeStd.time(), QTime(2, 0)); + QDateTime startFirst = QDateTime::fromMSecsSinceEpoch(replayMSecs - 3600000, cet); + QCOMPARE(startFirst.date(), QDate(2013, 10, 27)); + QCOMPARE(startFirst.time(), QTime(2, 0)); // - Test 1 msec before tran = 02:59:59.999 local first occurrence - QDateTime msecBeforeStd = QDateTime::fromMSecsSinceEpoch(dstToStdMSecs - 1, cet); - QCOMPARE(msecBeforeStd.date(), QDate(2013, 10, 27)); - QCOMPARE(msecBeforeStd.time(), QTime(2, 59, 59, 999)); + QDateTime endFirst = QDateTime::fromMSecsSinceEpoch(replayMSecs - 1, cet); + QCOMPARE(endFirst.date(), QDate(2013, 10, 27)); + QCOMPARE(endFirst.time(), QTime(2, 59, 59, 999)); // - Test at tran = 03:00:00 local becomes 02:00:00 local second occurrence - QDateTime atStd = QDateTime::fromMSecsSinceEpoch(dstToStdMSecs, cet); - QCOMPARE(atStd.date(), QDate(2013, 10, 27)); - QCOMPARE(atStd.time(), QTime(2, 0)); + QDateTime startRepeat = QDateTime::fromMSecsSinceEpoch(replayMSecs, cet); + QCOMPARE(startRepeat.date(), QDate(2013, 10, 27)); + QCOMPARE(startRepeat.time(), QTime(2, 0)); // - Test 59 mins after tran = 02:59:59.999 local second occurrence - QDateTime afterStd = QDateTime::fromMSecsSinceEpoch(dstToStdMSecs + 3600000 -1, cet); - QCOMPARE(afterStd.date(), QDate(2013, 10, 27)); - QCOMPARE(afterStd.time(), QTime(2, 59, 59, 999)); + QDateTime endRepeat = QDateTime::fromMSecsSinceEpoch(replayMSecs + 3600000 -1, cet); + QCOMPARE(endRepeat.date(), QDate(2013, 10, 27)); + QCOMPARE(endRepeat.time(), QTime(2, 59, 59, 999)); // - Test 1 hour after tran = 03:00:00 local - QDateTime hourAfterStd = QDateTime::fromMSecsSinceEpoch(dstToStdMSecs + 3600000, cet); - QCOMPARE(hourAfterStd.date(), QDate(2013, 10, 27)); - QCOMPARE(hourAfterStd.time(), QTime(3, 00, 00)); + QDateTime hourAfter = QDateTime::fromMSecsSinceEpoch(replayMSecs + 3600000, cet); + QCOMPARE(hourAfter.date(), QDate(2013, 10, 27)); + QCOMPARE(hourAfter.time(), QTime(3, 0)); + + // TODO (QTBUG-79923): Compare to results of direct QDateTime(date, time, cet, fold) + // construction; see Prior/Post commented-out tests. // Test local to MSecs // - Test first occurrence 02:00:00 = 1 hour before tran - hourBeforeStd = QDateTime(QDate(2013, 10, 27), QTime(2, 0), cet); - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); - QCOMPARE(hourBeforeStd.toMSecsSinceEpoch(), dstToStdMSecs - 3600000); + startFirst = QDateTime(QDate(2013, 10, 27), QTime(1, 59, 59), cet).addSecs(1); + // QCOMPARE(startFirst, QDateTime(QDate(2013, 10, 27), QTime(2, 0), cet, Prior)); + QCOMPARE(startFirst.toMSecsSinceEpoch(), replayMSecs - 3600000); // - Test first occurrence 02:59:59.999 = 1 msec before tran - msecBeforeStd = QDateTime(QDate(2013, 10, 27), QTime(2, 59, 59, 999), cet); - QEXPECT_FAIL("", "QDateTime doesn't properly support Daylight Transitions", Continue); - QCOMPARE(msecBeforeStd.toMSecsSinceEpoch(), dstToStdMSecs - 1); + endFirst = startFirst.addMSecs(3599999); + // QCOMPARE(endFirst, QDateTime(QDate(2013, 10, 27), QTime(2, 59, 59, 999), cet, Prior)); + QCOMPARE(endFirst.toMSecsSinceEpoch(), replayMSecs - 1); // - Test second occurrence 02:00:00 = at tran - atStd = QDateTime(QDate(2013, 10, 27), QTime(2, 0), cet); - QCOMPARE(atStd.toMSecsSinceEpoch(), dstToStdMSecs); - // - Test second occurrence 03:00:00 = 59 mins after tran - afterStd = QDateTime(QDate(2013, 10, 27), QTime(2, 59, 59, 999), cet); - QCOMPARE(afterStd.toMSecsSinceEpoch(), dstToStdMSecs + 3600000 - 1); - // - Test 03:00:00 = 1 hour after tran - hourAfterStd = QDateTime(QDate(2013, 10, 27), QTime(3, 0), cet); - QCOMPARE(hourAfterStd.toMSecsSinceEpoch(), dstToStdMSecs + 3600000); + startRepeat = endFirst.addMSecs(1); + // QCOMPARE(startRepeat, QDateTime(QDate(2013, 10, 27), QTime(2, 0), cet, Post)); + QCOMPARE(startRepeat.toMSecsSinceEpoch(), replayMSecs); + // - Test second occurrence 02:59:59.999 = 1 msec before 1 hour after tran + endRepeat = startRepeat.addMSecs(3599999); + // QCOMPARE(endRepeat, QDateTime(QDate(2013, 10, 27), QTime(2, 59, 59, 999), cet, Post)); + QCOMPARE(endRepeat.toMSecsSinceEpoch(), replayMSecs + 3600000 - 1); + // - Test 03:00:00 = 1 hour after tran (no ambiguity) + hourAfter = endRepeat.addMSecs(1); + QCOMPARE(hourAfter, QDateTime(QDate(2013, 10, 27), QTime(3, 0), cet)); + QCOMPARE(hourAfter.toMSecsSinceEpoch(), replayMSecs + 3600000); // Test Time Zone that has transitions but no future transitions afer a given date QTimeZone sgt("Asia/Singapore"); @@ -3655,35 +4486,60 @@ void tst_QDateTime::timeZones() const #endif } +void tst_QDateTime::systemTimeZoneChange_data() const +{ + QTest::addColumn<QDate>("date"); + QTest::newRow("short") << QDate(1970, 1, 1); + QTest::newRow("2012") << QDate(2012, 6, 1); // short on 64-bit, pimpled on 32-bit + QTest::newRow("pimpled") << QDate(1150000, 6, 1); +} + void tst_QDateTime::systemTimeZoneChange() const { - // Set the timezone to Brisbane time - TimeZoneRollback useZone(QByteArray("AEST-10:00")); + QFETCH(const QDate, date); + const QTime early(2, 15, 30); - QDateTime localDate = QDateTime(QDate(2012, 6, 1), QTime(2, 15, 30), Qt::LocalTime); - QDateTime utcDate = QDateTime(QDate(2012, 6, 1), QTime(2, 15, 30), Qt::UTC); + // Start out in Brisbane time: + TimeZoneRollback useZone(QByteArray("AEST-10:00")); + if (QDateTime(date, early).offsetFromUtc() != 600 * 60) + QSKIP("Test depends on system support for changing zone to AEST-10:00"); #if QT_CONFIG(timezone) - QDateTime tzDate = QDateTime(QDate(2012, 6, 1), QTime(2, 15, 30), QTimeZone("Australia/Brisbane")); + QVERIFY(QTimeZone::systemTimeZone().isValid()); #endif - qint64 localMsecs = localDate.toMSecsSinceEpoch(); - qint64 utcMsecs = utcDate.toMSecsSinceEpoch(); + + const QDateTime localDate = QDateTime(date, early); + const QDateTime utcDate = QDateTime(date, early, UTC); + const qint64 localMsecs = localDate.toMSecsSinceEpoch(); + const qint64 utcMsecs = utcDate.toMSecsSinceEpoch(); #if QT_CONFIG(timezone) - qint64 tzMsecs = tzDate.toMSecsSinceEpoch(); + const QTimeZone aest("Australia/Brisbane"); // no transitions since 1992 + // Check that Australia/Brisbane is known: + QVERIFY(aest.isValid()); + const QDateTime tzDate = QDateTime(date, early, aest); - // check that Australia/Brisbane is known + // Check we got the right zone ! QVERIFY(tzDate.timeZone().isValid()); + QCOMPARE(tzDate.timeZone(), aest); + const qint64 tzMsecs = tzDate.toMSecsSinceEpoch(); #endif // Change to Indian time useZone.reset(QByteArray("IST-05:30")); + if (QDateTime(date, early).offsetFromUtc() != 330 * 60) + QSKIP("Test depends on system support for changing zone to IST-05:30"); +#if QT_CONFIG(timezone) + QVERIFY(QTimeZone::systemTimeZone().isValid()); +#endif - QCOMPARE(localDate, QDateTime(QDate(2012, 6, 1), QTime(2, 15, 30), Qt::LocalTime)); - QVERIFY(localMsecs != localDate.toMSecsSinceEpoch()); - QCOMPARE(utcDate, QDateTime(QDate(2012, 6, 1), QTime(2, 15, 30), Qt::UTC)); + QCOMPARE(localDate, QDateTime(date, early)); + // Note: localDate.toMSecsSinceEpoch == localMsecs, unchanged, iff localDate is pimpled. + QVERIFY(localMsecs != QDateTime(date, early).toMSecsSinceEpoch()); + QCOMPARE(utcDate, QDateTime(date, early, UTC)); QCOMPARE(utcDate.toMSecsSinceEpoch(), utcMsecs); #if QT_CONFIG(timezone) - QCOMPARE(tzDate, QDateTime(QDate(2012, 6, 1), QTime(2, 15, 30), QTimeZone("Australia/Brisbane"))); QCOMPARE(tzDate.toMSecsSinceEpoch(), tzMsecs); + QCOMPARE(tzDate.timeZone(), aest); + QCOMPARE(tzDate, QDateTime(date, early, aest)); #endif } @@ -3698,17 +4554,19 @@ void tst_QDateTime::invalid_data() const QTest::newRow("simple") << invalidDate << Qt::LocalTime << true; QTest::newRow("UTC") << invalidDate.toUTC() << Qt::UTC << true; QTest::newRow("offset") - << invalidDate.toOffsetFromUtc(3600) << Qt::OffsetFromUTC << true; + << invalidDate.toTimeZone(QTimeZone::fromSecondsAheadOfUtc(3600)) << Qt::OffsetFromUTC + << true; #if QT_CONFIG(timezone) QTest::newRow("CET") << invalidDate.toTimeZone(QTimeZone("Europe/Oslo")) << Qt::TimeZone << true; // Crash tests, QTBUG-80146: QTest::newRow("nozone+construct") - << QDateTime(QDate(1970, 1, 1), QTime(12, 0), QTimeZone()) << Qt::TimeZone << false; + << QDateTime(QDate(1970, 1, 1), QTime(12, 0), QTimeZone()) + << Qt::TimeZone << false; QTest::newRow("nozone+fromMSecs") << QDateTime::fromMSecsSinceEpoch(42, QTimeZone()) << Qt::TimeZone << false; - QDateTime valid(QDate(1970, 1, 1), QTime(12, 0), Qt::UTC); + QDateTime valid(QDate(1970, 1, 1), QTime(12, 0), UTC); QTest::newRow("tonozone") << valid.toTimeZone(QTimeZone()) << Qt::TimeZone << false; #endif } @@ -3724,23 +4582,36 @@ void tst_QDateTime::invalid() const if (!goodZone) QCOMPARE(when.toMSecsSinceEpoch(), 0); QVERIFY(!when.isDaylightTime()); -#if QT_CONFIG(timezone) - QCOMPARE(when.timeZone().isValid(), goodZone); -#endif + QCOMPARE(when.timeRepresentation().isValid(), goodZone); } void tst_QDateTime::range() const { using Bounds = std::numeric_limits<qint64>; - QCOMPARE(QDateTime::fromMSecsSinceEpoch(Bounds::min() + 1, Qt::UTC).date().year(), + QCOMPARE(QDateTime::fromMSecsSinceEpoch(Bounds::min() + 1, UTC).date().year(), int(QDateTime::YearRange::First)); - QCOMPARE(QDateTime::fromMSecsSinceEpoch(Bounds::max() - 1, Qt::UTC).date().year(), + QCOMPARE(QDateTime::fromMSecsSinceEpoch(Bounds::max() - 1, UTC).date().year(), int(QDateTime::YearRange::Last)); + constexpr qint64 millisPerDay = 24 * 3600 * 1000; + constexpr qint64 wholeDays = Bounds::max() / millisPerDay; + constexpr qint64 millisRemainder = Bounds::max() % millisPerDay; + QVERIFY(QDateTime(QDate(1970, 1, 1).addDays(wholeDays), + QTime::fromMSecsSinceStartOfDay(millisRemainder), + UTC).isValid()); + QVERIFY(!QDateTime(QDate(1970, 1, 1).addDays(wholeDays), + QTime::fromMSecsSinceStartOfDay(millisRemainder + 1), + UTC).isValid()); + QVERIFY(QDateTime(QDate(1970, 1, 1).addDays(-wholeDays - 1), + QTime::fromMSecsSinceStartOfDay(3600 * 24000 - millisRemainder - 1), + UTC).isValid()); + QVERIFY(!QDateTime(QDate(1970, 1, 1).addDays(-wholeDays - 1), + QTime::fromMSecsSinceStartOfDay(3600 * 24000 - millisRemainder - 2), + UTC).isValid()); } void tst_QDateTime::macTypes() { -#ifndef Q_OS_MAC +#ifndef Q_OS_DARWIN QSKIP("This is a Apple-only test"); #else extern void tst_QDateTime_macTypes(); // in qdatetime_mac.mm @@ -3748,5 +4619,223 @@ void tst_QDateTime::macTypes() #endif } +#if __cpp_lib_chrono >= 201907L +using StdSysMillis = std::chrono::sys_time<std::chrono::milliseconds>; +Q_DECLARE_METATYPE(StdSysMillis); +#endif + +void tst_QDateTime::stdCompatibilitySysTime_data() +{ +#if __cpp_lib_chrono >= 201907L + QTest::addColumn<StdSysMillis>("sysTime"); + QTest::addColumn<QDateTime>("expected"); + + using namespace std::chrono; + + QTest::newRow("zero") + << StdSysMillis(0s) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0), UTC); + QTest::newRow("1s") + << StdSysMillis(1s) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0, 1), UTC); + QTest::newRow("1ms") + << StdSysMillis(1ms) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0, 1), UTC); + QTest::newRow("365d") + << StdSysMillis(days(365)) + << QDateTime(QDate(1971, 1, 1), QTime(0, 0), UTC); + QTest::newRow("-1s") + << StdSysMillis(-1s) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59), UTC); + QTest::newRow("-1ms") + << StdSysMillis(-1ms) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59, 999), UTC); + + { + // The first leap second occurred on 30 June 1972 at 23:59:60. + // Check that QDateTime does not take that leap second into account (like sys_time) + const year_month_day firstLeapSecondDate = 1972y/July/1; + const sys_days firstLeapSecondDateAsSysDays = firstLeapSecondDate; + QTest::newRow("first_leap_second") + << StdSysMillis(firstLeapSecondDateAsSysDays) + << QDateTime(QDate(1972, 7, 1), QTime(0, 0), UTC); + } + + { + // Random date + const sys_days date = 2000y/January/31; + const StdSysMillis dateTime = date + 3h + 10min + 42s; + QTest::newRow("2000-01-31 03:10:42") + << dateTime + << QDateTime(QDate(2000, 1, 31), QTime(3, 10, 42), UTC); + } +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} + +void tst_QDateTime::stdCompatibilitySysTime() +{ +#if __cpp_lib_chrono >= 201907L + QFETCH(StdSysMillis, sysTime); + QFETCH(QDateTime, expected); + + using namespace std::chrono; + + // system_clock in milliseconds -> QDateTime + QDateTime dtFromSysTime = QDateTime::fromStdTimePoint(sysTime); + QCOMPARE(dtFromSysTime, expected); + QCOMPARE(dtFromSysTime.timeSpec(), Qt::UTC); + + // QDateTime -> system_clock in milliseconds + StdSysMillis sysTimeFromDt = dtFromSysTime.toStdSysMilliseconds(); + QCOMPARE(sysTimeFromDt, sysTime); + + // system_clock in seconds -> QDateTime + sys_seconds sysTimeSecs = floor<seconds>(sysTime); + QDateTime dtFromSysSeconds = QDateTime::fromStdTimePoint(sysTimeSecs); + QDateTime expectedInSeconds = expected.addMSecs(-expected.time().msec()); // "floor" + QCOMPARE(dtFromSysSeconds, expectedInSeconds); + QCOMPARE(dtFromSysSeconds.timeSpec(), Qt::UTC); + + // QDateTime -> system_clock in seconds + sys_seconds sysTimeFromDtSecs = dtFromSysSeconds.toStdSysSeconds(); + QCOMPARE(sysTimeFromDtSecs, sysTimeSecs); + + // utc_clock in milliseconds -> QDateTime + utc_time<std::chrono::milliseconds> utcTime = utc_clock::from_sys(sysTime); + QDateTime dtFromUtcTime = QDateTime::fromStdTimePoint(utcTime); + QCOMPARE(dtFromUtcTime, expected); + QCOMPARE(dtFromUtcTime.timeSpec(), Qt::UTC); + + // QDateTime -> system_clock in milliseconds + sysTimeFromDt = dtFromUtcTime.toStdSysMilliseconds(); + QCOMPARE(sysTimeFromDt, sysTime); +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} + +#if __cpp_lib_chrono >= 201907L +using StdLocalMillis = std::chrono::local_time<std::chrono::milliseconds>; +Q_DECLARE_METATYPE(StdLocalMillis); +#endif + +void tst_QDateTime::stdCompatibilityLocalTime_data() +{ +#if __cpp_lib_chrono >= 201907L + QTest::addColumn<StdLocalMillis>("localTime"); + QTest::addColumn<QDateTime>("expected"); + + using namespace std::chrono; + + QTest::newRow("zero") + << StdLocalMillis(0s) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0)); + QTest::newRow("1s") + << StdLocalMillis(1s) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0, 1)); + QTest::newRow("1ms") + << StdLocalMillis(1ms) + << QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0, 1)); + QTest::newRow("365d") + << StdLocalMillis(days(365)) + << QDateTime(QDate(1971, 1, 1), QTime(0, 0)); + QTest::newRow("-1s") + << StdLocalMillis(-1s) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59)); + QTest::newRow("-1ms") + << StdLocalMillis(-1ms) + << QDateTime(QDate(1969, 12, 31), QTime(23, 59, 59, 999)); + { + // Random date + const local_days date = local_days(2000y/January/31); + const StdLocalMillis dateTime = date + 3h + 10min + 42s; + QTest::newRow("2000-01-31 03:10:42") + << dateTime + << QDateTime(QDate(2000, 1, 31), QTime(3, 10, 42)); + } +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} + +void tst_QDateTime::stdCompatibilityLocalTime() +{ +#if __cpp_lib_chrono >= 201907L + QFETCH(StdLocalMillis, localTime); + QFETCH(QDateTime, expected); + + using namespace std::chrono; + + QDateTime dtFromLocalTime = QDateTime::fromStdLocalTime(localTime); + QCOMPARE(dtFromLocalTime, expected); + QCOMPARE(dtFromLocalTime.timeSpec(), Qt::LocalTime); + + const time_zone *tz = current_zone(); + QVERIFY(tz); + const StdSysMillis sysMillis = tz->to_sys(localTime); + QCOMPARE(dtFromLocalTime.toStdSysMilliseconds(), sysMillis); +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} + +#if QT_CONFIG(timezone) +#if __cpp_lib_chrono >= 201907L +using StdZonedMillis = std::chrono::zoned_time<std::chrono::milliseconds>; +Q_DECLARE_METATYPE(StdZonedMillis); +#endif + +void tst_QDateTime::stdCompatibilityZonedTime_data() +{ +#if __cpp_lib_chrono >= 201907L + QTest::addColumn<StdZonedMillis>("zonedTime"); + QTest::addColumn<QDateTime>("expected"); + + using namespace std::chrono; + using namespace std::literals; + + const char timeZoneName[] = "Europe/Oslo"; + const QTimeZone timeZone(timeZoneName); + + { + StdZonedMillis zs(timeZoneName, local_days(2021y/1/1)); + QTest::addRow("localTimeOslo") + << zs + << QDateTime(QDate(2021, 1, 1), QTime(0, 0), timeZone); + } + { + StdZonedMillis zs(timeZoneName, sys_days(2021y/1/1)); + QTest::addRow("sysTimeOslo") + << zs + << QDateTime(QDate(2021, 1, 1), QTime(1, 0), timeZone); + } + { + StdZonedMillis zs(timeZoneName, sys_days(2021y/7/1)); + QTest::addRow("sysTimeOslo summer") + << zs + << QDateTime(QDate(2021, 7, 1), QTime(2, 0), timeZone); + } +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} + +void tst_QDateTime::stdCompatibilityZonedTime() +{ +#if __cpp_lib_chrono >= 201907L + QFETCH(StdZonedMillis, zonedTime); + QFETCH(QDateTime, expected); + + QDateTime dtFromZonedTime = QDateTime::fromStdZonedTime(zonedTime); + QCOMPARE(dtFromZonedTime, expected); + QCOMPARE(dtFromZonedTime.timeSpec(), Qt::TimeZone); +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} +#endif // QT_CONFIG(timezone) + QTEST_APPLESS_MAIN(tst_QDateTime) #include "tst_qdatetime.moc" diff --git a/tests/auto/corelib/time/qdatetime/tst_qdatetime_mac.mm b/tests/auto/corelib/time/qdatetime/tst_qdatetime_mac.mm index 4af199b4f8..08379ccb41 100644 --- a/tests/auto/corelib/time/qdatetime/tst_qdatetime_mac.mm +++ b/tests/auto/corelib/time/qdatetime/tst_qdatetime_mac.mm @@ -1,34 +1,11 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Copyright (C) 2014 Petroules Corporation. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2020 The Qt Company Ltd. +// Copyright (C) 2014 Petroules Corporation. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QtCore/QDateTime> -#include <QtTest/QtTest> +#include <QTest> + +#include <QtCore/private/qcore_mac_p.h> #include <CoreFoundation/CoreFoundation.h> #include <Foundation/Foundation.h> diff --git a/tests/auto/corelib/time/qdatetimeparser/.gitignore b/tests/auto/corelib/time/qdatetimeparser/.gitignore new file mode 100644 index 0000000000..880d073ac8 --- /dev/null +++ b/tests/auto/corelib/time/qdatetimeparser/.gitignore @@ -0,0 +1 @@ +tst_qdatetimeparser diff --git a/tests/auto/corelib/time/qdatetimeparser/CMakeLists.txt b/tests/auto/corelib/time/qdatetimeparser/CMakeLists.txt new file mode 100644 index 0000000000..6bdd66ebfc --- /dev/null +++ b/tests/auto/corelib/time/qdatetimeparser/CMakeLists.txt @@ -0,0 +1,19 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +##################################################################### +## tst_qdatetimeparser Test: +##################################################################### + +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qdatetimeparser LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qdatetimeparser + SOURCES + tst_qdatetimeparser.cpp + LIBRARIES + Qt::CorePrivate +) diff --git a/tests/auto/corelib/time/qdatetimeparser/tst_qdatetimeparser.cpp b/tests/auto/corelib/time/qdatetimeparser/tst_qdatetimeparser.cpp new file mode 100644 index 0000000000..bfc811eebe --- /dev/null +++ b/tests/auto/corelib/time/qdatetimeparser/tst_qdatetimeparser.cpp @@ -0,0 +1,211 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QTest> +#include <private/qdatetimeparser_p.h> + +using namespace Qt::StringLiterals; + +QT_BEGIN_NAMESPACE + +// access to needed members in QDateTimeParser +class QDTPUnitTestParser : public QDateTimeParser +{ +public: + QDTPUnitTestParser() : QDateTimeParser(QMetaType::QDateTime, QDateTimeParser::DateTimeEdit) { } + + // forward data structures + using QDateTimeParser::ParsedSection; + using QDateTimeParser::State; + + // function to manipulate private internals + void setText(QString text) { m_text = text; } + + // forwarding of methods + using QDateTimeParser::parseSection; +}; + +bool operator==(const QDTPUnitTestParser::ParsedSection &a, + const QDTPUnitTestParser::ParsedSection &b) +{ + return a.value == b.value && a.used == b.used && a.zeroes == b.zeroes && a.state == b.state; +} + +// pretty printing for ParsedSection +char *toString(const QDTPUnitTestParser::ParsedSection §ion) +{ + using QTest::toString; + return toString(QByteArray("ParsedSection(") + "state=" + QByteArray::number(section.state) + + ", value=" + QByteArray::number(section.value) + + ", used=" + QByteArray::number(section.used) + + ", zeros=" + QByteArray::number(section.zeroes) + ")"); +} + +QT_END_NAMESPACE + +class tst_QDateTimeParser : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + void reparse(); + void parseSection_data(); + void parseSection(); + + void intermediateYear_data(); + void intermediateYear(); +}; + +void tst_QDateTimeParser::reparse() +{ + const QDateTime when = QDate(2023, 6, 15).startOfDay(); + // QTBUG-114575: 6.2 through 6.5 got back a bogus Qt::TimeZone (with zero offset): + const auto expect = ([](QStringView name) { + // When local time is UTC or a fixed offset from it, the parser prefers + // to interpret a UTC or offset suffix as such, rather than as local + // time (thereby avoiding DST-ness checks). We have to match that here. + if (name == "UTC"_L1) + return Qt::UTC; + if (name.startsWith(u'+') || name.startsWith(u'-')) { + if (std::all_of(name.begin() + 1, name.end(), [](QChar ch) { return ch == u'0'; })) + return Qt::UTC; + if (std::all_of(name.begin() + 1, name.end(), [](QChar ch) { return ch.isDigit(); })) + return Qt::OffsetFromUTC; + // Potential hh:mm offset ? Not yet seen as local tzname[] entry. + } + return Qt::LocalTime; + }); + + const QStringView format = u"dd/MM/yyyy HH:mm t"; + QDateTimeParser who(QMetaType::QDateTime, QDateTimeParser::DateTimeEdit); + QVERIFY(who.parseFormat(format)); + { + // QDTP defaults to the system locale. + const auto state = who.parse(QLocale::system().toString(when, format), -1, when, false); + QCOMPARE(state.state, QDateTimeParser::Acceptable); + QVERIFY(!state.conflicts); + QCOMPARE(state.padded, 0); + QCOMPARE(state.value.timeSpec(), expect(when.timeZoneAbbreviation())); + QCOMPARE(state.value, when); + } + { + // QDT::toString() uses the C locale: + who.setDefaultLocale(QLocale::c()); + const QString zoneName = ([when]() { +#if QT_CONFIG(timezone) + if (QLocale::c() != QLocale::system()) { + const QString local = when.timeRepresentation().displayName( + when, QTimeZone::ShortName, QLocale::c()); + if (!local.isEmpty()) + return local; + } +#endif + return when.timeZoneAbbreviation(); + })(); + const auto state = who.parse(when.toString(format), -1, when, false); + QCOMPARE(state.state, QDateTimeParser::Acceptable); + QVERIFY(!state.conflicts); + QCOMPARE(state.padded, 0); + QCOMPARE(state.value.timeSpec(), expect(zoneName)); + QCOMPARE(state.value, when); + } +} + +void tst_QDateTimeParser::parseSection_data() +{ + QTest::addColumn<QString>("format"); + QTest::addColumn<QString>("input"); + QTest::addColumn<int>("sectionIndex"); + QTest::addColumn<int>("offset"); + QTest::addColumn<QDTPUnitTestParser::ParsedSection>("expected"); + + using ParsedSection = QDTPUnitTestParser::ParsedSection; + using State = QDTPUnitTestParser::State; + QTest::newRow("short-year-begin") + << "yyyy_MM_dd" << "200_12_15" << 0 << 0 + << ParsedSection(State::Intermediate ,200, 3, 0); + + QTest::newRow("short-year-middle") + << "MM-yyyy-dd" << "12-200-15" << 1 << 3 + << ParsedSection(State::Intermediate, 200, 3, 0); + + QTest::newRow("negative-year-middle-5") + << "MM-yyyy-dd" << "12--2000-15" << 1 << 3 + << ParsedSection(State::Acceptable, -2000, 5, 0); + + QTest::newRow("short-negative-year-middle-4") + << "MM-yyyy-dd" << "12--200-15" << 1 << 3 + << ParsedSection(State::Intermediate, -200, 4, 0); + + QTest::newRow("short-negative-year-middle-3") + << "MM-yyyy-dd" << "12--20-15" << 1 << 3 + << ParsedSection(State::Intermediate, -20, 3, 0); + + QTest::newRow("short-negative-year-middle-2") + << "MM-yyyy-dd" << "12--2-15" << 1 << 3 + << ParsedSection(State::Intermediate, -2, 2, 0); + + QTest::newRow("short-negative-year-middle-1") + << "MM-yyyy-dd" << "12---15" << 1 << 3 + << ParsedSection(State::Intermediate, 0, 1, 0); + + // Here the -15 will be understood as year, with separator and day omitted, + // although it could equally be read as month and day with missing year. + QTest::newRow("short-negative-year-middle-0") + << "MM-yyyy-dd" << "12--15" << 1 << 3 + << ParsedSection(State::Intermediate, -15, 3, 0); +} + +void tst_QDateTimeParser::parseSection() +{ + QFETCH(QString, format); + QFETCH(QString, input); + QFETCH(int, sectionIndex); + QFETCH(int, offset); + QFETCH(QDTPUnitTestParser::ParsedSection, expected); + + QDTPUnitTestParser testParser; + + QVERIFY(testParser.parseFormat(format)); + QDateTime val(QDate(1900, 1, 1).startOfDay()); + + testParser.setText(input); + auto result = testParser.parseSection(val, sectionIndex, offset); + QCOMPARE(result, expected); +} + +void tst_QDateTimeParser::intermediateYear_data() +{ + QTest::addColumn<QString>("format"); + QTest::addColumn<QString>("input"); + QTest::addColumn<QDate>("expected"); + + QTest::newRow("short-year-begin") + << "yyyy_MM_dd" << "200_12_15" << QDate(200, 12, 15); + QTest::newRow("short-year-mid") + << "MM_yyyy_dd" << "12_200_15" << QDate(200, 12, 15); + QTest::newRow("short-year-end") + << "MM_dd_yyyy" << "12_15_200" << QDate(200, 12, 15); +} + +void tst_QDateTimeParser::intermediateYear() +{ + QFETCH(QString, format); + QFETCH(QString, input); + QFETCH(QDate, expected); + + QDateTimeParser testParser(QMetaType::QDateTime, QDateTimeParser::DateTimeEdit); + + QVERIFY(testParser.parseFormat(format)); + + // Indian/Cocos has a transition at the start of 1900, so it started this + // day at 00:02:20, throwing a time offset into QDTP. + QDateTime val(QDate(1900, 1, 1).startOfDay()); + const QDateTimeParser::StateNode tmp = testParser.parse(input, -1, val, false); + QCOMPARE(tmp.state, QDateTimeParser::Intermediate); + QCOMPARE(tmp.value.date(), expected); +} + +QTEST_APPLESS_MAIN(tst_QDateTimeParser) + +#include "tst_qdatetimeparser.moc" diff --git a/tests/auto/corelib/time/qtime/CMakeLists.txt b/tests/auto/corelib/time/qtime/CMakeLists.txt index df3adf3649..6fe2968107 100644 --- a/tests/auto/corelib/time/qtime/CMakeLists.txt +++ b/tests/auto/corelib/time/qtime/CMakeLists.txt @@ -1,15 +1,23 @@ -# Generated from qtime.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qtime Test: ##################################################################### -qt_add_test(tst_qtime +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qtime LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qtime SOURCES tst_qtime.cpp DEFINES QT_NO_FOREACH QT_NO_KEYWORDS - PUBLIC_LIBRARIES + LIBRARIES Qt::CorePrivate + Qt::TestPrivate ) diff --git a/tests/auto/corelib/time/qtime/qtime.pro b/tests/auto/corelib/time/qtime/qtime.pro deleted file mode 100644 index f9daacf5d1..0000000000 --- a/tests/auto/corelib/time/qtime/qtime.pro +++ /dev/null @@ -1,5 +0,0 @@ -CONFIG += testcase -TARGET = tst_qtime -QT = core-private testlib -SOURCES = tst_qtime.cpp -DEFINES += QT_NO_KEYWORDS QT_NO_FOREACH diff --git a/tests/auto/corelib/time/qtime/tst_qtime.cpp b/tests/auto/corelib/time/qtime/tst_qtime.cpp index eaa90971f2..c0fdb07115 100644 --- a/tests/auto/corelib/time/qtime/tst_qtime.cpp +++ b/tests/auto/corelib/time/qtime/tst_qtime.cpp @@ -1,33 +1,9 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <private/qglobal_p.h> -#include <QtTest/QtTest> +#include <private/qcomparisontesthelper_p.h> +#include <QTest> #include "qdatetime.h" #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) # include <locale.h> @@ -52,12 +28,11 @@ private Q_SLOTS: void addMSecs(); void addSecs_data(); void addSecs(); + void orderingCompiles(); void operator_eq_eq_data(); void operator_eq_eq(); - void operator_lt(); - void operator_gt(); - void operator_lt_eq(); - void operator_gt_eq(); + void ordering_data(); + void ordering(); #if QT_CONFIG(datestring) # if QT_CONFIG(datetimeparser) void fromStringFormat_data(); @@ -309,7 +284,7 @@ void tst_QTime::secsTo_data() QTest::newRow("disregard msec (1s)") << QTime(12, 30, 1, 500) << QTime(12, 30, 2, 400) << 1; QTest::newRow("disregard msec (0s)") << QTime(12, 30, 1, 500) << QTime(12, 30, 1, 900) << 0; QTest::newRow("disregard msec (-1s)") << QTime(12, 30, 2, 400) << QTime(12, 30, 1, 500) << -1; - QTest::newRow("disregard msec (0s)") << QTime(12, 30, 1, 900) << QTime(12, 30, 1, 500) << 0; + QTest::newRow("disregard msec (-0s)") << QTime(12, 30, 1, 900) << QTime(12, 30, 1, 500) << 0; } void tst_QTime::secsTo() @@ -345,6 +320,11 @@ void tst_QTime::msecsTo() QCOMPARE( t1.msecsTo( t2 ), delta ); } +void tst_QTime::orderingCompiles() +{ + QTestPrivate::testAllComparisonOperatorsCompile<QTime>(); +} + void tst_QTime::operator_eq_eq_data() { QTest::addColumn<QTime>("t1"); @@ -370,169 +350,42 @@ void tst_QTime::operator_eq_eq() QFETCH(QTime, t2); QFETCH(bool, expectEqual); - bool equal = t1 == t2; - QCOMPARE(equal, expectEqual); - bool notEqual = t1 != t2; - QCOMPARE(notEqual, !expectEqual); + QT_TEST_EQUALITY_OPS(t1, t2, expectEqual); - if (equal) + if (expectEqual) QVERIFY(qHash(t1) == qHash(t2)); } -void tst_QTime::operator_lt() -{ - QTime t1(0,0,0,0); - QTime t2(0,0,0,0); - QVERIFY( !(t1 < t2) ); - - t1 = QTime(12,34,56,20); - t2 = QTime(12,34,56,30); - QVERIFY( t1 < t2 ); - - t1 = QTime(13,34,46,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 < t2 ); - - t1 = QTime(13,24,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 < t2 ); - - t1 = QTime(12,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 < t2 ); - - t1 = QTime(14,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 < t2) ); - - t1 = QTime(13,44,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 < t2) ); - - t1 = QTime(13,34,56,20); - t2 = QTime(13,34,46,20); - QVERIFY( !(t1 < t2) ); - - t1 = QTime(13,44,56,30); - t2 = QTime(13,44,56,20); - QVERIFY( !(t1 < t2) ); -} - -void tst_QTime::operator_gt() -{ - QTime t1(0,0,0,0); - QTime t2(0,0,0,0); - QVERIFY( !(t1 > t2) ); - - t1 = QTime(12,34,56,20); - t2 = QTime(12,34,56,30); - QVERIFY( !(t1 > t2) ); - - t1 = QTime(13,34,46,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 > t2) ); - - t1 = QTime(13,24,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 > t2) ); - - t1 = QTime(12,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 > t2) ); - - t1 = QTime(14,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 > t2 ); - - t1 = QTime(13,44,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 > t2 ); - - t1 = QTime(13,34,56,20); - t2 = QTime(13,34,46,20); - QVERIFY( t1 > t2 ); - - t1 = QTime(13,44,56,30); - t2 = QTime(13,44,56,20); - QVERIFY( t1 > t2 ); -} - -void tst_QTime::operator_lt_eq() +void tst_QTime::ordering_data() { - QTime t1(0,0,0,0); - QTime t2(0,0,0,0); - QVERIFY( t1 <= t2 ); - - t1 = QTime(12,34,56,20); - t2 = QTime(12,34,56,30); - QVERIFY( t1 <= t2 ); - - t1 = QTime(13,34,46,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 <= t2 ); - - t1 = QTime(13,24,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 <= t2 ); - - t1 = QTime(12,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 <= t2 ); - - t1 = QTime(14,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 <= t2) ); - - t1 = QTime(13,44,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 <= t2) ); - - t1 = QTime(13,34,56,20); - t2 = QTime(13,34,46,20); - QVERIFY( !(t1 <= t2) ); - - t1 = QTime(13,44,56,30); - t2 = QTime(13,44,56,20); - QVERIFY( !(t1 <= t2) ); + QTest::addColumn<QTime>("left"); + QTest::addColumn<QTime>("right"); + QTest::addColumn<Qt::strong_ordering>("expectedOrdering"); + + auto generateRow = [](QTime t1, QTime t2, Qt::strong_ordering ordering) { + const QByteArray t1Str = t1.toString("hh:mm:ss.zz").toLatin1(); + const QByteArray t2Str = t2.toString("hh:mm:ss.zz").toLatin1(); + QTest::addRow("%s_vs_%s", t1Str.constData(), t2Str.constData()) << t1 << t2 << ordering; + }; + + generateRow(QTime(0, 0), QTime(0, 0), Qt::strong_ordering::equivalent); + generateRow(QTime(12, 34, 56, 20), QTime(12, 34, 56, 30), Qt::strong_ordering::less); + generateRow(QTime(13, 34, 46, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::less); + generateRow(QTime(13, 24, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::less); + generateRow(QTime(12, 34, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::less); + generateRow(QTime(14, 34, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::greater); + generateRow(QTime(13, 44, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::greater); + generateRow(QTime(13, 34, 56, 20), QTime(13, 34, 46, 20), Qt::strong_ordering::greater); + generateRow(QTime(13, 34, 56, 30), QTime(13, 34, 56, 20), Qt::strong_ordering::greater); } -void tst_QTime::operator_gt_eq() +void tst_QTime::ordering() { - QTime t1(0,0,0,0); - QTime t2(0,0,0,0); - QVERIFY( t1 >= t2 ); - - t1 = QTime(12,34,56,20); - t2 = QTime(12,34,56,30); - QVERIFY( !(t1 >= t2) ); - - t1 = QTime(13,34,46,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 >= t2) ); - - t1 = QTime(13,24,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 >= t2) ); - - t1 = QTime(12,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( !(t1 >= t2) ); + QFETCH(QTime, left); + QFETCH(QTime, right); + QFETCH(Qt::strong_ordering, expectedOrdering); - t1 = QTime(14,34,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 >= t2 ); - - t1 = QTime(13,44,56,20); - t2 = QTime(13,34,56,20); - QVERIFY( t1 >= t2 ); - - t1 = QTime(13,34,56,20); - t2 = QTime(13,34,46,20); - QVERIFY( t1 >= t2 ); - - t1 = QTime(13,44,56,30); - t2 = QTime(13,44,56,20); - QVERIFY( t1 >= t2 ); + QT_TEST_ALL_COMPARISON_OPS(left, right, expectedOrdering); } #if QT_CONFIG(datestring) @@ -553,11 +406,24 @@ void tst_QTime::fromStringFormat_data() QTest::newRow("data7") << QString("25") << QString("hh") << invalidTime(); QTest::newRow("data8") << QString("22pm") << QString("Hap") << QTime(22, 0, 0); QTest::newRow("data9") << QString("2221") << QString("hhhh") << invalidTime(); - QTest::newRow("data10") << QString("02:23PM") << QString("hh:mmAP") << QTime(14,23,0,0); - QTest::newRow("data11") << QString("02:23pm") << QString("hh:mmap") << QTime(14,23,0,0); - QTest::newRow("short-msecs-lt100") << QString("10:12:34:045") << QString("hh:m:ss:z") << QTime(10,12,34,45); - QTest::newRow("short-msecs-gt100") << QString("10:12:34:45") << QString("hh:m:ss:z") << QTime(10,12,34,450); - QTest::newRow("late") << QString("23:59:59.999") << QString("hh:mm:ss.z") << QTime(23, 59, 59, 999); + // Parsing of am/pm indicators is case-insensitive + QTest::newRow("pm-upper") << QString("02:23PM") << QString("hh:mmAp") << QTime(14, 23); + QTest::newRow("pm-lower") << QString("02:23pm") << QString("hh:mmaP") << QTime(14, 23); + QTest::newRow("pm-as-upper") << QString("02:23Pm") << QString("hh:mmAP") << QTime(14, 23); + QTest::newRow("pm-as-lower") << QString("02:23pM") << QString("hh:mmap") << QTime(14, 23); + // Millisecond parsing must interpolate 0s only at the end and notice them at the start. + QTest::newRow("short-msecs-lt100") + << QString("10:12:34:045") << QString("hh:m:ss:z") << QTime(10, 12, 34, 45); + QTest::newRow("short-msecs-gt100") + << QString("10:12:34:45") << QString("hh:m:ss:z") << QTime(10, 12, 34, 450); + QTest::newRow("late") + << QString("23:59:59.999") << QString("hh:mm:ss.z") << QTime(23, 59, 59, 999); + + // Test unicode handling. + QTest::newRow("emoji in format string 1") + << QString("12👍31:25.05") << QString("hh👍mm:ss.z") << QTime(12, 31, 25, 50); + QTest::newRow("emoji in format string 2") + << QString("💖12👍31🌈25😺05🚀") << QString("💖hh👍mm🌈ss😺z🚀") << QTime(12, 31, 25, 50); } void tst_QTime::fromStringFormat() @@ -577,11 +443,17 @@ void tst_QTime::fromStringDateFormat_data() QTest::addColumn<Qt::DateFormat>("format"); QTest::addColumn<QTime>("expected"); - QTest::newRow("TextDate - data0") << QString("00:00:00") << Qt::TextDate << QTime(0,0,0,0); - QTest::newRow("TextDate - data1") << QString("10:12:34") << Qt::TextDate << QTime(10,12,34,0); - QTest::newRow("TextDate - data2") << QString("19:03:54.998601") << Qt::TextDate << QTime(19, 3, 54, 999); - QTest::newRow("TextDate - data3") << QString("19:03:54.999601") << Qt::TextDate << QTime(19, 3, 54, 999); - QTest::newRow("TextDate - data4") << QString("10:12") << Qt::TextDate << QTime(10, 12, 0, 0); + QTest::newRow("TextDate - zero") << QString("00:00:00") << Qt::TextDate << QTime(0, 0); + QTest::newRow("TextDate - ordinary") + << QString("10:12:34") << Qt::TextDate << QTime(10, 12, 34); + QTest::newRow("TextDate - milli-max") + << QString("19:03:54.998601") << Qt::TextDate << QTime(19, 3, 54, 999); + QTest::newRow("TextDate - milli-wrap") + << QString("19:03:54.999601") << Qt::TextDate << QTime(19, 3, 55); + QTest::newRow("TextDate - no-secs") + << QString("10:12") << Qt::TextDate << QTime(10, 12); + QTest::newRow("TextDate - midnight-nowrap") + << QString("23:59:59.9999") << Qt::TextDate << QTime(23, 59, 59, 999); QTest::newRow("TextDate - invalid, minutes") << QString::fromLatin1("23:XX:00") << Qt::TextDate << invalidTime(); QTest::newRow("TextDate - invalid, minute fraction") << QString::fromLatin1("23:00.123456") << Qt::TextDate << invalidTime(); QTest::newRow("TextDate - invalid, seconds") << QString::fromLatin1("23:00:XX") << Qt::TextDate << invalidTime(); @@ -591,6 +463,8 @@ void tst_QTime::fromStringDateFormat_data() QTest::newRow("IsoDate - valid, start of day, omit seconds") << QString::fromLatin1("00:00") << Qt::ISODate << QTime(0, 0, 0); QTest::newRow("IsoDate - valid, omit seconds") << QString::fromLatin1("22:21") << Qt::ISODate << QTime(22, 21, 0); + QTest::newRow("IsoDate - minute fraction") // 60 * 0.816666 = 48.99996 should round up: + << QString::fromLatin1("22:21.816666") << Qt::ISODate << QTime(22, 21, 49); QTest::newRow("IsoDate - valid, omit seconds (2)") << QString::fromLatin1("23:59") << Qt::ISODate << QTime(23, 59, 0); QTest::newRow("IsoDate - valid, end of day") << QString::fromLatin1("23:59:59") << Qt::ISODate << QTime(23, 59, 59); @@ -605,12 +479,18 @@ void tst_QTime::fromStringDateFormat_data() QTest::newRow("IsoDate - invalid, seconds") << QString::fromLatin1("23:00:XX") << Qt::ISODate << invalidTime(); QTest::newRow("IsoDate - invalid, milliseconds") << QString::fromLatin1("23:01:01:XXXX") << Qt::ISODate << invalidTime(); - QTest::newRow("IsoDate - data0") << QString("00:00:00") << Qt::ISODate << QTime(0,0,0,0); - QTest::newRow("IsoDate - data1") << QString("10:12:34") << Qt::ISODate << QTime(10,12,34,0); - QTest::newRow("IsoDate - data2") << QString("19:03:54.998601") << Qt::ISODate << QTime(19, 3, 54, 999); - QTest::newRow("IsoDate - data3") << QString("19:03:54.999601") << Qt::ISODate << QTime(19, 3, 54, 999); - QTest::newRow("IsoDate - midnight 24") << QString("24:00:00") << Qt::ISODate << QTime(0, 0, 0, 0); - QTest::newRow("IsoDate - minute fraction midnight") << QString("24:00,0") << Qt::ISODate << QTime(0, 0, 0, 0); + QTest::newRow("IsoDate - zero") << QString("00:00:00") << Qt::ISODate << QTime(0, 0); + QTest::newRow("IsoDate - ordinary") << QString("10:12:34") << Qt::ISODate << QTime(10, 12, 34); + QTest::newRow("IsoDate - milli-max") + << QString("19:03:54.998601") << Qt::ISODate << QTime(19, 3, 54, 999); + QTest::newRow("IsoDate - milli-wrap") + << QString("19:03:54.999601") << Qt::ISODate << QTime(19, 3, 55); + QTest::newRow("IsoDate - midnight-nowrap") + << QString("23:59:59.9999") << Qt::ISODate << QTime(23, 59, 59, 999); + QTest::newRow("IsoDate - midnight 24") + << QString("24:00:00") << Qt::ISODate << QTime(0, 0); + QTest::newRow("IsoDate - minute fraction midnight") + << QString("24:00,0") << Qt::ISODate << QTime(0, 0); // Test Qt::RFC2822Date format (RFC 2822). QTest::newRow("RFC 2822") << QString::fromLatin1("13 Feb 1987 13:24:51 +0100") @@ -631,6 +511,8 @@ void tst_QTime::fromStringDateFormat_data() << Qt::RFC2822Date << invalidTime(); QTest::newRow("RFC 2822 with day date only") << QString::fromLatin1("Fri, 01 Nov 2002") << Qt::RFC2822Date << invalidTime(); + QTest::newRow("RFC 2822 malformed time") + << QString::fromLatin1("01 Nov 2002 0:") << Qt::RFC2822Date << QTime(); // Test invalid month, day, year are ignored: QTest::newRow("RFC 2822 invalid month name") << QString::fromLatin1("13 Fev 1987 13:24:51 +0100") << Qt::RFC2822Date << QTime(13, 24, 51); @@ -658,7 +540,7 @@ void tst_QTime::fromStringDateFormat_data() << Qt::RFC2822Date << invalidTime(); // The common date text used by the "invalid character" tests, just to be // sure *it's* not what's invalid: - QTest::newRow("RFC 2822 invalid character at end") + QTest::newRow("RFC 2822 (not invalid)") << QString::fromLatin1("01 Jan 2012 08:00:00 +0100") << Qt::RFC2822Date << QTime(8, 0, 0); @@ -689,7 +571,7 @@ void tst_QTime::fromStringDateFormat_data() << Qt::RFC2822Date << invalidTime(); // The common date text used by the "invalid character" tests, just to be // sure *it's* not what's invalid: - QTest::newRow("RFC 850 and 1036 invalid character at end") + QTest::newRow("RFC 850 and 1036 no invalid character") << QString::fromLatin1("Sun Jan 01 08:00:00 2012 +0100") << Qt::RFC2822Date << QTime(8, 0, 0); @@ -748,6 +630,7 @@ void tst_QTime::toStringFormat_data() QTest::newRow( "am-pm" ) << QTime(10,12,34,45) << QString("hh:ss ap") << QString("10:34 am"); QTest::newRow( "AM-PM" ) << QTime(22,12,34,45) << QString("hh:zzz AP") << QString("10:045 PM"); QTest::newRow( "invalid" ) << QTime(230,230,230,230) << QString("hh:mm:ss") << QString(); + QTest::newRow( "empty format" ) << QTime(4,5,6,6) << QString("") << QString(""); } void tst_QTime::toStringFormat() diff --git a/tests/auto/corelib/time/qtimezone/BLACKLIST b/tests/auto/corelib/time/qtimezone/BLACKLIST deleted file mode 100644 index b820bab3d9..0000000000 --- a/tests/auto/corelib/time/qtimezone/BLACKLIST +++ /dev/null @@ -1,175 +0,0 @@ -# QTBUG-69122 -[dataStreamTest] -android - -# QTBUG-69129 -[specificTransition] -android - -# QTBUG-69131 -[transitionEachZone:America/Cancun@2010] -android -[transitionEachZone:America/Eirunepe@2010] -android -[transitionEachZone:America/Montevideo@2010] -android -[transitionEachZone:America/Porto_Acre@2010] -android -[transitionEachZone:America/Rio_Branco@2010] -android -[transitionEachZone:Asia/Anadyr@2010] -android -[transitionEachZone:Asia/Chita@2010] -android -[transitionEachZone:Asia/Kamchatka@2010] -android -[transitionEachZone:Asia/Khandyga@2010] -android -[transitionEachZone:Asia/Magadan@2010] -android -[transitionEachZone:Asia/Novokuznetsk@2010] -android -[transitionEachZone:Asia/Pyongyang@2010] -android -[transitionEachZone:Asia/Ust-Nera@2010] -android -[transitionEachZone:Asia/Yerevan@2010] -android -[transitionEachZone:Europe/Kaliningrad@2010] -android -[transitionEachZone:Europe/Minsk@2010] -android -[transitionEachZone:Europe/Moscow@2010] -android -[transitionEachZone:Europe/Samara@2010] -android -[transitionEachZone:Europe/Simferopol@2010] -android -[transitionEachZone:Europe/Volgograd@2010] -android -[transitionEachZone:W-SU@2010] -android -[transitionEachZone:Africa/Bissau@1970] -android -[transitionEachZone:Africa/Juba@1970] -android -[transitionEachZone:Africa/Khartoum@1970] -android -[transitionEachZone:America/Metlakatla@1970] -android -[transitionEachZone:America/Montevideo@1970] -android -[transitionEachZone:America/Paramaribo@1970] -android -[transitionEachZone:America/Santarem@1970] -android -[transitionEachZone:America/Santo_Domingo@1970] -android -[transitionEachZone:Asia/Anadyr@1970] -android -[transitionEachZone:Asia/Bahrain@1970] -android -[transitionEachZone:Asia/Chita@1970] -android -[transitionEachZone:Asia/Choibalsan@1970] -android -[transitionEachZone:Asia/Dushanbe@1970] -android -[transitionEachZone:Asia/Ho_Chi_Minh@1970] -android -[transitionEachZone:Asia/Hovd@1970] -android -[transitionEachZone:Asia/Kathmandu@1970] -android -[transitionEachZone:Asia/Katmandu@1970] -android -[transitionEachZone:Asia/Kuala_Lumpur@1970] -android -[transitionEachZone:Asia/Magadan@1970] -android -[transitionEachZone:Asia/Novosibirsk@1970] -android -[transitionEachZone:Asia/Pontianak@1970] -android -[transitionEachZone:Asia/Pyongyang@1970] -android -[transitionEachZone:Asia/Qatar@1970] -android -[transitionEachZone:Asia/Qyzylorda@1970] -android -[transitionEachZone:Asia/Saigon@1970] -android -[transitionEachZone:Asia/Sakhalin@1970] -android -[transitionEachZone:Asia/Singapore@1970] -android -[transitionEachZone:Asia/Tashkent@1970] -android -[transitionEachZone:Asia/Thimbu@1970] -android -[transitionEachZone:Asia/Thimphu@1970] -android -[transitionEachZone:Asia/Ulaanbaatar@1970] -android -[transitionEachZone:Asia/Ulan_Bator@1970] -android -[transitionEachZone:Asia/Ust-Nera@1970] -android -[transitionEachZone:Atlantic/Cape_Verde@1970] -android -[transitionEachZone:Chile/EasterIsland@1970] -android -[transitionEachZone:Europe/Kaliningrad@1970] -android -[transitionEachZone:Pacific/Bougainville@1970] -android -[transitionEachZone:Pacific/Easter@1970] -android -[transitionEachZone:Pacific/Enderbury@1970] -android -[transitionEachZone:Pacific/Galapagos@1970] -android -[transitionEachZone:Pacific/Kiritimati@1970] -android -[transitionEachZone:Pacific/Kosrae@1970] -android -[transitionEachZone:Pacific/Kwajalein@1970] -android -[transitionEachZone:Pacific/Nauru@1970] -android -[transitionEachZone:Pacific/Niue@1970] -android -[transitionEachZone:Singapore@1970] -android -[transitionEachZone:Brazil/Acre@2010] -android -[transitionEachZone:Pacific/Bougainville@2010] -android -[transitionEachZone:Africa/Algiers@1970] -android -[transitionEachZone:Africa/Monrovia@1970] -android -[transitionEachZone:Kwajalein@1970] -android -[transitionEachZone:Indian/Chagos@1970] -android -[transitionEachZone:Europe/Volgograd@1970] -android -[transitionEachZone:Atlantic/Stanley@1970] -android -[transitionEachZone:Antarctica/Mawson@1970] -android -[transitionEachZone:America/Swift_Current@1970] -android -[transitionEachZone:America/Guyana@1970] -android -[transitionEachZone:America/Grand_Turk@1970] -android -[transitionEachZone:America/Dawson_Creek@1970] -android -[transitionEachZone:America/Cancun@1970] -android -[transitionEachZone:America/Caracas@1970] -android -[transitionEachZone:America/Danmarkshavn@1970] -android diff --git a/tests/auto/corelib/time/qtimezone/CMakeLists.txt b/tests/auto/corelib/time/qtimezone/CMakeLists.txt index b97b2f9fd1..612bab0db5 100644 --- a/tests/auto/corelib/time/qtimezone/CMakeLists.txt +++ b/tests/auto/corelib/time/qtimezone/CMakeLists.txt @@ -1,30 +1,38 @@ -# Generated from qtimezone.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qtimezone Test: ##################################################################### -qt_add_test(tst_qtimezone +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qtimezone LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qtimezone SOURCES tst_qtimezone.cpp DEFINES QT_NO_FOREACH QT_NO_KEYWORDS - PUBLIC_LIBRARIES + LIBRARIES Qt::CorePrivate + Qt::TestPrivate ) ## Scopes: ##################################################################### -qt_extend_target(tst_qtimezone CONDITION QT_FEATURE_icu +qt_internal_extend_target(tst_qtimezone CONDITION QT_FEATURE_icu LIBRARIES ICU::i18n ICU::uc ICU::data ) -qt_extend_target(tst_qtimezone CONDITION APPLE +qt_internal_extend_target(tst_qtimezone CONDITION APPLE SOURCES tst_qtimezone_darwin.mm - PUBLIC_LIBRARIES + LIBRARIES ${FWFoundation} ) diff --git a/tests/auto/corelib/time/qtimezone/qtimezone.pro b/tests/auto/corelib/time/qtimezone/qtimezone.pro deleted file mode 100644 index 24d4b776be..0000000000 --- a/tests/auto/corelib/time/qtimezone/qtimezone.pro +++ /dev/null @@ -1,11 +0,0 @@ -CONFIG += testcase -TARGET = tst_qtimezone -QT = core-private testlib -SOURCES = tst_qtimezone.cpp -DEFINES += QT_NO_KEYWORDS QT_NO_FOREACH - -qtConfig(icu): QMAKE_USE_PRIVATE += icu -darwin { - OBJECTIVE_SOURCES += tst_qtimezone_darwin.mm - LIBS += -framework Foundation -} diff --git a/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp b/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp index 294e6e8ed4..e71f32a3ca 100644 --- a/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp +++ b/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp @@ -1,57 +1,48 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include <QtTest/QtTest> +// Copyright (C) 2022 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QTest> #include <qtimezone.h> #include <private/qtimezoneprivate_p.h> +#include <private/qcomparisontesthelper_p.h> + #include <qlocale.h> +#include <qscopeguard.h> + +#if defined(Q_OS_WIN) +#include <QOperatingSystemVersion> +#endif #if defined(Q_OS_WIN) && !QT_CONFIG(icu) # define USING_WIN_TZ #endif +using namespace Qt::StringLiterals; + class tst_QTimeZone : public QObject { Q_OBJECT -public: - tst_QTimeZone(); - private Q_SLOTS: // Public class default system tests void createTest(); void nullTest(); - void systemZone(); + void assign(); + void compareCompiles(); + void compare_data(); + void compare(); + void timespec(); + void offset(); void dataStreamTest(); +#if QT_CONFIG(timezone) + void asBackendZone(); + void systemZone(); void isTimeZoneIdAvailable(); void availableTimeZoneIds(); void utcOffsetId_data(); void utcOffsetId(); + void aliasMatches_data(); + void aliasMatches(); void specificTransition_data(); void specificTransition(); void transitionEachZone_data(); @@ -63,6 +54,7 @@ private Q_SLOTS: void isValidId_data(); void isValidId(); void serialize(); + void malformed(); // Backend tests void utcTest(); void icuTest(); @@ -70,35 +62,35 @@ private Q_SLOTS: void macTest(); void darwinTypes(); void winTest(); + void localeSpecificDisplayName_data(); + void localeSpecificDisplayName(); + void stdCompatibility_data(); + void stdCompatibility(); +#endif // timezone backends private: void printTimeZone(const QTimeZone &tz); -#ifdef QT_BUILD_INTERNAL +#if defined(QT_BUILD_INTERNAL) && QT_CONFIG(timezone) // Generic tests of privates, called by implementation-specific private tests: void testCetPrivate(const QTimeZonePrivate &tzp); void testEpochTranPrivate(const QTimeZonePrivate &tzp); -#endif // QT_BUILD_INTERNAL - const bool debug; -}; - -tst_QTimeZone::tst_QTimeZone() +#endif // QT_BUILD_INTERNAL && timezone backends // Set to true to print debug output, test Display Names and run long stress tests - : debug(false) -{ -} + static constexpr bool debug = false; +}; void tst_QTimeZone::printTimeZone(const QTimeZone &tz) { QDateTime now = QDateTime::currentDateTime(); - QDateTime jan = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime jun = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC); + QDateTime jan = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC); + QDateTime jun = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC); qDebug() << ""; qDebug() << "Time Zone = " << tz; qDebug() << ""; qDebug() << "Is Valid = " << tz.isValid(); qDebug() << ""; qDebug() << "Zone ID = " << tz.id(); - qDebug() << "Country = " << QLocale::countryToString(tz.country()); + qDebug() << "Territory = " << QLocale::territoryToString(tz.territory()); qDebug() << "Comment = " << tz.comment(); qDebug() << ""; qDebug() << "Locale = " << QLocale().name(); @@ -155,31 +147,29 @@ void tst_QTimeZone::printTimeZone(const QTimeZone &tz) void tst_QTimeZone::createTest() { - QTimeZone tz("Pacific/Auckland"); + const QTimeZone tz("Pacific/Auckland"); if (debug) printTimeZone(tz); // If the tz is not valid then skip as is probably using the UTC backend which is tested later if (!tz.isValid()) - return; + QSKIP("System lacks zone used for test"); // This returns. - // Validity tests - QCOMPARE(tz.isValid(), true); + QCOMPARE(tz.id(), "Pacific/Auckland"); + // Comparison tests: + const QTimeZone same("Pacific/Auckland"); + QCOMPARE((tz == same), true); + QCOMPARE((tz != same), false); + const QTimeZone other("Australia/Sydney"); + QCOMPARE((tz == other), false); + QCOMPARE((tz != other), true); - // Comparison tests - QTimeZone tz2("Pacific/Auckland"); - QTimeZone tz3("Australia/Sydney"); - QCOMPARE((tz == tz2), true); - QCOMPARE((tz != tz2), false); - QCOMPARE((tz == tz3), false); - QCOMPARE((tz != tz3), true); + QCOMPARE(tz.territory(), QLocale::NewZealand); - QCOMPARE(tz.country(), QLocale::NewZealand); - - QDateTime jan = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime jun = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime janPrev = QDateTime(QDate(2011, 1, 1), QTime(0, 0, 0), Qt::UTC); + QDateTime jan = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC); + QDateTime jun = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC); + QDateTime janPrev = QDateTime(QDate(2011, 1, 1), QTime(0, 0), QTimeZone::UTC); QCOMPARE(tz.offsetFromUtc(jan), 13 * 3600); QCOMPARE(tz.offsetFromUtc(jun), 12 * 3600); @@ -199,7 +189,8 @@ void tst_QTimeZone::createTest() QTimeZone::OffsetData tran = tz.nextTransition(jan); // 2012-04-01 03:00 NZDT, +13 -> +12 QCOMPARE(tran.atUtc, - QDateTime(QDate(2012, 4, 1), QTime(3, 0), Qt::OffsetFromUTC, 13 * 3600)); + QDateTime(QDate(2012, 4, 1), QTime(3, 0), + QTimeZone::fromSecondsAheadOfUtc(13 * 3600))); QCOMPARE(tran.offsetFromUtc, 12 * 3600); QCOMPARE(tran.standardTimeOffset, 12 * 3600); QCOMPARE(tran.daylightTimeOffset, 0); @@ -207,7 +198,8 @@ void tst_QTimeZone::createTest() tran = tz.nextTransition(jun); // 2012-09-30 02:00 NZST, +12 -> +13 QCOMPARE(tran.atUtc, - QDateTime(QDate(2012, 9, 30), QTime(2, 0), Qt::OffsetFromUTC, 12 * 3600)); + QDateTime(QDate(2012, 9, 30), QTime(2, 0), + QTimeZone::fromSecondsAheadOfUtc(12 * 3600))); QCOMPARE(tran.offsetFromUtc, 13 * 3600); QCOMPARE(tran.standardTimeOffset, 12 * 3600); QCOMPARE(tran.daylightTimeOffset, 3600); @@ -215,7 +207,8 @@ void tst_QTimeZone::createTest() tran = tz.previousTransition(jan); // 2011-09-25 02:00 NZST, +12 -> +13 QCOMPARE(tran.atUtc, - QDateTime(QDate(2011, 9, 25), QTime(2, 0), Qt::OffsetFromUTC, 12 * 3600)); + QDateTime(QDate(2011, 9, 25), QTime(2, 0), + QTimeZone::fromSecondsAheadOfUtc(12 * 3600))); QCOMPARE(tran.offsetFromUtc, 13 * 3600); QCOMPARE(tran.standardTimeOffset, 12 * 3600); QCOMPARE(tran.daylightTimeOffset, 3600); @@ -223,25 +216,26 @@ void tst_QTimeZone::createTest() tran = tz.previousTransition(jun); // 2012-04-01 03:00 NZDT, +13 -> +12 (again) QCOMPARE(tran.atUtc, - QDateTime(QDate(2012, 4, 1), QTime(3, 0), Qt::OffsetFromUTC, 13 * 3600)); + QDateTime(QDate(2012, 4, 1), QTime(3, 0), + QTimeZone::fromSecondsAheadOfUtc(13 * 3600))); QCOMPARE(tran.offsetFromUtc, 12 * 3600); QCOMPARE(tran.standardTimeOffset, 12 * 3600); QCOMPARE(tran.daylightTimeOffset, 0); QTimeZone::OffsetDataList expected; - tran.atUtc = QDateTime(QDate(2011, 4, 3), QTime(2, 0), Qt::OffsetFromUTC, 13 * 3600); + // Reuse 2012's fall-back data for 2011-04-03: + tran.atUtc = QDateTime(QDate(2011, 4, 3), QTime(3, 0), + QTimeZone::fromSecondsAheadOfUtc(13 * 3600)); + expected << tran; + // 2011's spring-forward: + tran.atUtc = QDateTime(QDate(2011, 9, 25), QTime(2, 0), + QTimeZone::fromSecondsAheadOfUtc(12 * 3600)); tran.offsetFromUtc = 13 * 3600; - tran.standardTimeOffset = 12 * 3600; tran.daylightTimeOffset = 3600; expected << tran; - tran.atUtc = QDateTime(QDate(2011, 9, 25), QTime(2, 0), Qt::OffsetFromUTC, 12 * 3600); - tran.offsetFromUtc = 12 * 3600; - tran.standardTimeOffset = 12 * 3600; - tran.daylightTimeOffset = 0; - expected << tran; QTimeZone::OffsetDataList result = tz.transitions(janPrev, jan); - QCOMPARE(result.count(), expected.count()); - for (int i = 0; i > expected.count(); ++i) { + QCOMPARE(result.size(), expected.size()); + for (int i = 0; i < expected.size(); ++i) { QCOMPARE(result.at(i).atUtc, expected.at(i).atUtc); QCOMPARE(result.at(i).offsetFromUtc, expected.at(i).offsetFromUtc); QCOMPARE(result.at(i).standardTimeOffset, expected.at(i).standardTimeOffset); @@ -274,12 +268,12 @@ void tst_QTimeZone::nullTest() QCOMPARE(utc.isValid(), false); QCOMPARE(nullTz1.id(), QByteArray()); - QCOMPARE(nullTz1.country(), QLocale::AnyCountry); + QCOMPARE(nullTz1.territory(), QLocale::AnyTerritory); QCOMPARE(nullTz1.comment(), QString()); - QDateTime jan = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime jun = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime janPrev = QDateTime(QDate(2011, 1, 1), QTime(0, 0, 0), Qt::UTC); + QDateTime jan = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC); + QDateTime jun = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC); + QDateTime janPrev = QDateTime(QDate(2011, 1, 1), QTime(0, 0), QTimeZone::UTC); QCOMPARE(nullTz1.abbreviation(jan), QString()); QCOMPARE(nullTz1.displayName(jan), QString()); @@ -299,36 +293,178 @@ void tst_QTimeZone::nullTest() QCOMPARE(nullTz1.isDaylightTime(jun), false); QTimeZone::OffsetData data = nullTz1.offsetData(jan); + constexpr auto invalidOffset = std::numeric_limits<int>::min(); QCOMPARE(data.atUtc, QDateTime()); - QCOMPARE(data.offsetFromUtc, std::numeric_limits<int>::min()); - QCOMPARE(data.standardTimeOffset, std::numeric_limits<int>::min()); - QCOMPARE(data.daylightTimeOffset, std::numeric_limits<int>::min()); + QCOMPARE(data.offsetFromUtc, invalidOffset); + QCOMPARE(data.standardTimeOffset, invalidOffset); + QCOMPARE(data.daylightTimeOffset, invalidOffset); QCOMPARE(nullTz1.hasTransitions(), false); data = nullTz1.nextTransition(jan); QCOMPARE(data.atUtc, QDateTime()); - QCOMPARE(data.offsetFromUtc, std::numeric_limits<int>::min()); - QCOMPARE(data.standardTimeOffset, std::numeric_limits<int>::min()); - QCOMPARE(data.daylightTimeOffset, std::numeric_limits<int>::min()); + QCOMPARE(data.offsetFromUtc, invalidOffset); + QCOMPARE(data.standardTimeOffset, invalidOffset); + QCOMPARE(data.daylightTimeOffset, invalidOffset); data = nullTz1.previousTransition(jan); QCOMPARE(data.atUtc, QDateTime()); - QCOMPARE(data.offsetFromUtc, std::numeric_limits<int>::min()); - QCOMPARE(data.standardTimeOffset, std::numeric_limits<int>::min()); - QCOMPARE(data.daylightTimeOffset, std::numeric_limits<int>::min()); + QCOMPARE(data.offsetFromUtc, invalidOffset); + QCOMPARE(data.standardTimeOffset, invalidOffset); + QCOMPARE(data.daylightTimeOffset, invalidOffset); } -void tst_QTimeZone::systemZone() +void tst_QTimeZone::assign() { - const QTimeZone zone = QTimeZone::systemTimeZone(); - QVERIFY(zone.isValid()); - QCOMPARE(zone.id(), QTimeZone::systemTimeZoneId()); - QCOMPARE(zone, QTimeZone(QTimeZone::systemTimeZoneId())); + QTimeZone assignee; + QCOMPARE(assignee.timeSpec(), Qt::TimeZone); + assignee = QTimeZone(); + QCOMPARE(assignee.timeSpec(), Qt::TimeZone); + assignee = QTimeZone::UTC; + QCOMPARE(assignee.timeSpec(), Qt::UTC); + assignee = QTimeZone::LocalTime; + QCOMPARE(assignee.timeSpec(), Qt::LocalTime); + assignee = QTimeZone(); + QCOMPARE(assignee.timeSpec(), Qt::TimeZone); + assignee = QTimeZone::fromSecondsAheadOfUtc(1); + QCOMPARE(assignee.timeSpec(), Qt::OffsetFromUTC); + assignee = QTimeZone::fromSecondsAheadOfUtc(0); + QCOMPARE(assignee.timeSpec(), Qt::UTC); +#if QT_CONFIG(timezone) + { + const QTimeZone cet("Europe/Oslo"); + assignee = cet; + QCOMPARE(assignee.timeSpec(), Qt::TimeZone); + } +#endif +} + +void tst_QTimeZone::compareCompiles() +{ + QTestPrivate::testEqualityOperatorsCompile<QTimeZone>(); +} + +void tst_QTimeZone::compare_data() +{ + QTest::addColumn<QTimeZone>("left"); + QTest::addColumn<QTimeZone>("right"); + QTest::addColumn<bool>("expectedEqual"); + + const QTimeZone local; + const QTimeZone utc(QTimeZone::UTC); + const auto secondEast = QTimeZone::fromSecondsAheadOfUtc(1); + const auto zeroOffset = QTimeZone::fromSecondsAheadOfUtc(0); + const auto durationEast = QTimeZone::fromDurationAheadOfUtc(std::chrono::seconds{1}); + + QTest::newRow("local vs default-constructed") << local << QTimeZone() << true; + QTest::newRow("local vs UTC") << local << utc << false; + QTest::newRow("local vs secondEast") << local << secondEast << false; + QTest::newRow("secondEast vs UTC") << secondEast << utc << false; + QTest::newRow("UTC vs zeroOffset") << utc << zeroOffset << true; + QTest::newRow("secondEast vs durationEast") << secondEast << durationEast << true; +} + +void tst_QTimeZone::compare() +{ + QFETCH(QTimeZone, left); + QFETCH(QTimeZone, right); + QFETCH(bool, expectedEqual); + + QT_TEST_EQUALITY_OPS(left, right, expectedEqual); +} + +void tst_QTimeZone::timespec() +{ + using namespace std::chrono_literals; + QCOMPARE(QTimeZone().timeSpec(), Qt::TimeZone); + QCOMPARE(QTimeZone(QTimeZone::UTC).timeSpec(), Qt::UTC); + QCOMPARE(QTimeZone(QTimeZone::LocalTime).timeSpec(), Qt::LocalTime); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(0).timeSpec(), Qt::UTC); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(0s).timeSpec(), Qt::UTC); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(0min).timeSpec(), Qt::UTC); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(0h).timeSpec(), Qt::UTC); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(1).timeSpec(), Qt::OffsetFromUTC); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(-1).timeSpec(), Qt::OffsetFromUTC); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(36000).timeSpec(), Qt::OffsetFromUTC); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(-36000).timeSpec(), Qt::OffsetFromUTC); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(3h - 20min +17s).timeSpec(), Qt::OffsetFromUTC); + { + const QTimeZone zone; + QCOMPARE(zone.timeSpec(), Qt::TimeZone); + } + { + const QTimeZone zone = { QTimeZone::UTC }; + QCOMPARE(zone.timeSpec(), Qt::UTC); + } + { + const QTimeZone zone = { QTimeZone::LocalTime }; + QCOMPARE(zone.timeSpec(), Qt::LocalTime); + } + { + const auto zone = QTimeZone::fromSecondsAheadOfUtc(0); + QCOMPARE(zone.timeSpec(), Qt::UTC); + } + { + const auto zone = QTimeZone::fromDurationAheadOfUtc(0s); + QCOMPARE(zone.timeSpec(), Qt::UTC); + } + { + const auto zone = QTimeZone::fromSecondsAheadOfUtc(1); + QCOMPARE(zone.timeSpec(), Qt::OffsetFromUTC); + } + { + const auto zone = QTimeZone::fromDurationAheadOfUtc(1s); + QCOMPARE(zone.timeSpec(), Qt::OffsetFromUTC); + } +#if QT_CONFIG(timezone) + QCOMPARE(QTimeZone("Europe/Oslo").timeSpec(), Qt::TimeZone); +#endif +} + +void tst_QTimeZone::offset() +{ + QCOMPARE(QTimeZone().fixedSecondsAheadOfUtc(), 0); + QCOMPARE(QTimeZone(QTimeZone::UTC).fixedSecondsAheadOfUtc(), 0); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(0).fixedSecondsAheadOfUtc(), 0); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(std::chrono::seconds{}).fixedSecondsAheadOfUtc(), 0); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(std::chrono::minutes{}).fixedSecondsAheadOfUtc(), 0); + QCOMPARE(QTimeZone::fromDurationAheadOfUtc(std::chrono::hours{}).fixedSecondsAheadOfUtc(), 0); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(1).fixedSecondsAheadOfUtc(), 1); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(-1).fixedSecondsAheadOfUtc(), -1); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(36000).fixedSecondsAheadOfUtc(), 36000); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(-36000).fixedSecondsAheadOfUtc(), -36000); + { + const QTimeZone zone; + QCOMPARE(zone.fixedSecondsAheadOfUtc(), 0); + } + { + const QTimeZone zone = { QTimeZone::UTC }; + QCOMPARE(zone.fixedSecondsAheadOfUtc(), 0); + } + { + const auto zone = QTimeZone::fromSecondsAheadOfUtc(0); + QCOMPARE(zone.fixedSecondsAheadOfUtc(), 0); + } + { + const auto zone = QTimeZone::fromDurationAheadOfUtc(std::chrono::seconds{}); + QCOMPARE(zone.fixedSecondsAheadOfUtc(), 0); + } + { + const auto zone = QTimeZone::fromSecondsAheadOfUtc(1); + QCOMPARE(zone.fixedSecondsAheadOfUtc(), 1); + } + { + const auto zone = QTimeZone::fromDurationAheadOfUtc(std::chrono::seconds{1}); + QCOMPARE(zone.fixedSecondsAheadOfUtc(), 1); + } +#if QT_CONFIG(timezone) + QCOMPARE(QTimeZone("Europe/Oslo").fixedSecondsAheadOfUtc(), 0); +#endif } void tst_QTimeZone::dataStreamTest() { +#ifndef QT_NO_DATASTREAM // Test the OffsetFromUtc backend serialization. First with a custom timezone: QTimeZone tz1("QST", 123456, "Qt Standard Time", "QST", QLocale::Norway, "Qt Testing"); QByteArray tmp; @@ -343,7 +479,7 @@ void tst_QTimeZone::dataStreamTest() } QCOMPARE(tz2.id(), QByteArray("QST")); QCOMPARE(tz2.comment(), QString("Qt Testing")); - QCOMPARE(tz2.country(), QLocale::Norway); + QCOMPARE(tz2.territory(), QLocale::Norway); QCOMPARE(tz2.abbreviation(QDateTime::currentDateTime()), QString("QST")); QCOMPARE(tz2.displayName(QTimeZone::StandardTime, QTimeZone::LongName, QLocale()), QString("Qt Standard Time")); @@ -382,14 +518,63 @@ void tst_QTimeZone::dataStreamTest() ds >> tz2; } QCOMPARE(tz2.id(), tz1.id()); +#endif +} + +#if QT_CONFIG(timezone) +void tst_QTimeZone::asBackendZone() +{ + QCOMPARE(QTimeZone(QTimeZone::LocalTime).asBackendZone(), QTimeZone::systemTimeZone()); + QCOMPARE(QTimeZone(QTimeZone::UTC).asBackendZone(), QTimeZone::utc()); + QCOMPARE(QTimeZone::fromSecondsAheadOfUtc(-300).asBackendZone(), QTimeZone(-300)); + QTimeZone cet("Europe/Oslo"); + QCOMPARE(cet.asBackendZone(), cet); +} + +void tst_QTimeZone::systemZone() +{ + const QTimeZone zone = QTimeZone::systemTimeZone(); + QVERIFY2(zone.isValid(), + "Invalid system zone setting, tests are doomed on misconfigured system."); + // This may fail on Windows if CLDR data doesn't map system MS ID to IANA ID: + QCOMPARE(zone.id(), QTimeZone::systemTimeZoneId()); + QCOMPARE(zone, QTimeZone(QTimeZone::systemTimeZoneId())); + // Check it behaves the same as local-time: + const QDate dates[] = { + QDate::fromJulianDay(0), // far in the distant past (LMT) + QDate(1625, 6, 8), // Before time-zones (date of Cassini's birth) + QDate(1901, 12, 13), // Last day before 32-bit time_t's range + QDate(1969, 12, 31), // Last day before the epoch + QDate(1970, 0, 0), // Start of epoch + QDate(2000, 2, 29), // An anomalous leap day + QDate(2038, 1, 20) // First day after 32-bit time_t's range + }; + for (const auto &date : dates) + QCOMPARE(date.startOfDay(QTimeZone::LocalTime), date.startOfDay(zone)); + +#if __cpp_lib_chrono >= 201907L + const std::chrono::time_zone *currentTimeZone = std::chrono::current_zone(); + QCOMPARE(QByteArrayView(currentTimeZone->name()), QByteArrayView(zone.id())); +#endif } void tst_QTimeZone::isTimeZoneIdAvailable() { const QList<QByteArray> available = QTimeZone::availableTimeZoneIds(); for (const QByteArray &id : available) { - QVERIFY(QTimeZone::isTimeZoneIdAvailable(id)); - QVERIFY(QTimeZone(id).isValid()); + QVERIFY2(QTimeZone::isTimeZoneIdAvailable(id), id); + const QTimeZone zone(id); + QVERIFY2(zone.isValid(), id); + QVERIFY2(zone.aliasMatches(id), zone.id() + " != " + id); + } + // availableTimeZoneIds() doesn't list all possible offset IDs, but + // isTimeZoneIdAvailable() should accept them. + for (qint32 offset = QTimeZone::MinUtcOffsetSecs; + offset <= QTimeZone::MinUtcOffsetSecs; ++offset) { + const QByteArray id = QTimeZone(offset).id(); + QVERIFY2(QTimeZone::isTimeZoneIdAvailable(id), id); + QVERIFY2(QTimeZone(id).isValid(), id); + QCOMPARE(QTimeZone(id).id(), id); } } @@ -407,7 +592,7 @@ void tst_QTimeZone::utcOffsetId_data() #define ROW(name, valid, offset) \ QTest::newRow(name) << QByteArray(name) << valid << offset - // See qtbase/util/locale_database/cldr2qtimezone.py for source + // See qtbase/util/locale_database/zonedata.py for source // CLDR v35.1 IDs: ROW("UTC", true, 0); ROW("UTC-14:00", true, -50400); @@ -449,11 +634,16 @@ void tst_QTimeZone::utcOffsetId_data() ROW("UTC+12:00", true, 43200); ROW("UTC+13:00", true, 46800); ROW("UTC+14:00", true, 50400); + // Windows IDs known to CLDR v35.1: ROW("UTC-11", true, -39600); ROW("UTC-09", true, -32400); ROW("UTC-08", true, -28800); + ROW("UTC-8", true, -28800); + ROW("UTC-2:5", true, -7500); ROW("UTC-02", true, -7200); + ROW("UTC+2", true, 7200); + ROW("UTC+2:5", true, 7500); ROW("UTC+12", true, 43200); ROW("UTC+13", true, 46800); // Encountered in bug reports: @@ -497,13 +687,79 @@ void tst_QTimeZone::utcOffsetId() QTimeZone zone(id); QCOMPARE(zone.isValid(), valid); if (valid) { - QDateTime epoch(QDate(1970, 1, 1), QTime(0, 0, 0), Qt::UTC); + QDateTime epoch(QDate(1970, 1, 1), QTime(0, 0), QTimeZone::UTC); QFETCH(int, offset); QCOMPARE(zone.offsetFromUtc(epoch), offset); QVERIFY(!zone.hasDaylightTime()); + + // zone.id() will be an IANA ID with zero minutes field if original was + // a UTC offset by a whole number of hours. It will also zero-pad a + // single-digit hour or minute to two digits. + if (const qsizetype cut = id.indexOf(':'); cut >= 0) { + if (id.size() == cut + 2) // "...:m" -> "...:0m" + id.insert(cut + 1, '0'); + } else if (zone.id().contains(':')) { + id += ":00"; + } + if (id.indexOf(':') == 5) // UTC±h:mm -> UTC±0h:mm + id.insert(4, '0'); + + QCOMPARE(zone.id(), id); } } +void tst_QTimeZone::aliasMatches_data() +{ + QTest::addColumn<QByteArray>("iana"); + QTest::addColumn<QByteArray>("alias"); + + QTest::newRow("Montreal=Toronto") << "America/Toronto"_ba << "America/Montreal"_ba; + QTest::newRow("Asmera=Asmara") << "Africa/Asmara"_ba << "Africa/Asmera"_ba; + QTest::newRow("Argentina/Catamarca") + << "America/Argentina/Catamarca"_ba << "America/Catamarca"_ba; + QTest::newRow("Godthab=Nuuk") << "America/Nuuk"_ba << "America/Godthab"_ba; + QTest::newRow("Indiana/Indianapolis") + << "America/Indiana/Indianapolis"_ba << "America/Indianapolis"_ba; + QTest::newRow("Kentucky/Louisville") + << "America/Kentucky/Louisville"_ba << "America/Louisville"_ba; + QTest::newRow("Calcutta=Kolkata") << "Asia/Kolkata"_ba << "Asia/Calcutta"_ba; + QTest::newRow("Katmandu=Kathmandu") << "Asia/Kathmandu"_ba << "Asia/Katmandu"_ba; + QTest::newRow("Rangoon=Yangon") << "Asia/Yangon"_ba << "Asia/Rangoon"_ba; + QTest::newRow("Saigon=Ho_Chi_Minh") << "Asia/Ho_Chi_Minh"_ba << "Asia/Saigon"_ba; + QTest::newRow("Faeroe=Faroe") << "Atlantic/Faroe"_ba << "Atlantic/Faeroe"_ba; + QTest::newRow("Currie=Hobart") << "Australia/Hobart"_ba << "Australia/Currie"_ba; + QTest::newRow("Kiev=Kyiv") << "Europe/Kyiv"_ba << "Europe/Kiev"_ba; + QTest::newRow("Uzhgorod=Kyiv") << "Europe/Kyiv"_ba << "Europe/Uzhgorod"_ba; + QTest::newRow("Zaporozhye=Kyiv") << "Europe/Kyiv"_ba << "Europe/Zaporozhye"_ba; + QTest::newRow("Fiji=Fiji") << "Pacific/Fiji"_ba << "Pacific/Fiji"_ba; + QTest::newRow("Enderbury=Enderbury") << "Pacific/Enderbury"_ba << "Pacific/Enderbury"_ba; +} + +void tst_QTimeZone::aliasMatches() +{ + QFETCH(const QByteArray, iana); + QFETCH(const QByteArray, alias); + const QTimeZone zone(iana); + const QTimeZone peer(alias); + if (!zone.isValid()) + QSKIP("Backend doesn't support IANA ID"); + + auto report = qScopeGuard([zone, peer]() { + const QByteArray zid = zone.id(), pid = peer.id(); + qDebug("Using %s and %s", zid.constData(), pid.constData()); + }); + QVERIFY2(peer.isValid(), "Construction should have fallen back on IANA ID"); + QVERIFY(zone.aliasMatches(zone.id())); + QVERIFY(zone.aliasMatches(iana)); + QVERIFY(peer.aliasMatches(peer.id())); + QVERIFY(peer.aliasMatches(alias)); + QVERIFY(zone.aliasMatches(peer.id())); + QVERIFY(zone.aliasMatches(alias)); + QVERIFY(peer.aliasMatches(zone.id())); + QVERIFY(peer.aliasMatches(iana)); + report.dismiss(); +} + void tst_QTimeZone::specificTransition_data() { QTest::addColumn<QByteArray>("zone"); @@ -511,10 +767,14 @@ void tst_QTimeZone::specificTransition_data() QTest::addColumn<QDate>("stop"); QTest::addColumn<int>("count"); QTest::addColumn<QDateTime>("atUtc"); - // In minutes: + // In seconds: QTest::addColumn<int>("offset"); QTest::addColumn<int>("stdoff"); QTest::addColumn<int>("dstoff"); +#ifdef Q_OS_ANDROID + if (!QTimeZone("Europe/Moscow").hasTransitions()) + QSKIP("Android time-zone back-end has no transition data"); +#endif // Moscow ditched DST on 2010-10-31 but has since changed standard offset twice. #ifdef USING_WIN_TZ @@ -524,16 +784,16 @@ void tst_QTimeZone::specificTransition_data() { QTest::newRow("Moscow/2014") // From original bug-report << QByteArray("Europe/Moscow") - << QDate(2011, 4, 1) << QDate(2017, 12,31) << 1 - << QDateTime(QDate(2014, 10, 26), QTime(2, 0, 0), - Qt::OffsetFromUTC, 4 * 3600).toUTC() + << QDate(2011, 4, 1) << QDate(2021, 12, 31) << 1 + << QDateTime(QDate(2014, 10, 26), QTime(2, 0), + QTimeZone::fromSecondsAheadOfUtc(4 * 3600)).toUTC() << 3 * 3600 << 3 * 3600 << 0; } QTest::newRow("Moscow/2011") // Transition on 2011-03-27 << QByteArray("Europe/Moscow") << QDate(2010, 11, 1) << QDate(2014, 10, 25) << 1 - << QDateTime(QDate(2011, 3, 27), QTime(2, 0, 0), - Qt::OffsetFromUTC, 3 * 3600).toUTC() + << QDateTime(QDate(2011, 3, 27), QTime(2, 0), + QTimeZone::fromSecondsAheadOfUtc(3 * 3600)).toUTC() << 4 * 3600 << 4 * 3600 << 0; } @@ -554,14 +814,15 @@ void tst_QTimeZone::specificTransition() if (!timeZone.isValid()) QSKIP("Missing time-zone data"); QTimeZone::OffsetDataList transits = - timeZone.transitions(QDateTime(start, QTime(0, 0), timeZone), - QDateTime(stop, QTime(23, 59), timeZone)); - QCOMPARE(transits.length(), count); - const QTimeZone::OffsetData &transition = transits.at(0); - QCOMPARE(transition.offsetFromUtc, offset); - QCOMPARE(transition.standardTimeOffset, stdoff); - QCOMPARE(transition.daylightTimeOffset, dstoff); - QCOMPARE(transition.atUtc, atUtc); + timeZone.transitions(start.startOfDay(timeZone), stop.endOfDay(timeZone)); + QCOMPARE(transits.size(), count); + if (count) { + const QTimeZone::OffsetData &transition = transits.at(0); + QCOMPARE(transition.offsetFromUtc, offset); + QCOMPARE(transition.standardTimeOffset, stdoff); + QCOMPARE(transition.daylightTimeOffset, dstoff); + QCOMPARE(transition.atUtc, atUtc); + } } void tst_QTimeZone::transitionEachZone_data() @@ -571,24 +832,20 @@ void tst_QTimeZone::transitionEachZone_data() QTest::addColumn<int>("start"); QTest::addColumn<int>("stop"); - struct { + const struct { qint64 baseSecs; int start, stop; int year; } table[] = { - { 25666200, 3, 12, 1970 }, // 1970-10-25 01:30 UTC; North America - { 1288488600, -4, 8, 2010 } // 2010-10-31 01:30 UTC; Europe, Russia + { 1288488600, -4, 8, 2010 }, // 2010-10-31 01:30 UTC; Europe, Russia + { 25666200, 3, 12, 1970 }, // 1970-10-25 01:30 UTC; North America }; const auto zones = QTimeZone::availableTimeZoneIds(); - for (int k = sizeof(table) / sizeof(table[0]); k-- > 0; ) { + for (const auto &entry : table) { for (const QByteArray &zone : zones) { - const QString name = QString::asprintf("%s@%d", zone.constData(), table[k].year); - QTest::newRow(name.toUtf8().constData()) - << zone - << table[k].baseSecs - << table[k].start - << table[k].stop; + QTest::addRow("%s@%d", zone.constData(), entry.year) + << zone << entry.baseSecs << entry.start << entry.stop; } } } @@ -597,29 +854,31 @@ void tst_QTimeZone::transitionEachZone() { // Regression test: round-trip fromMsecs/toMSecs should be idempotent; but // various zones failed during fall-back transitions. - QFETCH(QByteArray, zone); - QFETCH(qint64, secs); - QFETCH(int, start); - QFETCH(int, stop); - QTimeZone named(zone); + QFETCH(const QByteArray, zone); + QFETCH(const qint64, secs); + QFETCH(const int, start); + QFETCH(const int, stop); + const QTimeZone named(zone); + if (!named.isValid()) + QSKIP("Supposedly available zone is not valid"); + if (named.id() != zone) + QSKIP("Supposedly available zone's id does not match"); for (int i = start; i < stop; i++) { #ifdef USING_WIN_TZ // See QTBUG-64985: MS's TZ APIs' misdescription of Europe/Samara leads // to mis-disambiguation of its fall-back here. - if (zone == "Europe/Samara" && i == -3) { + if (zone == "Europe/Samara" && i == -3) continue; - } #endif -#ifdef Q_OS_ANDROID - if (zone == "America/Mazatlan" || zone == "Mexico/BajaSur") - QSKIP("Crashes on Android, see QTBUG-69132"); -#endif - qint64 here = secs + i * 3600; - QDateTime when = QDateTime::fromMSecsSinceEpoch(here * 1000, named); - qint64 stamp = when.toMSecsSinceEpoch(); - if (here * 1000 != stamp) // (The +1 is due to using *1*:30 as baseSecs.) - qDebug() << "Failing for" << zone << "at half past" << (i + 1) << "UTC"; + const qint64 here = secs + i * 3600; + const QDateTime when = QDateTime::fromSecsSinceEpoch(here, named); + const qint64 stamp = when.toMSecsSinceEpoch(); + if (here * 1000 != stamp) { + // (The +1 is due to using _1_:30 as baseSecs.) + qDebug("Failing at half past %d UTC (offset %d in %s)", i + 1, when.offsetFromUtc(), + QLocale::territoryToString(named.territory()).toUtf8().constData()); + } QCOMPARE(stamp % 1000, 0); QCOMPARE(here - stamp / 1000, 0); } @@ -627,17 +886,29 @@ void tst_QTimeZone::transitionEachZone() void tst_QTimeZone::checkOffset_data() { - QTest::addColumn<QByteArray>("zoneName"); + QTest::addColumn<QTimeZone>("zone"); QTest::addColumn<QDateTime>("when"); QTest::addColumn<int>("netOffset"); QTest::addColumn<int>("stdOffset"); QTest::addColumn<int>("dstOffset"); + const QTimeZone UTC = QTimeZone::UTC; + QTest::addRow("UTC") + << UTC << QDate(1970, 1, 1).startOfDay(UTC) << 0 << 0 << 0; + const auto east = QTimeZone::fromSecondsAheadOfUtc(28'800); // 8 hours + QTest::addRow("UTC+8") + << east << QDate(2000, 2, 29).startOfDay(east) << 28'800 << 28'800 << 0; + const auto west = QTimeZone::fromDurationAheadOfUtc(std::chrono::hours{-8}); + QTest::addRow("UTC-8") + << west << QDate(2100, 2, 28).startOfDay(west) << -28'800 << -28'800 << 0; + struct { const char *zone, *nick; int year, month, day, hour, min, sec; int std, dst; } table[] = { + // Exercise the UTC-backend: + { "UTC", "epoch", 1970, 1, 1, 0, 0, 0, 0, 0 }, // Zone with no transitions (QTBUG-74614, QTBUG-74666, when TZ backend uses minimal data) { "Etc/UTC", "epoch", 1970, 1, 1, 0, 0, 0, 0, 0 }, { "Etc/UTC", "pre_int32", 1901, 12, 13, 20, 45, 51, 0, 0 }, @@ -645,15 +916,15 @@ void tst_QTimeZone::checkOffset_data() { "Etc/UTC", "post_uint32", 2106, 2, 7, 6, 28, 17, 0, 0 }, { "Etc/UTC", "initial", -292275056, 5, 16, 16, 47, 5, 0, 0 }, { "Etc/UTC", "final", 292278994, 8, 17, 7, 12, 55, 0, 0 }, - // Kiev: regression test for QTBUG-64122 (on MS): - { "Europe/Kiev", "summer", 2017, 10, 27, 12, 0, 0, 2 * 3600, 3600 }, - { "Europe/Kiev", "winter", 2017, 10, 29, 12, 0, 0, 2 * 3600, 0 } + // Kyiv: regression test for QTBUG-64122 (on MS): + { "Europe/Kyiv", "summer", 2017, 10, 27, 12, 0, 0, 2 * 3600, 3600 }, + { "Europe/Kyiv", "winter", 2017, 10, 29, 12, 0, 0, 2 * 3600, 0 } }; for (const auto &entry : table) { QTimeZone zone(entry.zone); if (zone.isValid()) { QTest::addRow("%s@%s", entry.zone, entry.nick) - << QByteArray(entry.zone) + << zone << QDateTime(QDate(entry.year, entry.month, entry.day), QTime(entry.hour, entry.min, entry.sec), zone) << entry.dst + entry.std << entry.std << entry.dst; @@ -665,18 +936,24 @@ void tst_QTimeZone::checkOffset_data() void tst_QTimeZone::checkOffset() { - QFETCH(QByteArray, zoneName); + QFETCH(QTimeZone, zone); QFETCH(QDateTime, when); QFETCH(int, netOffset); QFETCH(int, stdOffset); QFETCH(int, dstOffset); - QTimeZone zone(zoneName); QVERIFY(zone.isValid()); // It was when _data() added the row ! QCOMPARE(zone.offsetFromUtc(when), netOffset); QCOMPARE(zone.standardTimeOffset(when), stdOffset); QCOMPARE(zone.daylightTimeOffset(when), dstOffset); QCOMPARE(zone.isDaylightTime(when), dstOffset != 0); + + // Also test offsetData(), which gets all this data in one go: + const auto data = zone.offsetData(when); + QCOMPARE(data.atUtc, when); + QCOMPARE(data.offsetFromUtc, netOffset); + QCOMPARE(data.standardTimeOffset, stdOffset); + QCOMPARE(data.daylightTimeOffset, dstOffset); } void tst_QTimeZone::availableTimeZoneIds() @@ -702,13 +979,14 @@ void tst_QTimeZone::availableTimeZoneIds() void tst_QTimeZone::stressTest() { + const auto UTC = QTimeZone::UTC; const QList<QByteArray> idList = QTimeZone::availableTimeZoneIds(); for (const QByteArray &id : idList) { QTimeZone testZone = QTimeZone(id); QCOMPARE(testZone.isValid(), true); - QCOMPARE(testZone.id(), id); - QDateTime testDate = QDateTime(QDate(2015, 1, 1), QTime(0, 0, 0), Qt::UTC); - testZone.country(); + QVERIFY2(testZone.aliasMatches(id), testZone.id() + " != " + id); + QDateTime testDate = QDateTime(QDate(2015, 1, 1), QTime(0, 0), UTC); + testZone.territory(); testZone.comment(); testZone.displayName(testDate); testZone.displayName(QTimeZone::DaylightTime); @@ -724,10 +1002,10 @@ void tst_QTimeZone::stressTest() testZone.nextTransition(testDate); testZone.previousTransition(testDate); // Dates known to be outside possible tz file pre-calculated rules range - QDateTime lowDate1 = QDateTime(QDate(1800, 1, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime lowDate2 = QDateTime(QDate(1800, 6, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime highDate1 = QDateTime(QDate(2200, 1, 1), QTime(0, 0, 0), Qt::UTC); - QDateTime highDate2 = QDateTime(QDate(2200, 6, 1), QTime(0, 0, 0), Qt::UTC); + QDateTime lowDate1 = QDateTime(QDate(1800, 1, 1), QTime(0, 0), UTC); + QDateTime lowDate2 = QDateTime(QDate(1800, 6, 1), QTime(0, 0), UTC); + QDateTime highDate1 = QDateTime(QDate(2200, 1, 1), QTime(0, 0), UTC); + QDateTime highDate2 = QDateTime(QDate(2200, 6, 1), QTime(0, 0), UTC); testZone.nextTransition(lowDate1); testZone.nextTransition(lowDate2); testZone.previousTransition(lowDate2); @@ -754,12 +1032,12 @@ void tst_QTimeZone::windowsId() Current Windows zones for "Central Standard Time": Region IANA Id(s) Default "America/Chicago" - Canada "America/Winnipeg America/Rainy_River America/Rankin_Inlet America/Resolute" + Canada "America/Winnipeg America/Rankin_Inlet America/Resolute" Mexico "America/Matamoros" USA "America/Chicago America/Indiana/Knox America/Indiana/Tell_City America/Menominee" "America/North_Dakota/Beulah America/North_Dakota/Center" "America/North_Dakota/New_Salem" - AnyCountry "CST6CDT" + AnyTerritory "CST6CDT" */ QCOMPARE(QTimeZone::ianaIdToWindowsId("America/Chicago"), QByteArray("Central Standard Time")); @@ -776,50 +1054,58 @@ void tst_QTimeZone::windowsId() QByteArray("America/Chicago")); QCOMPARE(QTimeZone::windowsIdToDefaultIanaId("Central Standard Time", QLocale::Canada), QByteArray("America/Winnipeg")); - QCOMPARE(QTimeZone::windowsIdToDefaultIanaId("Central Standard Time", QLocale::AnyCountry), + QCOMPARE(QTimeZone::windowsIdToDefaultIanaId("Central Standard Time", QLocale::AnyTerritory), QByteArray("CST6CDT")); QCOMPARE(QTimeZone::windowsIdToDefaultIanaId(QByteArray()), QByteArray()); - // No country is sorted list of all zones - QList<QByteArray> list; - list << "America/Chicago" << "America/Indiana/Knox" << "America/Indiana/Tell_City" - << "America/Matamoros" << "America/Menominee" << "America/North_Dakota/Beulah" - << "America/North_Dakota/Center" << "America/North_Dakota/New_Salem" - << "America/Rainy_River" << "America/Rankin_Inlet" << "America/Resolute" - << "America/Winnipeg" << "CST6CDT"; - QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time"), list); - - // Check country with no match returns empty list - list.clear(); - QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::NewZealand), - list); - - // Check valid country returns list in preference order - list.clear(); - list << "America/Winnipeg" << "America/Rainy_River" << "America/Rankin_Inlet" - << "America/Resolute"; - QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::Canada), list); - - list.clear(); - list << "America/Matamoros"; - QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::Mexico), list); - - list.clear(); - list << "America/Chicago" << "America/Indiana/Knox" << "America/Indiana/Tell_City" - << "America/Menominee" << "America/North_Dakota/Beulah" << "America/North_Dakota/Center" - << "America/North_Dakota/New_Salem"; - QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::UnitedStates), - list); - - list.clear(); - list << "CST6CDT"; - QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::AnyCountry), - list); - - // Check no windowsId return empty - list.clear(); - QCOMPARE(QTimeZone::windowsIdToIanaIds(QByteArray()), list); - QCOMPARE(QTimeZone::windowsIdToIanaIds(QByteArray(), QLocale::AnyCountry), list); + { + // With no country, expect sorted list of all zones for ID + const QList<QByteArray> list = { + "America/Chicago", "America/Indiana/Knox", "America/Indiana/Tell_City", + "America/Matamoros", "America/Menominee", "America/North_Dakota/Beulah", + "America/North_Dakota/Center", "America/North_Dakota/New_Salem", + "America/Ojinaga", "America/Rankin_Inlet", "America/Resolute", + "America/Winnipeg", "CST6CDT" + }; + QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time"), list); + } + { + // Check country with no match returns empty list + const QList<QByteArray> empty; + QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::NewZealand), + empty); + } + { + // Check valid country returns list in preference order + const QList<QByteArray> list = { + "America/Winnipeg", "America/Rankin_Inlet", "America/Resolute" + }; + QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::Canada), list); + } + { + const QList<QByteArray> list = { "America/Matamoros", "America/Ojinaga" }; + QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::Mexico), list); + } + { + const QList<QByteArray> list = { + "America/Chicago", "America/Indiana/Knox", "America/Indiana/Tell_City", + "America/Menominee", "America/North_Dakota/Beulah", "America/North_Dakota/Center", + "America/North_Dakota/New_Salem" + }; + QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::UnitedStates), + list); + } + { + const QList<QByteArray> list = { "CST6CDT" }; + QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::AnyTerritory), + list); + } + { + // Check empty if given no windowsId: + const QList<QByteArray> empty; + QCOMPARE(QTimeZone::windowsIdToIanaIds(QByteArray()), empty); + QCOMPARE(QTimeZone::windowsIdToIanaIds(QByteArray(), QLocale::AnyTerritory), empty); + } } void tst_QTimeZone::isValidId_data() @@ -842,7 +1128,7 @@ void tst_QTimeZone::isValidId_data() // Parts separated by '/', each part min 1 and max of 14 chars TESTSET("empty", "", false); TESTSET("minimal", "m", true); -#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_EMBEDDED) +#if defined(Q_OS_ANDROID) || QT_CONFIG(icu) TESTSET("maximal", "East-Saskatchewan", true); // Android actually uses this TESTSET("too long", "North-Saskatchewan", false); // ... but thankfully not this. #else @@ -913,7 +1199,7 @@ void tst_QTimeZone::isValidId_data() QTest::newRow("a,z alone") << QByteArray("a,z") << false; QTest::newRow("/z alone") << QByteArray("/z") << false; QTest::newRow("-z alone") << QByteArray("-z") << false; -#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_EMBEDDED) +#if defined(Q_OS_ANDROID) || QT_CONFIG(icu) QTest::newRow("long alone") << QByteArray("12345678901234567") << true; QTest::newRow("over-long alone") << QByteArray("123456789012345678") << false; #else @@ -940,6 +1226,7 @@ void tst_QTimeZone::serialize() { int parts = 0; #ifndef QT_NO_DEBUG_STREAM + QTest::ignoreMessage(QtDebugMsg, "QTimeZone(\"\")"); qDebug() << QTimeZone(); // to verify no crash parts++; #endif @@ -963,6 +1250,24 @@ void tst_QTimeZone::serialize() QSKIP("No serialization enabled"); } +void tst_QTimeZone::malformed() +{ + // Regression test for QTBUG-92808 + // Strings that look enough like a POSIX zone specifier that the constructor + // accepts them, but the specifier is invalid. + // Must not crash or trigger assertions when calling offsetFromUtc() + const QDateTime now = QDateTime::currentDateTime(); + QTimeZone barf("QUT4tCZ0 , /"); + if (barf.isValid()) + QCOMPARE(barf.offsetFromUtc(now), 0); + barf = QTimeZone("QtC+09,,MA"); + if (barf.isValid()) + QCOMPARE(barf.offsetFromUtc(now), 0); + barf = QTimeZone("UTCC+14:00,-,"); + if (barf.isValid()) + QCOMPARE(barf.daylightTimeOffset(now), -14 * 3600); +} + void tst_QTimeZone::utcTest() { #ifdef QT_BUILD_INTERNAL @@ -970,7 +1275,7 @@ void tst_QTimeZone::utcTest() QUtcTimeZonePrivate tzp; QCOMPARE(tzp.isValid(), true); QCOMPARE(tzp.id(), QByteArray("UTC")); - QCOMPARE(tzp.country(), QLocale::AnyCountry); + QCOMPARE(tzp.territory(), QLocale::AnyTerritory); QCOMPARE(tzp.abbreviation(0), QString("UTC")); QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::LongName, QLocale()), QString("UTC")); QCOMPARE(tzp.offsetFromUtc(0), 0); @@ -979,18 +1284,25 @@ void tst_QTimeZone::utcTest() QCOMPARE(tzp.hasDaylightTime(), false); QCOMPARE(tzp.hasTransitions(), false); - // Test create from UTC Offset + // Test create from UTC Offset: QDateTime now = QDateTime::currentDateTime(); QTimeZone tz(36000); - QCOMPARE(tz.isValid(), true); + QVERIFY(tz.isValid()); QCOMPARE(tz.id(), QByteArray("UTC+10:00")); QCOMPARE(tz.offsetFromUtc(now), 36000); QCOMPARE(tz.standardTimeOffset(now), 36000); QCOMPARE(tz.daylightTimeOffset(now), 0); - // Test invalid UTC offset, must be in range -14 to +14 hours - int min = -14*60*60; - int max = 14*60*60; + tz = QTimeZone(15 * 3600); // no IANA ID, so uses minimal id, skipping :00 minutes + QVERIFY(tz.isValid()); + QCOMPARE(tz.id(), QByteArray("UTC+15")); + QCOMPARE(tz.offsetFromUtc(now), 15 * 3600); + QCOMPARE(tz.standardTimeOffset(now), 15 * 3600); + QCOMPARE(tz.daylightTimeOffset(now), 0); + + // Test validity range of UTC offsets: + int min = QTimeZone::MinUtcOffsetSecs; + int max = QTimeZone::MaxUtcOffsetSecs; QCOMPARE(QTimeZone(min - 1).isValid(), false); QCOMPARE(QTimeZone(min).isValid(), true); QCOMPARE(QTimeZone(min + 1).isValid(), true); @@ -998,9 +1310,9 @@ void tst_QTimeZone::utcTest() QCOMPARE(QTimeZone(max).isValid(), true); QCOMPARE(QTimeZone(max + 1).isValid(), false); - // Test create from standard name + // Test create from standard name (preserves :00 for minutes in id): tz = QTimeZone("UTC+10:00"); - QCOMPARE(tz.isValid(), true); + QVERIFY(tz.isValid()); QCOMPARE(tz.id(), QByteArray("UTC+10:00")); QCOMPARE(tz.offsetFromUtc(now), 36000); QCOMPARE(tz.standardTimeOffset(now), 36000); @@ -1011,7 +1323,7 @@ void tst_QTimeZone::utcTest() QCOMPARE(tz.isValid(), true); QCOMPARE(tz.id(), QByteArray("QST")); QCOMPARE(tz.comment(), QString("Qt Testing")); - QCOMPARE(tz.country(), QLocale::Norway); + QCOMPARE(tz.territory(), QLocale::Norway); QCOMPARE(tz.abbreviation(now), QString("QST")); QCOMPARE(tz.displayName(QTimeZone::StandardTime, QTimeZone::LongName, QLocale()), QString("Qt Standard Time")); @@ -1021,18 +1333,25 @@ void tst_QTimeZone::utcTest() #endif // QT_BUILD_INTERNAL } +// Relies on local variable names: zone tzp and locale enUS. +#define ZONE_DNAME_CHECK(type, name, val) \ + QCOMPARE(tzp.displayName(QTimeZone::type, QTimeZone::name, enUS), \ + QStringLiteral(val)); + void tst_QTimeZone::icuTest() { -#if defined(QT_BUILD_INTERNAL) && QT_CONFIG(icu) +#if defined(QT_BUILD_INTERNAL) && QT_CONFIG(icu) && !defined(Q_OS_UNIX) // Known datetimes - qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); + qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); + qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); // Test default constructor QIcuTimeZonePrivate tzpd; QVERIFY(tzpd.isValid()); - // Test invalid constructor + // Test invalid is not available: + QVERIFY(!tzpd.isTimeZoneIdAvailable("Gondwana/Erewhon")); + // and construction gives an invalid result: QIcuTimeZonePrivate tzpi("Gondwana/Erewhon"); QCOMPARE(tzpi.isValid(), false); @@ -1044,25 +1363,16 @@ void tst_QTimeZone::icuTest() if (debug) { // Test display names by type QLocale enUS("en_US"); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::LongName, enUS), - QString("Central European Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::ShortName, enUS), - QString("GMT+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::LongName, enUS), - QString("Central European Summer Time")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::ShortName, enUS), - QString("GMT+02:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::OffsetName, enUS), - QString("UTC+02:00")); + ZONE_DNAME_CHECK(StandardTime, LongName, "Central European Standard Time"); + ZONE_DNAME_CHECK(StandardTime, ShortName, "GMT+01:00"); + ZONE_DNAME_CHECK(StandardTime, OffsetName, "UTC+01:00"); + ZONE_DNAME_CHECK(DaylightTime, LongName, "Central European Summer Time"); + ZONE_DNAME_CHECK(DaylightTime, ShortName, "GMT+02:00"); + ZONE_DNAME_CHECK(DaylightTime, OffsetName, "UTC+02:00"); // ICU C api does not support Generic Time yet, C++ api does - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::LongName, enUS), - QString("Central European Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::ShortName, enUS), - QString("GMT+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); + ZONE_DNAME_CHECK(GenericTime, LongName, "Central European Standard Time"); + ZONE_DNAME_CHECK(GenericTime, ShortName, "GMT+01:00"); + ZONE_DNAME_CHECK(GenericTime, OffsetName, "UTC+01:00"); // Test Abbreviations QCOMPARE(tzp.abbreviation(std), QString("CET")); @@ -1070,16 +1380,19 @@ void tst_QTimeZone::icuTest() } testCetPrivate(tzp); + if (QTest::currentTestFailed()) + return; testEpochTranPrivate(QIcuTimeZonePrivate("America/Toronto")); -#endif // icu +#endif // ICU not on Unix } void tst_QTimeZone::tzTest() { #if defined QT_BUILD_INTERNAL && defined Q_OS_UNIX && !defined Q_OS_DARWIN && !defined Q_OS_ANDROID + const auto UTC = QTimeZone::UTC; // Known datetimes - qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); + qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0), UTC).toMSecsSinceEpoch(); + qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0), UTC).toMSecsSinceEpoch(); // Test default constructor QTzTimeZonePrivate tzpd; @@ -1087,15 +1400,34 @@ void tst_QTimeZone::tzTest() // Test invalid constructor QTzTimeZonePrivate tzpi("Gondwana/Erewhon"); - QCOMPARE(tzpi.isValid(), false); + QVERIFY(!tzpi.isValid()); // Test named constructor QTzTimeZonePrivate tzp("Europe/Berlin"); QVERIFY(tzp.isValid()); // Test POSIX-format value for $TZ: - QTzTimeZonePrivate tzposix("MET-1METDST-2,M3.5.0/02:00:00,M10.5.0/03:00:00"); + QTimeZone tzposix("MET-1METDST-2,M3.5.0/02:00:00,M10.5.0/03:00:00"); QVERIFY(tzposix.isValid()); + QVERIFY(tzposix.hasDaylightTime()); + + // RHEL has been seen with this as Africa/Casablanca's POSIX rule: + QTzTimeZonePrivate permaDst("<+00>0<+01>,0/0,J365/25"); + const QTimeZone utcP1("UTC+01:00"); // Should always have same offset as permaDst + QVERIFY(permaDst.isValid()); + QVERIFY(permaDst.hasDaylightTime()); + QVERIFY(permaDst.isDaylightTime(QDate(2020, 1, 1).startOfDay(utcP1).toMSecsSinceEpoch())); + QVERIFY(permaDst.isDaylightTime(QDate(2020, 12, 31).endOfDay(utcP1).toMSecsSinceEpoch())); + // Note that the final /25 could be misunderstood as putting a fall-back at + // 1am on the next year's Jan 1st; check we don't do that: + QVERIFY(permaDst.isDaylightTime( + QDateTime(QDate(2020, 1, 1), QTime(1, 30), utcP1).toMSecsSinceEpoch())); + // It shouldn't have any transitions. QTimeZone::hasTransitions() only says + // whether the backend supports them, so ask for transitions in a wide + // enough interval that one would show up, if there are any: + QVERIFY(permaDst.transitions(QDate(2015, 1, 1).startOfDay(UTC).toMSecsSinceEpoch(), + QDate(2020, 1, 1).startOfDay(UTC).toMSecsSinceEpoch() + ).isEmpty()); QTimeZone tzBrazil("BRT+3"); // parts of Northern Brazil, as a POSIX rule QVERIFY(tzBrazil.isValid()); @@ -1106,44 +1438,26 @@ void tst_QTimeZone::tzTest() // Only test names in debug mode, names used can vary by ICU version installed if (debug) { #if QT_CONFIG(icu) - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::LongName, enUS), - QString("Central European Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::ShortName, enUS), - QString("GMT+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::LongName, enUS), - QString("Central European Summer Time")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::ShortName, enUS), - QString("GMT+02:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::OffsetName, enUS), - QString("UTC+02:00")); + ZONE_DNAME_CHECK(StandardTime, LongName, "Central European Standard Time"); + ZONE_DNAME_CHECK(StandardTime, ShortName, "GMT+01:00"); + ZONE_DNAME_CHECK(StandardTime, OffsetName, "UTC+01:00"); + ZONE_DNAME_CHECK(DaylightTime, LongName, "Central European Summer Time"); + ZONE_DNAME_CHECK(DaylightTime, ShortName, "GMT+02:00"); + ZONE_DNAME_CHECK(DaylightTime, OffsetName, "UTC+02:00"); // ICU C api does not support Generic Time yet, C++ api does - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::LongName, enUS), - QString("Central European Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::ShortName, enUS), - QString("GMT+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); + ZONE_DNAME_CHECK(GenericTime, LongName, "Central European Standard Time"); + ZONE_DNAME_CHECK(GenericTime, ShortName, "GMT+01:00"); + ZONE_DNAME_CHECK(GenericTime, OffsetName, "UTC+01:00"); #else - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::LongName, enUS), - QString("CET")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::ShortName, enUS), - QString("CET")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::OffsetName, enUS), - QString("CET")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::LongName, enUS), - QString("CEST")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::ShortName, enUS), - QString("CEST")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::OffsetName, enUS), - QString("CEST")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::LongName, enUS), - QString("CET")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::ShortName, enUS), - QString("CET")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::OffsetName, enUS), - QString("CET")); + ZONE_DNAME_CHECK(StandardTime, LongName, "CET"); + ZONE_DNAME_CHECK(StandardTime, ShortName, "CET"); + ZONE_DNAME_CHECK(StandardTime, OffsetName, "CET"); + ZONE_DNAME_CHECK(DaylightTime, LongName, "CEST"); + ZONE_DNAME_CHECK(DaylightTime, ShortName, "CEST"); + ZONE_DNAME_CHECK(DaylightTime, OffsetName, "CEST"); + ZONE_DNAME_CHECK(GenericTime, LongName, "CET"); + ZONE_DNAME_CHECK(GenericTime, ShortName, "CET"); + ZONE_DNAME_CHECK(GenericTime, OffsetName, "CET"); #endif // icu // Test Abbreviations @@ -1152,81 +1466,98 @@ void tst_QTimeZone::tzTest() } testCetPrivate(tzp); + if (QTest::currentTestFailed()) + return; testEpochTranPrivate(QTzTimeZonePrivate("America/Toronto")); + if (QTest::currentTestFailed()) + return; // Test first and last transition rule // Warning: This could vary depending on age of TZ file! // Test low date uses first rule found + constexpr qint64 ancient = -Q_INT64_C(9999999999999); // Note: Depending on the OS in question, the database may be carrying the // Local Mean Time. which for Berlin is 0:53:28 - QTimeZonePrivate::Data dat = tzp.data(-9999999999999); - QCOMPARE(dat.atMSecsSinceEpoch, (qint64)-9999999999999); + QTimeZonePrivate::Data dat = tzp.data(ancient); + QCOMPARE(dat.atMSecsSinceEpoch, ancient); QCOMPARE(dat.daylightTimeOffset, 0); if (dat.abbreviation == "LMT") { QCOMPARE(dat.standardTimeOffset, 3208); } else { QCOMPARE(dat.standardTimeOffset, 3600); + constexpr qint64 invalidTime = std::numeric_limits<qint64>::min(); + constexpr int invalidOffset = std::numeric_limits<int>::min(); // Test previous to low value is invalid - dat = tzp.previousTransition(-9999999999999); - QCOMPARE(dat.atMSecsSinceEpoch, std::numeric_limits<qint64>::min()); - QCOMPARE(dat.standardTimeOffset, std::numeric_limits<int>::min()); - QCOMPARE(dat.daylightTimeOffset, std::numeric_limits<int>::min()); + dat = tzp.previousTransition(ancient); + QCOMPARE(dat.atMSecsSinceEpoch, invalidTime); + QCOMPARE(dat.standardTimeOffset, invalidOffset); + QCOMPARE(dat.daylightTimeOffset, invalidOffset); } - dat = tzp.nextTransition(-9999999999999); - QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, Qt::OffsetFromUTC, 3600), - QDateTime(QDate(1893, 4, 1), QTime(0, 6, 32), Qt::OffsetFromUTC, 3600)); + dat = tzp.nextTransition(ancient); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, + QTimeZone::fromSecondsAheadOfUtc(3600)), + QDateTime(QDate(1893, 4, 1), QTime(0, 6, 32), + QTimeZone::fromSecondsAheadOfUtc(3600))); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 0); - // Known high datetimes - qint64 stdHi = QDateTime(QDate(2100, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 dstHi = QDateTime(QDate(2100, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); + // Date-times late enough to exercise POSIX rules: + qint64 stdHi = QDate(2100, 1, 1).startOfDay(UTC).toMSecsSinceEpoch(); + qint64 dstHi = QDate(2100, 6, 1).startOfDay(UTC).toMSecsSinceEpoch(); + // Relevant last Sundays in October and March: + QCOMPARE(Qt::DayOfWeek(QDate(2099, 10, 25).dayOfWeek()), Qt::Sunday); + QCOMPARE(Qt::DayOfWeek(QDate(2100, 3, 28).dayOfWeek()), Qt::Sunday); + QCOMPARE(Qt::DayOfWeek(QDate(2100, 10, 31).dayOfWeek()), Qt::Sunday); - // Tets high dates use the POSIX rule dat = tzp.data(stdHi); - QCOMPARE(dat.atMSecsSinceEpoch - stdHi, (qint64)0); + QCOMPARE(dat.atMSecsSinceEpoch - stdHi, qint64(0)); QCOMPARE(dat.offsetFromUtc, 3600); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 0); dat = tzp.data(dstHi); - QCOMPARE(dat.atMSecsSinceEpoch - dstHi, (qint64)0); + QCOMPARE(dat.atMSecsSinceEpoch - dstHi, qint64(0)); QCOMPARE(dat.offsetFromUtc, 7200); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 3600); dat = tzp.previousTransition(stdHi); - QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, Qt::OffsetFromUTC, 3600), - QDateTime(QDate(2099, 10, 26), QTime(2, 0), Qt::OffsetFromUTC, 3600)); + QCOMPARE(dat.abbreviation, QStringLiteral("CET")); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2099, 10, 25), QTime(3, 0), QTimeZone::fromSecondsAheadOfUtc(7200))); QCOMPARE(dat.offsetFromUtc, 3600); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 0); dat = tzp.previousTransition(dstHi); - QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, Qt::OffsetFromUTC, 3600), - QDateTime(QDate(2100, 3, 29), QTime(2, 0), Qt::OffsetFromUTC, 3600)); + QCOMPARE(dat.abbreviation, QStringLiteral("CEST")); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2100, 3, 28), QTime(2, 0), QTimeZone::fromSecondsAheadOfUtc(3600))); QCOMPARE(dat.offsetFromUtc, 7200); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 3600); dat = tzp.nextTransition(stdHi); - QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, Qt::OffsetFromUTC, 3600), - QDateTime(QDate(2100, 3, 29), QTime(2, 0), Qt::OffsetFromUTC, 3600)); + QCOMPARE(dat.abbreviation, QStringLiteral("CEST")); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2100, 3, 28), QTime(2, 0), QTimeZone::fromSecondsAheadOfUtc(3600))); QCOMPARE(dat.offsetFromUtc, 7200); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 3600); dat = tzp.nextTransition(dstHi); - QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, Qt::OffsetFromUTC, 3600), - QDateTime(QDate(2100, 10, 25), QTime(2, 0), Qt::OffsetFromUTC, 3600)); + QCOMPARE(dat.abbreviation, QStringLiteral("CET")); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(dat.atMSecsSinceEpoch, + QTimeZone::fromSecondsAheadOfUtc(3600)), + QDateTime(QDate(2100, 10, 31), QTime(3, 0), QTimeZone::fromSecondsAheadOfUtc(7200))); QCOMPARE(dat.offsetFromUtc, 3600); QCOMPARE(dat.standardTimeOffset, 3600); QCOMPARE(dat.daylightTimeOffset, 0); - // Test TZ timezone vs UTC timezone for fractionary negative offset + // Test TZ timezone vs UTC timezone for non-whole-hour negative offset: QTzTimeZonePrivate tztz1("America/Caracas"); QUtcTimeZonePrivate tzutc1("UTC-04:30"); QVERIFY(tztz1.isValid()); @@ -1235,33 +1566,36 @@ void tst_QTimeZone::tzTest() QTzTimeZonePrivate::Data datautc1 = tzutc1.data(std); QCOMPARE(datatz1.offsetFromUtc, datautc1.offsetFromUtc); - // Test TZ timezone vs UTC timezone for fractionary positive offset - QTzTimeZonePrivate tztz2("Asia/Calcutta"); + // Test TZ timezone vs UTC timezone for non-whole-hour positive offset: + QTzTimeZonePrivate tztz2k("Asia/Kolkata"); // New name + QTzTimeZonePrivate tztz2c("Asia/Calcutta"); // Legacy name + // Can't assign QtzTZP, so use a reference; prefer new name. + QTzTimeZonePrivate &tztz2 = tztz2k.isValid() ? tztz2k : tztz2c; QUtcTimeZonePrivate tzutc2("UTC+05:30"); - QVERIFY(tztz2.isValid()); + QVERIFY2(tztz2.isValid(), tztz2.id().constData()); QVERIFY(tzutc2.isValid()); QTzTimeZonePrivate::Data datatz2 = tztz2.data(std); QTzTimeZonePrivate::Data datautc2 = tzutc2.data(std); QCOMPARE(datatz2.offsetFromUtc, datautc2.offsetFromUtc); - // Test a timezone with a name that isn't all letters + // Test a timezone with an abbreviation that isn't all letters: QTzTimeZonePrivate tzBarnaul("Asia/Barnaul"); if (tzBarnaul.isValid()) { QCOMPARE(tzBarnaul.data(std).abbreviation, QString("+07")); // first full day of the new rule (tzdata2016b) - QDateTime dt(QDate(2016, 3, 28), QTime(0, 0, 0), Qt::UTC); + QDateTime dt(QDate(2016, 3, 28), QTime(0, 0), UTC); QCOMPARE(tzBarnaul.data(dt.toMSecsSinceEpoch()).abbreviation, QString("+07")); } -#endif // QT_BUILD_INTERNAL && Q_OS_UNIX && !Q_OS_DARWIN +#endif // QT_BUILD_INTERNAL && Q_OS_UNIX && !Q_OS_DARWIN && !Q_OS_ANDROID } void tst_QTimeZone::macTest() { #if defined(QT_BUILD_INTERNAL) && defined(Q_OS_DARWIN) // Known datetimes - qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); + qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); + qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); // Test default constructor QMacTimeZonePrivate tzpd; @@ -1279,25 +1613,16 @@ void tst_QTimeZone::macTest() if (debug) { // Test display names by type QLocale enUS("en_US"); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::LongName, enUS), - QString("Central European Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::ShortName, enUS), - QString("GMT+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::LongName, enUS), - QString("Central European Summer Time")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::ShortName, enUS), - QString("GMT+02:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::OffsetName, enUS), - QString("UTC+02:00")); + ZONE_DNAME_CHECK(StandardTime, LongName, "Central European Standard Time"); + ZONE_DNAME_CHECK(StandardTime, ShortName, "GMT+01:00"); + ZONE_DNAME_CHECK(StandardTime, OffsetName, "UTC+01:00"); + ZONE_DNAME_CHECK(DaylightTime, LongName, "Central European Summer Time"); + ZONE_DNAME_CHECK(DaylightTime, ShortName, "GMT+02:00"); + ZONE_DNAME_CHECK(DaylightTime, OffsetName, "UTC+02:00"); // ICU C api does not support Generic Time yet, C++ api does - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::LongName, enUS), - QString("Central European Time")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::ShortName, enUS), - QString("Germany Time")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); + ZONE_DNAME_CHECK(GenericTime, LongName, "Central European Time"); + ZONE_DNAME_CHECK(GenericTime, ShortName, "Germany Time"); + ZONE_DNAME_CHECK(GenericTime, OffsetName, "UTC+01:00"); // Test Abbreviations QCOMPARE(tzp.abbreviation(std), QString("CET")); @@ -1305,6 +1630,8 @@ void tst_QTimeZone::macTest() } testCetPrivate(tzp); + if (QTest::currentTestFailed()) + return; testEpochTranPrivate(QMacTimeZonePrivate("America/Toronto")); #endif // QT_BUILD_INTERNAL && Q_OS_DARWIN } @@ -1323,8 +1650,8 @@ void tst_QTimeZone::winTest() { #if defined(QT_BUILD_INTERNAL) && defined(USING_WIN_TZ) // Known datetimes - qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); + qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); + qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); // Test default constructor QWinTimeZonePrivate tzpd; @@ -1346,24 +1673,17 @@ void tst_QTimeZone::winTest() if (debug) { // Test display names by type QLocale enUS("en_US"); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::LongName, enUS), - QString("W. Europe Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::ShortName, enUS), - QString("W. Europe Standard Time")); - QCOMPARE(tzp.displayName(QTimeZone::StandardTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::LongName, enUS), - QString("W. Europe Daylight Time")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::ShortName, enUS), - QString("W. Europe Daylight Time")); - QCOMPARE(tzp.displayName(QTimeZone::DaylightTime, QTimeZone::OffsetName, enUS), - QString("UTC+02:00")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::LongName, enUS), - QString("(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::ShortName, enUS), - QString("(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna")); - QCOMPARE(tzp.displayName(QTimeZone::GenericTime, QTimeZone::OffsetName, enUS), - QString("UTC+01:00")); + ZONE_DNAME_CHECK(StandardTime, LongName, "W. Europe Standard Time"); + ZONE_DNAME_CHECK(StandardTime, ShortName, "W. Europe Standard Time"); + ZONE_DNAME_CHECK(StandardTime, OffsetName, "UTC+01:00"); + ZONE_DNAME_CHECK(DaylightTime, LongName, "W. Europe Daylight Time"); + ZONE_DNAME_CHECK(DaylightTime, ShortName, "W. Europe Daylight Time"); + ZONE_DNAME_CHECK(DaylightTime, OffsetName, "UTC+02:00"); + ZONE_DNAME_CHECK(GenericTime, LongName, + "(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna"); + ZONE_DNAME_CHECK(GenericTime, ShortName, + "(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna"); + ZONE_DNAME_CHECK(GenericTime, OffsetName, "UTC+01:00"); // Test Abbreviations QCOMPARE(tzp.abbreviation(std), QString("W. Europe Standard Time")); @@ -1371,18 +1691,75 @@ void tst_QTimeZone::winTest() } testCetPrivate(tzp); + if (QTest::currentTestFailed()) + return; testEpochTranPrivate(QWinTimeZonePrivate("America/Toronto")); #endif // QT_BUILD_INTERNAL && USING_WIN_TZ } +#undef ZONE_DNAME_CHECK + +void tst_QTimeZone::localeSpecificDisplayName_data() +{ +#ifdef USING_WIN_TZ + QSKIP("MS backend does not use locale parameter"); +#endif + QTest::addColumn<QByteArray>("zoneName"); + QTest::addColumn<QLocale>("locale"); + QTest::addColumn<QTimeZone::TimeType>("timeType"); + QTest::addColumn<QString>("expectedName"); + + QStringList names; + QLocale locale; + // Pick a non-system locale; German or French + if (QLocale::system().language() != QLocale::German) { + locale = QLocale(QLocale::German); + names << QString("Mitteleurop\u00e4ische Normalzeit") + << QString("Mitteleurop\u00e4ische Sommerzeit"); + } else { + locale = QLocale(QLocale::French); + names << QString("heure normale d\u2019Europe centrale") + << QString("heure d\u2019\u00E9t\u00E9 d\u2019Europe centrale"); + } + + qsizetype index = 0; + QTest::newRow("Berlin, standard time") + << QByteArray("Europe/Berlin") << locale << QTimeZone::StandardTime + << names.at(index++); + + QTest::newRow("Berlin, summer time") + << QByteArray("Europe/Berlin") << locale << QTimeZone::DaylightTime + << names.at(index++); +} + +void tst_QTimeZone::localeSpecificDisplayName() +{ + // This test checks that QTimeZone::displayName() correctly uses the + // specified locale, NOT the system locale (see QTBUG-101460). + QFETCH(QByteArray, zoneName); + QFETCH(QLocale, locale); + QFETCH(QTimeZone::TimeType, timeType); + QFETCH(QString, expectedName); + + QTimeZone zone(zoneName); + QVERIFY(zone.isValid()); + + const QString localeName = zone.displayName(timeType, QTimeZone::LongName, locale); + if (localeName.isEmpty()) // Backend doesn't know how to localize this zone's name + QEXPECT_FAIL("", "QTBUG-115158 zone name localization unknown", Continue); + QCOMPARE(localeName, expectedName); +} + #ifdef QT_BUILD_INTERNAL // Test each private produces the same basic results for CET void tst_QTimeZone::testCetPrivate(const QTimeZonePrivate &tzp) { // Known datetimes - qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); - qint64 prev = QDateTime(QDate(2011, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch(); + const auto UTC = QTimeZone::UTC; + const auto eastOneHour = QTimeZone::fromSecondsAheadOfUtc(3600); + qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0), UTC).toMSecsSinceEpoch(); + qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0), UTC).toMSecsSinceEpoch(); + qint64 prev = QDateTime(QDate(2011, 1, 1), QTime(0, 0), UTC).toMSecsSinceEpoch(); QCOMPARE(tzp.offsetFromUtc(std), 3600); QCOMPARE(tzp.offsetFromUtc(dst), 7200); @@ -1415,32 +1792,34 @@ void tst_QTimeZone::testCetPrivate(const QTimeZonePrivate &tzp) if (tzp.hasTransitions()) { QTimeZonePrivate::Data tran = tzp.nextTransition(std); // 2012-03-25 02:00 CET, +1 -> +2 - QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, Qt::UTC), - QDateTime(QDate(2012, 3, 25), QTime(2, 0), Qt::OffsetFromUTC, 3600)); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2012, 3, 25), QTime(2, 0), eastOneHour)); QCOMPARE(tran.offsetFromUtc, 7200); QCOMPARE(tran.standardTimeOffset, 3600); QCOMPARE(tran.daylightTimeOffset, 3600); tran = tzp.nextTransition(dst); // 2012-10-28 03:00 CEST, +2 -> +1 - QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, Qt::UTC), - QDateTime(QDate(2012, 10, 28), QTime(3, 0), Qt::OffsetFromUTC, 2 * 3600)); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2012, 10, 28), QTime(3, 0), + QTimeZone::fromSecondsAheadOfUtc(2 * 3600))); QCOMPARE(tran.offsetFromUtc, 3600); QCOMPARE(tran.standardTimeOffset, 3600); QCOMPARE(tran.daylightTimeOffset, 0); tran = tzp.previousTransition(std); // 2011-10-30 03:00 CEST, +2 -> +1 - QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, Qt::UTC), - QDateTime(QDate(2011, 10, 30), QTime(3, 0), Qt::OffsetFromUTC, 2 * 3600)); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2011, 10, 30), QTime(3, 0), + QTimeZone::fromSecondsAheadOfUtc(2 * 3600))); QCOMPARE(tran.offsetFromUtc, 3600); QCOMPARE(tran.standardTimeOffset, 3600); QCOMPARE(tran.daylightTimeOffset, 0); tran = tzp.previousTransition(dst); // 2012-03-25 02:00 CET, +1 -> +2 (again) - QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, Qt::UTC), - QDateTime(QDate(2012, 3, 25), QTime(2, 0), Qt::OffsetFromUTC, 3600)); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, UTC), + QDateTime(QDate(2012, 3, 25), QTime(2, 0), eastOneHour)); QCOMPARE(tran.offsetFromUtc, 7200); QCOMPARE(tran.standardTimeOffset, 3600); QCOMPARE(tran.daylightTimeOffset, 3600); @@ -1448,25 +1827,24 @@ void tst_QTimeZone::testCetPrivate(const QTimeZonePrivate &tzp) QTimeZonePrivate::DataList expected; // 2011-03-27 02:00 CET, +1 -> +2 tran.atMSecsSinceEpoch = QDateTime(QDate(2011, 3, 27), QTime(2, 0), - Qt::OffsetFromUTC, 3600).toMSecsSinceEpoch(); + eastOneHour).toMSecsSinceEpoch(); tran.offsetFromUtc = 7200; tran.standardTimeOffset = 3600; tran.daylightTimeOffset = 3600; expected << tran; // 2011-10-30 03:00 CEST, +2 -> +1 tran.atMSecsSinceEpoch = QDateTime(QDate(2011, 10, 30), QTime(3, 0), - Qt::OffsetFromUTC, 2 * 3600).toMSecsSinceEpoch(); + QTimeZone::fromSecondsAheadOfUtc(2 * 3600) + ).toMSecsSinceEpoch(); tran.offsetFromUtc = 3600; tran.standardTimeOffset = 3600; tran.daylightTimeOffset = 0; expected << tran; QTimeZonePrivate::DataList result = tzp.transitions(prev, std); - QCOMPARE(result.count(), expected.count()); - for (int i = 0; i < expected.count(); ++i) { - QCOMPARE(QDateTime::fromMSecsSinceEpoch(result.at(i).atMSecsSinceEpoch, - Qt::OffsetFromUTC, 3600), - QDateTime::fromMSecsSinceEpoch(expected.at(i).atMSecsSinceEpoch, - Qt::OffsetFromUTC, 3600)); + QCOMPARE(result.size(), expected.size()); + for (int i = 0; i < expected.size(); ++i) { + QCOMPARE(QDateTime::fromMSecsSinceEpoch(result.at(i).atMSecsSinceEpoch, eastOneHour), + QDateTime::fromMSecsSinceEpoch(expected.at(i).atMSecsSinceEpoch, eastOneHour)); QCOMPARE(result.at(i).offsetFromUtc, expected.at(i).offsetFromUtc); QCOMPARE(result.at(i).standardTimeOffset, expected.at(i).standardTimeOffset); QCOMPARE(result.at(i).daylightTimeOffset, expected.at(i).daylightTimeOffset); @@ -1480,10 +1858,13 @@ void tst_QTimeZone::testEpochTranPrivate(const QTimeZonePrivate &tzp) if (!tzp.hasTransitions()) return; // test only viable for transitions + const auto UTC = QTimeZone::UTC; + const auto hour = std::chrono::hours{1}; QTimeZonePrivate::Data tran = tzp.nextTransition(0); // i.e. first after epoch // 1970-04-26 02:00 EST, -5 -> -4 - const QDateTime after = QDateTime(QDate(1970, 4, 26), QTime(2, 0), Qt::OffsetFromUTC, -5 * 3600); - const QDateTime found = QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, Qt::UTC); + const QDateTime after = QDateTime(QDate(1970, 4, 26), QTime(2, 0), + QTimeZone::fromDurationAheadOfUtc(-5 * hour)); + const QDateTime found = QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, UTC); #ifdef USING_WIN_TZ // MS gets the date wrong: 5th April instead of 26th. QCOMPARE(found.toOffsetFromUtc(-5 * 3600).time(), after.time()); #else @@ -1494,16 +1875,16 @@ void tst_QTimeZone::testEpochTranPrivate(const QTimeZonePrivate &tzp) QCOMPARE(tran.daylightTimeOffset, 3600); // Pre-epoch time-zones might not be supported at all: - tran = tzp.nextTransition(QDateTime(QDate(1601, 1, 1), QTime(0, 0), - Qt::UTC).toMSecsSinceEpoch()); + tran = tzp.nextTransition(QDateTime(QDate(1601, 1, 1), QTime(0, 0), UTC).toMSecsSinceEpoch()); if (tran.atMSecsSinceEpoch != QTimeZonePrivate::invalidMSecs() // Toronto *did* have a transition before 1970 (DST since 1918): && tran.atMSecsSinceEpoch < 0) { // ... but, if they are, we should be able to search back to them: tran = tzp.previousTransition(0); // i.e. last before epoch // 1969-10-26 02:00 EDT, -4 -> -5 - QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, Qt::UTC), - QDateTime(QDate(1969, 10, 26), QTime(2, 0), Qt::OffsetFromUTC, -4 * 3600)); + QCOMPARE(QDateTime::fromMSecsSinceEpoch(tran.atMSecsSinceEpoch, UTC), + QDateTime(QDate(1969, 10, 26), QTime(2, 0), + QTimeZone::fromDurationAheadOfUtc(-4 * hour))); QCOMPARE(tran.offsetFromUtc, -5 * 3600); QCOMPARE(tran.standardTimeOffset, -5 * 3600); QCOMPARE(tran.daylightTimeOffset, 0); @@ -1514,5 +1895,39 @@ void tst_QTimeZone::testEpochTranPrivate(const QTimeZonePrivate &tzp) } #endif // QT_BUILD_INTERNAL +#if __cpp_lib_chrono >= 201907L +Q_DECLARE_METATYPE(const std::chrono::time_zone *); +#endif + +void tst_QTimeZone::stdCompatibility_data() +{ +#if __cpp_lib_chrono >= 201907L + QTest::addColumn<const std::chrono::time_zone *>("timeZone"); + const std::chrono::tzdb &tzdb = std::chrono::get_tzdb(); + qDebug() << "Using tzdb version:" << QByteArrayView(tzdb.version); + + for (const std::chrono::time_zone &zone : tzdb.zones) + QTest::addRow(zone.name().data()) << &zone; +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} + +void tst_QTimeZone::stdCompatibility() +{ +#if __cpp_lib_chrono >= 201907L + QFETCH(const std::chrono::time_zone *, timeZone); + QByteArrayView zoneName = QByteArrayView(timeZone->name()); + QTimeZone tz = QTimeZone::fromStdTimeZonePtr(timeZone); + if (tz.isValid()) + QVERIFY2(tz.aliasMatches(zoneName), tz.id().constData()); + else + QVERIFY(!QTimeZone::isTimeZoneIdAvailable(zoneName.toByteArray())); +#else + QSKIP("This test requires C++20's <chrono>."); +#endif +} +#endif // timezone backends + QTEST_APPLESS_MAIN(tst_QTimeZone) #include "tst_qtimezone.moc" diff --git a/tests/auto/corelib/time/qtimezone/tst_qtimezone_darwin.mm b/tests/auto/corelib/time/qtimezone/tst_qtimezone_darwin.mm index de801e55d0..f4ef15036d 100644 --- a/tests/auto/corelib/time/qtimezone/tst_qtimezone_darwin.mm +++ b/tests/auto/corelib/time/qtimezone/tst_qtimezone_darwin.mm @@ -1,40 +1,15 @@ -/**************************************************************************** -** -** Copyright (C) 2017 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QtCore/QTimeZone> -#include <QtTest/QtTest> +#include <QTest> #include <CoreFoundation/CoreFoundation.h> #include <Foundation/Foundation.h> void tst_QTimeZone_darwinTypes() { -#if !defined(QT_NO_SYSTEMLOCALE) +#if QT_CONFIG(timezone) // QTimeZone <-> CFTimeZone { QTimeZone qtTimeZone("America/Los_Angeles"); @@ -64,5 +39,5 @@ void tst_QTimeZone_darwinTypes() QVERIFY([qtTimeZone.toNSTimeZone() isEqual:nsTimeZone]); [autoreleasepool release]; } -#endif +#endif // feature timezone } diff --git a/tests/auto/corelib/time/time.pro b/tests/auto/corelib/time/time.pro deleted file mode 100644 index c917587fe7..0000000000 --- a/tests/auto/corelib/time/time.pro +++ /dev/null @@ -1,7 +0,0 @@ -TEMPLATE = subdirs -SUBDIRS = \ - qcalendar \ - qdate \ - qdatetime \ - qtime -qtConfig(timezone): SUBDIRS += qtimezone |