qiurui
/
qtbase
mirror of https://github.com/qt/qtbase.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge integration refs/builds/qtci/dev/1618564901

This commit is contained in:
Qt CI Bot 2021-04-16 15:28:18 +00:00
parent 07d4a981a2 54730b31fa
commit 931929865f
7 changed files with 194 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
examples/widgets/widgets/calendarwidget/window.cpp
View File

@ -237,6 +237,9 @@ void Window::createPreviewGroupBox()
}
//! [9]
// TODO: use loc.name() as label (but has underscore in place of slash)
// TODO: use locale() == loc instead of only comparing language and territory
// Needs someone familiar with this example to work out ramifications
//! [10]
void Window::createGeneralOptionsGroupBox()
{
@ -247,15 +250,16 @@ void Window::createGeneralOptionsGroupBox()
int index = 0;
for (int _lang = QLocale::C; _lang <= QLocale::LastLanguage; ++_lang) {
QLocale::Language lang = static_cast<QLocale::Language>(_lang);
const auto territories = QLocale::territoriesForLanguage(lang);
for (auto territory : territories) {
const auto locales =
QLocale::matchingLocales(lang, QLocale::AnyScript, QLocale::AnyTerritory);
for (auto loc : locales) {
QString label = QLocale::languageToString(lang);
auto territory = loc.territory();
label += QLatin1Char('/');
label += QLocale::territoryToString(territory);
QLocale locale(lang, territory);
if (this->locale().language() == lang && this->locale().territory() == territory)
if (locale().language() == lang && locale().territory() == territory)
curLocaleIndex = index;
localeCombo->addItem(label, locale);
localeCombo->addItem(label, loc);
++index;
}
}

38
src/corelib/text/qlocale.cpp
View File

@ -2653,38 +2653,9 @@ QList<QLocale> QLocale::matchingLocales(QLocale::Language language, QLocale::Scr
return result;
}
/*!
\since 6.2
Returns the list of countries that have entries for \a language in Qt's locale
database. If the result is an empty list, then \a language is not represented in
Qt's locale database.
\sa matchingLocales()
*/
QList<QLocale::Territory> QLocale::territoriesForLanguage(QLocale::Language language)
{
QList<Territory> result;
if (language == C) {
result << AnyTerritory;
return result;
}
unsigned language_id = language;
const QLocaleData *data = locale_data + locale_index[language_id];
while (data->m_language_id == language_id) {
const QLocale::Territory territory = static_cast<Territory>(data->m_territory_id);
if (!result.contains(territory))
result.append(territory);
++data;
}
return result;
}
#if QT_DEPRECATED_SINCE(6, 6)
/*!
\obsolete Use territoriesForLanguage(Language) instead.
\obsolete Use matchingLocales() instead and consult the territory() of each.
\since 4.3
Returns the list of countries that have entries for \a language in Qt's locale
@ -2695,7 +2666,12 @@ QList<QLocale::Territory> QLocale::territoriesForLanguage(QLocale::Language lang
*/
QList<QLocale::Country> QLocale::countriesForLanguage(Language language)
{
return territoriesForLanguage(language);
const auto locales = matchingLocales(language, AnyScript, AnyCountry);
QList<QLocale::Country> result;
result.reserve(locales.size());
for (const auto &locale : locales)
result.append(locale.territory());
return result;
}
#endif

6
src/corelib/text/qlocale.h
View File

@ -1108,10 +1108,10 @@ public:
static QLocale c() { return QLocale(C); }
static QLocale system();
static QList<QLocale> matchingLocales(QLocale::Language language, QLocale::Script script, QLocale::Territory territory);
static QList<Territory> territoriesForLanguage(Language lang);
static QList<QLocale> matchingLocales(QLocale::Language language, QLocale::Script script,
QLocale::Territory territory);
#if QT_DEPRECATED_SINCE(6, 6)
QT_DEPRECATED_VERSION_X_6_6("Use territoriesForLanguage(Language) instead")
QT_DEPRECATED_VERSION_X_6_6("Query territory() on each entry from matchingLocales() instead")
static QList<Country> countriesForLanguage(Language lang);
#endif

272
src/corelib/time/qdatetime.cpp
View File

@ -84,7 +84,7 @@ enum : qint64 {
SECS_PER_MIN = 60,
MSECS_PER_MIN = 60000,
MSECS_PER_SEC = 1000,
TIME_T_MAX = 2145916799, // int maximum 2037-12-31T23:59:59 UTC
TIME_T_MAX = std::numeric_limits<time_t>::max(),
JULIAN_DAY_FOR_EPOCH = 2440588 // result of julianDayFromDate(1970, 1, 1)
};
@ -2430,15 +2430,15 @@ int QDateTimeParser::startsWithLocalTimeZone(QStringView name)
}
#endif // datetimeparser
// Calls the platform variant of mktime for the given date, time and daylightStatus,
// and updates the date, time, daylightStatus and abbreviation with the returned values
// If the date falls outside the 1970 to 2037 range supported by mktime / time_t
// then null date/time will be returned, you should adjust the date first if
// you need a guaranteed result.
// Calls the platform variant of mktime for the given date, time and
// daylightStatus, and updates the date, time, daylightStatus and abbreviation
// with the returned values. If the date falls outside the time_t range
// supported by mktime, then date/time will not be updated and *ok is set false.
static qint64 qt_mktime(QDate *date, QTime *time, QDateTimePrivate::DaylightStatus *daylightStatus,
QString *abbreviation, bool *ok = nullptr)
QString *abbreviation, bool *ok)
{
const qint64 msec = time->msec();
Q_ASSERT(ok);
qint64 msec = time->msec();
int yy, mm, dd;
date->getDate(&yy, &mm, &dd);
@ -2505,14 +2505,21 @@ static qint64 qt_mktime(QDate *date, QTime *time, QDateTimePrivate::DaylightStat
*daylightStatus = QDateTimePrivate::UnknownDaylightTime;
if (abbreviation)
*abbreviation = QString();
if (ok)
*ok = false;
*ok = false;
return 0;
}
if (ok)
*ok = true;
if (secsSinceEpoch < 0 && msec > 0) {
secsSinceEpoch++;
msec -= MSECS_PER_SEC;
}
qint64 millis;
const bool overflow =
mul_overflow(qint64(secsSinceEpoch),
std::integral_constant<qint64, MSECS_PER_SEC>(), &millis)
|| add_overflow(millis, msec, &msec);
*ok = !overflow;
return qint64(secsSinceEpoch) * MSECS_PER_SEC + msec;
return msec;
}
// Calls the platform variant of localtime for the given msecs, and updates
@ -2602,9 +2609,37 @@ static qint64 timeToMSecs(QDate date, QTime time)
+ time.msecsSinceStartOfDay();
}
/*!
\internal
Tests whether system functions can handle a given time.
On MS-systems (where time_t is 64-bit by default), the system functions only
work for dates up to the end of year 3000 (for mktime(); for _localtime64_s
it's 18 days later, but we ignore that here). On Unix the supported range
is as many seconds after the epoch as time_t can represent.
This second-range is then mapped to a millisecond range; if \a slack is
passed, the range is extended by this many milliseconds at each end. The
function returns true precisely if \a millis is within the resulting range.
*/
static inline bool millisInSystemRange(qint64 millis, qint64 slack = 0)
{
#ifdef Q_OS_WIN
const qint64 msecsMax = Q_INT64_C(32535215999999);
return millis <= msecsMax + slack;
#else
if constexpr (std::numeric_limits<qint64>::max() / MSECS_PER_SEC > TIME_T_MAX) {
const qint64 msecsMax = TIME_T_MAX * MSECS_PER_SEC;
return millis <= msecsMax + slack;
} else {
return true;
}
#endif
}
// Convert an MSecs Since Epoch into Local Time
static bool epochMSecsToLocalTime(qint64 msecs, QDate *localDate, QTime *localTime,
QDateTimePrivate::DaylightStatus *daylightStatus = nullptr)
bool QDateTimePrivate::epochMSecsToLocalTime(qint64 msecs, QDate *localDate, QTime *localTime,
QDateTimePrivate::DaylightStatus *daylightStatus)
{
if (msecs < 0) {
// Docs state any LocalTime before 1970-01-01 will *not* have any Daylight Time applied
@ -2614,12 +2649,28 @@ static bool epochMSecsToLocalTime(qint64 msecs, QDate *localDate, QTime *localTi
if (daylightStatus)
*daylightStatus = QDateTimePrivate::StandardTime;
return true;
} else if (msecs > TIME_T_MAX * MSECS_PER_SEC) {
// Docs state any LocalTime after 2037-12-31 *will* have any DST applied
// but this may fall outside the supported time_t range, so need to fake it.
// Use existing method to fake the conversion, but this is deeply flawed as it may
// apply the conversion from the wrong day number, e.g. if rule is last Sunday of month
// TODO Use QTimeZone when available to apply the future rule correctly
}
if (!millisInSystemRange(msecs)) {
// Docs state any LocalTime after 2038-01-18 *will* have any DST applied.
// When this falls outside the supported range, we need to fake it.
#if QT_CONFIG(timezone)
// Use the system time-zone.
const auto sys = QTimeZone::systemTimeZone();
if (daylightStatus) {
*daylightStatus = sys.d->isDaylightTime(msecs)
? QDateTimePrivate::DaylightTime
: QDateTimePrivate::StandardTime;
}
if (add_overflow(msecs, sys.d->offsetFromUtc(msecs) * MSECS_PER_SEC, &msecs))
return false;
msecsToTime(msecs, localDate, localTime);
return true;
#else // Kludge
// Use existing method to fake the conversion (this is deeply flawed
// as it may apply the conversion from the wrong day number, e.g. if
// rule is last Sunday of month).
QDate utcDate;
QTime utcTime;
msecsToTime(msecs, &utcDate, &utcTime);
@ -2633,49 +2684,50 @@ static bool epochMSecsToLocalTime(qint64 msecs, QDate *localDate, QTime *localTi
bool res = qt_localtime(fakeMsecs, localDate, localTime, daylightStatus);
*localDate = localDate->addDays(fakeDate.daysTo(utcDate));
return res;
} else {
// Falls inside time_t suported range so can use localtime
return qt_localtime(msecs, localDate, localTime, daylightStatus);
#endif // timezone
}
// Falls inside time_t supported range so can use localtime
return qt_localtime(msecs, localDate, localTime, daylightStatus);
}
// Convert a LocalTime expressed in local msecs encoding and the corresponding
// DST status into a UTC epoch msecs. Optionally populate the returned
// values from mktime for the adjusted local date and time.
static qint64 localMSecsToEpochMSecs(qint64 localMsecs,
QDateTimePrivate::DaylightStatus *daylightStatus,
QDate *localDate = nullptr, QTime *localTime = nullptr,
QString *abbreviation = nullptr)
qint64 QDateTimePrivate::localMSecsToEpochMSecs(qint64 localMsecs,
QDateTimePrivate::DaylightStatus *daylightStatus,
QDate *localDate, QTime *localTime,
QString *abbreviation)
{
QDate dt;
QTime tm;
msecsToTime(localMsecs, &dt, &tm);
const qint64 msecsMax = TIME_T_MAX * MSECS_PER_SEC;
// First, if localMsecs is within +/- 1 day of viable range, try mktime() in
// case it does fall in the range and gets proper DST conversion:
if (localMsecs >= -MSECS_PER_DAY && millisInSystemRange(localMsecs, MSECS_PER_DAY)) {
bool valid;
const qint64 utcMsecs = qt_mktime(&dt, &tm, daylightStatus, abbreviation, &valid);
if (valid && utcMsecs >= 0 && millisInSystemRange(utcMsecs)) {
// mktime worked and falls in valid range, so use it
if (localDate)
*localDate = dt;
if (localTime)
*localTime = tm;
return utcMsecs;
}
// Restore dt and tm, after qt_mktime() stomped them:
msecsToTime(localMsecs, &dt, &tm);
} else if (localMsecs < MSECS_PER_DAY) {
// Didn't call mktime(), but the pre-epoch code below needs mktime()'s
// implicit tzset() call to have happened.
qTzSet();
}
if (localMsecs <= MSECS_PER_DAY) {
// Would have been caught above if after UTC epoch, so is before.
// Docs state any LocalTime before 1970-01-01 will *not* have any DST applied
// First, if localMsecs is within +/- 1 day of minimum time_t try mktime in case it does
// fall after minimum and needs proper DST conversion
if (localMsecs >= -MSECS_PER_DAY) {
bool valid;
qint64 utcMsecs = qt_mktime(&dt, &tm, daylightStatus, abbreviation, &valid);
if (valid && utcMsecs >= 0) {
// mktime worked and falls in valid range, so use it
if (localDate)
*localDate = dt;
if (localTime)
*localTime = tm;
return utcMsecs;
}
} else {
// If we don't call mktime then need to call tzset to get offset
qTzSet();
}
// Time is clearly before 1970-01-01 so just use standard offset to convert
qint64 utcMsecs = localMsecs + qt_timezone() * MSECS_PER_SEC;
const qint64 utcMsecs = localMsecs + qt_timezone() * MSECS_PER_SEC;
if (localDate || localTime)
msecsToTime(localMsecs, localDate, localTime);
if (daylightStatus)
@ -2683,59 +2735,47 @@ static qint64 localMSecsToEpochMSecs(qint64 localMsecs,
if (abbreviation)
*abbreviation = qt_tzname(QDateTimePrivate::StandardTime);
return utcMsecs;
} else if (localMsecs >= msecsMax - MSECS_PER_DAY) {
// Docs state any LocalTime after 2037-12-31 *will* have any DST applied
// but this may fall outside the supported time_t range, so need to fake it.
// First, if localMsecs is within +/- 1 day of maximum time_t try mktime in case it does
// fall before maximum and can use proper DST conversion
if (localMsecs <= msecsMax + MSECS_PER_DAY) {
bool valid;
qint64 utcMsecs = qt_mktime(&dt, &tm, daylightStatus, abbreviation, &valid);
if (valid && utcMsecs <= msecsMax) {
// mktime worked and falls in valid range, so use it
if (localDate)
*localDate = dt;
if (localTime)
*localTime = tm;
return utcMsecs;
}
}
// Use existing method to fake the conversion, but this is deeply flawed as it may
// apply the conversion from the wrong day number, e.g. if rule is last Sunday of month
// TODO Use QTimeZone when available to apply the future rule correctly
int year, month, day;
dt.getDate(&year, &month, &day);
// 2037 is not a leap year, so make sure date isn't Feb 29
if (month == 2 && day == 29)
--day;
QDate fakeDate(2037, month, day);
qint64 fakeDiff = fakeDate.daysTo(dt);
qint64 utcMsecs = qt_mktime(&fakeDate, &tm, daylightStatus, abbreviation);
if (localDate)
*localDate = fakeDate.addDays(fakeDiff);
if (localTime)
*localTime = tm;
QDate utcDate;
QTime utcTime;
msecsToTime(utcMsecs, &utcDate, &utcTime);
utcDate = utcDate.addDays(fakeDiff);
utcMsecs = timeToMSecs(utcDate, utcTime);
return utcMsecs;
} else {
// Clearly falls inside 1970-2037 suported range so can use mktime
qint64 utcMsecs = qt_mktime(&dt, &tm, daylightStatus, abbreviation);
if (localDate)
*localDate = dt;
if (localTime)
*localTime = tm;
return utcMsecs;
}
// Otherwise, after the end of the system range.
#if QT_CONFIG(timezone)
// Use the system zone:
const auto sys = QTimeZone::systemTimeZone();
const qint64 utcMsecs =
QDateTimePrivate::zoneMSecsToEpochMSecs(localMsecs, sys,
QDateTimePrivate::UnknownDaylightTime,
localDate, localTime);
if (abbreviation)
*abbreviation = sys.d->abbreviation(utcMsecs);
if (daylightStatus) {
*daylightStatus = sys.d->isDaylightTime(utcMsecs)
? QDateTimePrivate::DaylightTime
: QDateTimePrivate::StandardTime;
}
return utcMsecs;
#else // Kludge
// Use existing method to fake the conversion (this is deeply flawed as it
// may apply the conversion from the wrong day number, e.g. if rule is last
// Sunday of month).
int year, month, day;
dt.getDate(&year, &month, &day);
// 2037 is not a leap year, so make sure date isn't Feb 29
if (month == 2 && day == 29)
--day;
bool ok;
QDate fakeDate(2037, month, day);
const qint64 fakeDiff = fakeDate.daysTo(dt);
const qint64 utcMsecs = qt_mktime(&fakeDate, &tm, daylightStatus, abbreviation, &ok);
Q_ASSERT(ok);
if (localDate)
*localDate = fakeDate.addDays(fakeDiff);
if (localTime)
*localTime = tm;
QDate utcDate;
QTime utcTime;
msecsToTime(utcMsecs, &utcDate, &utcTime);
return timeToMSecs(utcDate.addDays(fakeDiff), utcTime);
#endif
}
static inline bool specCanBeSmall(Qt::TimeSpec spec)
@ -2866,7 +2906,8 @@ static void refreshZonedDateTime(QDateTimeData &d, Qt::TimeSpec spec)
QTime testTime;
auto dstStatus = extractDaylightStatus(status);
if (spec == Qt::LocalTime) {
epochMSecs = localMSecsToEpochMSecs(msecs, &dstStatus, &testDate, &testTime);
epochMSecs =
QDateTimePrivate::localMSecsToEpochMSecs(msecs, &dstStatus, &testDate, &testTime);
#if QT_CONFIG(timezone)
// else spec == Qt::TimeZone, so check zone is valid:
} else if (d->m_timeZone.isValid()) {
@ -3350,14 +3391,13 @@ inline qint64 QDateTimePrivate::zoneMSecsToEpochMSecs(qint64 zoneMSecs, const QT
result. For example, adding one minute to 01:59:59 will get 03:00:00.
The range of valid dates taking DST into account is 1970-01-01 to the
present, and rules are in place for handling DST correctly until 2037-12-31,
but these could change. For dates after 2037, QDateTime makes a \e{best
guess} using the rules for year 2037, but we can't guarantee accuracy;
indeed, for \e{any} future date, the time-zone may change its rules before
that date comes around. For dates before 1970, QDateTime doesn't take DST
changes into account, even if the system's time zone database provides that
information, although it does take into account changes to the time-zone's
standard offset, where this information is available.
present, and rules are in place for handling DST correctly until 2038-01-18
(or the end of the \c time_t range, if this is later). For dates after the
end of this range, QDateTime makes a \e{best guess} using the rules for year
2037, but we can't guarantee accuracy; indeed, for \e{any} future date, the
time-zone may change its rules before that date comes around. For dates
before 1970, QDateTime uses the current abbreviation and offset of local
time's standad time.
\section2 Offsets From UTC
@ -3671,7 +3711,7 @@ QString QDateTime::timeZoneAbbreviation() const
case Qt::LocalTime: {
QString abbrev;
auto status = extractDaylightStatus(getStatus(d));
localMSecsToEpochMSecs(getMSecs(d), &status, nullptr, nullptr, &abbrev);
QDateTimePrivate::localMSecsToEpochMSecs(getMSecs(d), &status, nullptr, nullptr, &abbrev);
return abbrev;
}
}
@ -3708,7 +3748,7 @@ bool QDateTime::isDaylightTime() const
case Qt::LocalTime: {
auto status = extractDaylightStatus(getStatus(d));
if (status == QDateTimePrivate::UnknownDaylightTime)
localMSecsToEpochMSecs(getMSecs(d), &status);
QDateTimePrivate::localMSecsToEpochMSecs(getMSecs(d), &status);
return (status == QDateTimePrivate::DaylightTime);
}
}
@ -3851,7 +3891,7 @@ qint64 QDateTime::toMSecsSinceEpoch() const
if (!d.isShort())
return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
// Offset from UTC not recorded: need to recompute.
return localMSecsToEpochMSecs(getMSecs(d), &status);
return QDateTimePrivate::localMSecsToEpochMSecs(getMSecs(d), &status);
}
case Qt::TimeZone:
@ -3943,7 +3983,7 @@ void QDateTime::setMSecsSinceEpoch(qint64 msecs)
QDate dt;
QTime tm;
QDateTimePrivate::DaylightStatus dstStatus;
epochMSecsToLocalTime(msecs, &dt, &tm, &dstStatus);
QDateTimePrivate::epochMSecsToLocalTime(msecs, &dt, &tm, &dstStatus);
setDateTime(d, dt, tm);
refreshZonedDateTime(d, spec); // FIXME: we do this again, below
msecs = getMSecs(d);
@ -4151,7 +4191,7 @@ static inline void massageAdjustedDateTime(QDateTimeData &d, QDate date, QTime t
auto spec = getSpec(d);
if (spec == Qt::LocalTime) {
QDateTimePrivate::DaylightStatus status = QDateTimePrivate::UnknownDaylightTime;
localMSecsToEpochMSecs(timeToMSecs(date, time), &status, &date, &time);
QDateTimePrivate::localMSecsToEpochMSecs(timeToMSecs(date, time), &status, &date, &time);
#if QT_CONFIG(timezone)
} else if (spec == Qt::TimeZone && d->m_timeZone.isValid()) {
QDateTimePrivate::zoneMSecsToEpochMSecs(timeToMSecs(date, time),

7
src/corelib/time/qdatetime_p.h
View File

@ -118,6 +118,13 @@ public:
static QDateTime::Data create(QDate toDate, QTime toTime, const QTimeZone & timeZone);
#endif // timezone
static bool epochMSecsToLocalTime(qint64 msecs, QDate *localDate, QTime *localTime,
QDateTimePrivate::DaylightStatus *daylightStatus = nullptr);
static qint64 localMSecsToEpochMSecs(qint64 localMsecs,
QDateTimePrivate::DaylightStatus *daylightStatus,
QDate *localDate = nullptr, QTime *localTime = nullptr,
QString *abbreviation = nullptr);
StatusFlags m_status = StatusFlag(Qt::LocalTime << TimeSpecShift);
qint64 m_msecs = 0;
int m_offsetFromUtc = 0;

23
src/network/access/qnetworkdiskcache.cpp
View File

@ -53,6 +53,8 @@
#include <qcryptographichash.h>
#include <qdebug.h>
#include <memory>
#define CACHE_POSTFIX QLatin1String(".d")
#define PREPARED_SLASH QLatin1String("prepared/")
#define CACHE_VERSION 8
@ -196,7 +198,7 @@ QIODevice *QNetworkDiskCache::prepare(const QNetworkCacheMetaData &metaData)
break;
}
}
QScopedPointer<QCacheItem> cacheItem(new QCacheItem);
std::unique_ptr<QCacheItem> cacheItem = std::make_unique<QCacheItem>();
cacheItem->metaData = metaData;
QIODevice *device = nullptr;
@ -218,7 +220,7 @@ QIODevice *QNetworkDiskCache::prepare(const QNetworkCacheMetaData &metaData)
cacheItem->writeHeader(cacheItem->file);
device = cacheItem->file;
}
d->inserting[device] = cacheItem.take();
d->inserting[device] = cacheItem.release();
return device;
}
@ -395,7 +397,7 @@ QIODevice *QNetworkDiskCache::data(const QUrl &url)
qDebug() << "QNetworkDiskCache::data()" << url;
#endif
Q_D(QNetworkDiskCache);
QScopedPointer<QBuffer> buffer;
std::unique_ptr<QBuffer> buffer;
if (!url.isValid())
return nullptr;
if (d->lastItem.metaData.url() == url && d->lastItem.data.isOpen()) {
@ -417,22 +419,11 @@ QIODevice *QNetworkDiskCache::data(const QUrl &url)
buffer->setData(d->lastItem.data.data());
} else {
buffer.reset(new QBuffer);
// ### verify that QFile uses the fd size and not the file name
qint64 size = file->size() - file->pos();
const uchar *p = nullptr;
#if !defined(Q_OS_INTEGRITY)
p = file->map(file->pos(), size);
#endif
if (p) {
buffer->setData((const char *)p, size);
file.take()->setParent(buffer.data());
} else {
buffer->setData(file->readAll());
}
buffer->setData(file->readAll());
}
}
buffer->open(QBuffer::ReadOnly);
return buffer.take();
return buffer.release();
}
/*!

14
tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp
View File

@ -615,7 +615,7 @@ void tst_QDateTime::setMSecsSinceEpoch_data()
<< 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")
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(7, 28, 16));
@ -713,10 +713,7 @@ void tst_QDateTime::setMSecsSinceEpoch()
}
QCOMPARE(dt.toMSecsSinceEpoch(), msecs);
if (quint64(msecs / 1000) < 0xFFFFFFFF) {
QCOMPARE(qint64(dt.toSecsSinceEpoch()), msecs / 1000);
}
QCOMPARE(qint64(dt.toSecsSinceEpoch()), msecs / 1000);
QDateTime reference(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC);
QCOMPARE(dt, reference.addMSecs(msecs));
@ -766,11 +763,10 @@ void tst_QDateTime::fromMSecsSinceEpoch()
QCOMPARE(dtUtc.toMSecsSinceEpoch(), msecs);
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(dtOffset.toSecsSinceEpoch()), msecs / 1000);
}
QCOMPARE(qint64(dtUtc.toSecsSinceEpoch()), msecs / 1000);
QCOMPARE(qint64(dtOffset.toSecsSinceEpoch()), msecs / 1000);
QDateTime reference(QDate(1970, 1, 1), QTime(0, 0), Qt::UTC);
if (!localOverflow)