diff options
Diffstat (limited to 'tests/auto/corelib/kernel/qdeadlinetimer')
4 files changed, 287 insertions, 277 deletions
diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/BLACKLIST b/tests/auto/corelib/kernel/qdeadlinetimer/BLACKLIST new file mode 100644 index 0000000000..8c6c88c444 --- /dev/null +++ b/tests/auto/corelib/kernel/qdeadlinetimer/BLACKLIST @@ -0,0 +1,2 @@ +[stdchrono] +windows clang ci diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/CMakeLists.txt b/tests/auto/corelib/kernel/qdeadlinetimer/CMakeLists.txt index 933f8e937e..2031cd9d48 100644 --- a/tests/auto/corelib/kernel/qdeadlinetimer/CMakeLists.txt +++ b/tests/auto/corelib/kernel/qdeadlinetimer/CMakeLists.txt @@ -1,10 +1,19 @@ -# Generated from qdeadlinetimer.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qdeadlinetimer Test: ##################################################################### -qt_add_test(tst_qdeadlinetimer +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qdeadlinetimer LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qdeadlinetimer SOURCES tst_qdeadlinetimer.cpp + LIBRARIES + Qt::TestPrivate ) diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/qdeadlinetimer.pro b/tests/auto/corelib/kernel/qdeadlinetimer/qdeadlinetimer.pro deleted file mode 100644 index 12ad7dabc2..0000000000 --- a/tests/auto/corelib/kernel/qdeadlinetimer/qdeadlinetimer.pro +++ /dev/null @@ -1,5 +0,0 @@ -CONFIG += testcase -TARGET = tst_qdeadlinetimer -QT = core testlib -SOURCES = tst_qdeadlinetimer.cpp - diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp index db53c3f20c..79416faaf9 100644 --- a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp +++ b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp @@ -1,51 +1,42 @@ -/**************************************************************************** -** -** 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) 2016 Intel Corporation. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QtCore/QString> #include <QtCore/QTime> #include <QtCore/QDeadlineTimer> #include <QtCore/QElapsedTimer> -#include <QtTest/QtTest> +#include <QTest> +#include <QtTest/private/qcomparisontesthelper_p.h> +#include <QTimer> -#if __has_include(<chrono>) -# include <chrono> -#endif +#include <chrono> +#include <inttypes.h> static const int minResolution = 400; // the minimum resolution for the tests -Q_DECLARE_METATYPE(Qt::TimerType) +QT_BEGIN_NAMESPACE +namespace QTest { +template<> char *toString(const QDeadlineTimer &dt) +{ + if (dt.isForever()) + return qstrdup("QDeadlineTimer::Forever"); + + qint64 deadline = dt.deadlineNSecs(); + char *buf = new char[256]; + qsnprintf(buf, 256, "%lld.%09d%s", + deadline / 1000 / 1000 / 1000, qAbs(deadline) % (1000 * 1000 * 1000), + dt.hasExpired() ? " (expired)" : ""); + return buf; +} +} +QT_END_NAMESPACE class tst_QDeadlineTimer : public QObject { Q_OBJECT private Q_SLOTS: - void initTestCase_data(); + void compareCompiles(); void basics(); void foreverness(); void current(); @@ -56,12 +47,11 @@ private Q_SLOTS: void stdchrono(); }; -void tst_QDeadlineTimer::initTestCase_data() +static constexpr auto timerType = Qt::PreciseTimer; + +void tst_QDeadlineTimer::compareCompiles() { - qRegisterMetaType<Qt::TimerType>(); - QTest::addColumn<Qt::TimerType>("timerType"); - QTest::newRow("precise") << Qt::PreciseTimer; - QTest::newRow("coarse") << Qt::CoarseTimer; + QTestPrivate::testAllComparisonOperatorsCompile<QDeadlineTimer>(); } void tst_QDeadlineTimer::basics() @@ -69,20 +59,22 @@ void tst_QDeadlineTimer::basics() QDeadlineTimer deadline; QCOMPARE(deadline.timerType(), Qt::CoarseTimer); - QFETCH_GLOBAL(Qt::TimerType, timerType); deadline = QDeadlineTimer(timerType); QCOMPARE(deadline.timerType(), timerType); QVERIFY(!deadline.isForever()); QCOMPARE(deadline, QDeadlineTimer(timerType)); QVERIFY(!(deadline != QDeadlineTimer(timerType))); QVERIFY(!(deadline < QDeadlineTimer())); - QVERIFY(deadline <= QDeadlineTimer()); - QVERIFY(deadline >= QDeadlineTimer()); + QCOMPARE_LE(deadline, QDeadlineTimer()); + QCOMPARE_GE(deadline, QDeadlineTimer()); QVERIFY(!(deadline > QDeadlineTimer())); QVERIFY(!(deadline < deadline)); - QVERIFY(deadline <= deadline); - QVERIFY(deadline >= deadline); + QCOMPARE_LE(deadline, deadline); + QCOMPARE_GE(deadline, deadline); QVERIFY(!(deadline > deadline)); + QT_TEST_ALL_COMPARISON_OPS(deadline, QDeadlineTimer(timerType), Qt::strong_ordering::equal); + QT_TEST_ALL_COMPARISON_OPS(deadline, QDeadlineTimer(), Qt::strong_ordering::equal); + QT_TEST_ALL_COMPARISON_OPS(QDeadlineTimer(), QDeadlineTimer(), Qt::strong_ordering::equal); // should have expired, but we may be running too early after boot QTRY_VERIFY_WITH_TIMEOUT(deadline.hasExpired(), 100); @@ -95,18 +87,18 @@ void tst_QDeadlineTimer::basics() deadline.setRemainingTime(0, timerType); QCOMPARE(deadline.remainingTime(), qint64(0)); QCOMPARE(deadline.remainingTimeNSecs(), qint64(0)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); deadline.setPreciseRemainingTime(0, 0, timerType); QCOMPARE(deadline.remainingTime(), qint64(0)); QCOMPARE(deadline.remainingTimeNSecs(), qint64(0)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); deadline.setDeadline(0, timerType); QCOMPARE(deadline.remainingTime(), qint64(0)); @@ -123,9 +115,6 @@ void tst_QDeadlineTimer::basics() void tst_QDeadlineTimer::foreverness() { - QFETCH_GLOBAL(Qt::TimerType, timerType); - // we don't check whether timerType() is our type since it's possible it detects it's forever - QDeadlineTimer deadline = QDeadlineTimer::Forever; QCOMPARE(deadline.timerType(), Qt::CoarseTimer); QVERIFY(deadline.isForever()); @@ -185,9 +174,10 @@ void tst_QDeadlineTimer::foreverness() QCOMPARE(deadline, deadline); QVERIFY(!(deadline < deadline)); - QVERIFY(deadline <= deadline); - QVERIFY(deadline >= deadline); + QCOMPARE_LE(deadline, deadline); + QCOMPARE_GE(deadline, deadline); QVERIFY(!(deadline > deadline)); + QT_TEST_ALL_COMPARISON_OPS(deadline, deadline, Qt::strong_ordering::equal); // adding to forever must still be forever QDeadlineTimer deadline2 = deadline + 1; @@ -202,9 +192,10 @@ void tst_QDeadlineTimer::foreverness() QCOMPARE(deadline2 - deadline, qint64(0)); QCOMPARE(deadline2, deadline); QVERIFY(!(deadline2 < deadline)); - QVERIFY(deadline2 <= deadline); - QVERIFY(deadline2 >= deadline); + QCOMPARE_LE(deadline2, deadline); + QCOMPARE_GE(deadline2, deadline); QVERIFY(!(deadline2 > deadline)); + QT_TEST_ALL_COMPARISON_OPS(deadline2, deadline, Qt::strong_ordering::equal); // subtracting from forever is *also* forever deadline2 = deadline - 1; @@ -219,33 +210,34 @@ void tst_QDeadlineTimer::foreverness() QCOMPARE(deadline2 - deadline, qint64(0)); QCOMPARE(deadline2, deadline); QVERIFY(!(deadline2 < deadline)); - QVERIFY(deadline2 <= deadline); - QVERIFY(deadline2 >= deadline); + QCOMPARE_LE(deadline2, deadline); + QCOMPARE_GE(deadline2, deadline); QVERIFY(!(deadline2 > deadline)); + QT_TEST_ALL_COMPARISON_OPS(deadline2, deadline, Qt::strong_ordering::equal); // compare and order against a default-constructed object QDeadlineTimer expired; QVERIFY(!(deadline == expired)); - QVERIFY(deadline != expired); + QCOMPARE_NE(deadline, expired); QVERIFY(!(deadline < expired)); QVERIFY(!(deadline <= expired)); - QVERIFY(deadline >= expired); - QVERIFY(deadline > expired); + QCOMPARE_GE(deadline, expired); + QCOMPARE_GT(deadline, expired); + QT_TEST_EQUALITY_OPS(deadline, expired, false); } void tst_QDeadlineTimer::current() { - QFETCH_GLOBAL(Qt::TimerType, timerType); auto deadline = QDeadlineTimer::current(timerType); QVERIFY(deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); QCOMPARE(deadline.remainingTime(), qint64(0)); QCOMPARE(deadline.remainingTimeNSecs(), qint64(0)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); // subtracting from current should be "more expired" QDeadlineTimer earlierDeadline = deadline - 1; @@ -254,122 +246,123 @@ void tst_QDeadlineTimer::current() QCOMPARE(earlierDeadline.timerType(), timerType); QCOMPARE(earlierDeadline.remainingTime(), qint64(0)); QCOMPARE(earlierDeadline.remainingTimeNSecs(), qint64(0)); - QVERIFY(earlierDeadline.deadline() != 0); - QVERIFY(earlierDeadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(earlierDeadline.deadlineNSecs() != 0); - QVERIFY(earlierDeadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_NE(earlierDeadline.deadline(), 0); + QCOMPARE_NE(earlierDeadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(earlierDeadline.deadlineNSecs(), 0); + QCOMPARE_NE(earlierDeadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); QCOMPARE(earlierDeadline.deadline(), deadline.deadline() - 1); QCOMPARE(earlierDeadline.deadlineNSecs(), deadline.deadlineNSecs() - 1000*1000); QCOMPARE(earlierDeadline - deadline, qint64(-1)); - QVERIFY(earlierDeadline != deadline); - QVERIFY(earlierDeadline < deadline); - QVERIFY(earlierDeadline <= deadline); + QCOMPARE_NE(earlierDeadline, deadline); + QCOMPARE_LT(earlierDeadline, deadline); + QCOMPARE_LE(earlierDeadline, deadline); QVERIFY(!(earlierDeadline >= deadline)); QVERIFY(!(earlierDeadline > deadline)); + QT_TEST_ALL_COMPARISON_OPS(earlierDeadline, deadline, Qt::strong_ordering::less); } void tst_QDeadlineTimer::deadlines() { - QFETCH_GLOBAL(Qt::TimerType, timerType); - QDeadlineTimer deadline(4 * minResolution, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTime() > (3 * minResolution)); - QVERIFY(deadline.remainingTime() <= (4 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_GT(deadline.remainingTime(), (3 * minResolution)); + QCOMPARE_LE(deadline.remainingTime(), (4 * minResolution)); + QCOMPARE_GT(deadline.remainingTimeNSecs(), (3000000 * minResolution)); + QCOMPARE_LE(deadline.remainingTimeNSecs(), (4000000 * minResolution)); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); deadline.setRemainingTime(4 * minResolution, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTime() > (3 * minResolution)); - QVERIFY(deadline.remainingTime() <= (4 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_GT(deadline.remainingTime(), (3 * minResolution)); + QCOMPARE_LE(deadline.remainingTime(), (4 * minResolution)); + QCOMPARE_GT(deadline.remainingTimeNSecs(), (3000000 * minResolution)); + QCOMPARE_LE(deadline.remainingTimeNSecs(), (4000000 * minResolution)); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); deadline.setPreciseRemainingTime(0, 4000000 * minResolution, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTime() > (3 * minResolution)); - QVERIFY(deadline.remainingTime() <= (4 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_GT(deadline.remainingTime(), (3 * minResolution)); + QCOMPARE_LE(deadline.remainingTime(), (4 * minResolution)); + QCOMPARE_GT(deadline.remainingTimeNSecs(), (3000000 * minResolution)); + QCOMPARE_LE(deadline.remainingTimeNSecs(), (4000000 * minResolution)); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); deadline.setPreciseRemainingTime(1, 0, timerType); // 1 sec QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTime() > (1000 - minResolution)); - QVERIFY(deadline.remainingTime() <= 1000); - QVERIFY(deadline.remainingTimeNSecs() > (1000 - minResolution)*1000*1000); - QVERIFY(deadline.remainingTimeNSecs() <= (1000*1000*1000)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_GT(deadline.remainingTime(), (1000 - minResolution)); + QCOMPARE_LE(deadline.remainingTime(), 1000); + QCOMPARE_GT(deadline.remainingTimeNSecs(), (1000 - minResolution)*1000*1000); + QCOMPARE_LE(deadline.remainingTimeNSecs(), (1000*1000*1000)); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); // adding to a future deadline must still be further in the future QDeadlineTimer laterDeadline = deadline + 1; QVERIFY(!laterDeadline.hasExpired()); QVERIFY(!laterDeadline.isForever()); QCOMPARE(laterDeadline.timerType(), timerType); - QVERIFY(laterDeadline.remainingTime() > (1000 - minResolution)); - QVERIFY(laterDeadline.remainingTime() <= 1001); - QVERIFY(laterDeadline.remainingTimeNSecs() > (1001 - minResolution)*1000*1000); - QVERIFY(laterDeadline.remainingTimeNSecs() <= (1001*1000*1000)); - QVERIFY(laterDeadline.deadline() != 0); - QVERIFY(laterDeadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(laterDeadline.deadlineNSecs() != 0); - QVERIFY(laterDeadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_GT(laterDeadline.remainingTime(), (1000 - minResolution)); + QCOMPARE_LE(laterDeadline.remainingTime(), 1001); + QCOMPARE_GT(laterDeadline.remainingTimeNSecs(), (1001 - minResolution)*1000*1000); + QCOMPARE_LE(laterDeadline.remainingTimeNSecs(), (1001*1000*1000)); + QCOMPARE_NE(laterDeadline.deadline(), 0); + QCOMPARE_NE(laterDeadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(laterDeadline.deadlineNSecs(), 0); + QCOMPARE_NE(laterDeadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); QCOMPARE(laterDeadline.deadline(), deadline.deadline() + 1); QCOMPARE(laterDeadline.deadlineNSecs(), deadline.deadlineNSecs() + 1000*1000); QCOMPARE(laterDeadline - deadline, qint64(1)); - QVERIFY(laterDeadline != deadline); + QCOMPARE_NE(laterDeadline, deadline); QVERIFY(!(laterDeadline < deadline)); QVERIFY(!(laterDeadline <= deadline)); - QVERIFY(laterDeadline >= deadline); - QVERIFY(laterDeadline > deadline); + QCOMPARE_GE(laterDeadline, deadline); + QCOMPARE_GT(laterDeadline, deadline); + QT_TEST_ALL_COMPARISON_OPS(laterDeadline, deadline, Qt::strong_ordering::greater); // compare and order against a default-constructed object QDeadlineTimer expired; QVERIFY(!(deadline == expired)); - QVERIFY(deadline != expired); + QCOMPARE_NE(deadline, expired); QVERIFY(!(deadline < expired)); QVERIFY(!(deadline <= expired)); - QVERIFY(deadline >= expired); - QVERIFY(deadline > expired); + QCOMPARE_GE(deadline, expired); + QCOMPARE_GT(deadline, expired); + QT_TEST_EQUALITY_OPS(deadline, expired, false); // compare and order against a forever deadline QDeadlineTimer forever_(QDeadlineTimer::Forever); + QT_TEST_EQUALITY_OPS(deadline, forever_, false); QVERIFY(!(deadline == forever_)); - QVERIFY(deadline != forever_); - QVERIFY(deadline < forever_); - QVERIFY(deadline <= forever_); + QCOMPARE_NE(deadline, forever_); + QCOMPARE_LT(deadline, forever_); + QCOMPARE_LE(deadline, forever_); QVERIFY(!(deadline >= forever_)); QVERIFY(!(deadline > forever_)); } void tst_QDeadlineTimer::setDeadline() { - QFETCH_GLOBAL(Qt::TimerType, timerType); auto now = QDeadlineTimer::current(timerType); QDeadlineTimer deadline; @@ -397,10 +390,10 @@ void tst_QDeadlineTimer::setDeadline() QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTime() > (3 * minResolution)); - QVERIFY(deadline.remainingTime() <= (4 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution)); + QCOMPARE_GT(deadline.remainingTime(), (3 * minResolution)); + QCOMPARE_LE(deadline.remainingTime(), (4 * minResolution)); + QCOMPARE_GT(deadline.remainingTimeNSecs(), (3000000 * minResolution)); + QCOMPARE_LE(deadline.remainingTimeNSecs(), (4000000 * minResolution)); QCOMPARE(deadline.deadline(), now.deadline() + 4 * minResolution); // yes, it's exact // don't check deadlineNSecs! @@ -411,17 +404,16 @@ void tst_QDeadlineTimer::setDeadline() QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTime() > (3 * minResolution)); - QVERIFY(deadline.remainingTime() <= (4 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution)); - QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution)); + QCOMPARE_GT(deadline.remainingTime(), (3 * minResolution)); + QCOMPARE_LE(deadline.remainingTime(), (4 * minResolution)); + QCOMPARE_GT(deadline.remainingTimeNSecs(), (3000000 * minResolution)); + QCOMPARE_LE(deadline.remainingTimeNSecs(), (4000000 * minResolution)); QCOMPARE(deadline.deadline(), nsec / (1000 * 1000)); QCOMPARE(deadline.deadlineNSecs(), nsec); } void tst_QDeadlineTimer::overflow() { - QFETCH_GLOBAL(Qt::TimerType, timerType); // Check the constructor for overflows (should also cover saturating the result of the deadline() method if overflowing) QDeadlineTimer now = QDeadlineTimer::current(timerType), deadline(std::numeric_limits<qint64>::max() - 1, timerType); QVERIFY(deadline.isForever() || deadline.deadline() >= now.deadline()); @@ -479,27 +471,48 @@ void tst_QDeadlineTimer::overflow() // However we are tracking the elapsed time, so it shouldn't be a problem. deadline.setPreciseRemainingTime(1, -1000, timerType); qint64 difference = (deadline.deadlineNSecs() - nsDeadline) - nsExpected; - QVERIFY(difference >= 0); // Should always be true, but just in case - QVERIFY(difference <= callTimer.nsecsElapsed()); // Ideally difference should be 0 exactly + QCOMPARE_GE(difference, 0); // Should always be true, but just in case + QCOMPARE_LE(difference, callTimer.nsecsElapsed()); // Ideally difference should be 0 exactly // Make sure setRemainingTime underflows gracefully deadline.setPreciseRemainingTime(std::numeric_limits<qint64>::min() / 10, 0, timerType); - QVERIFY(!deadline.isForever()); // On Win/macOS the above underflows, make sure we don't saturate to Forever - QVERIFY(deadline.remainingTime() == 0); + QVERIFY(deadline.isForever()); // The above could underflow, so make sure we did set to Forever + QCOMPARE(deadline.remainingTimeNSecs(), -1); + QCOMPARE(deadline.remainingTime(), -1); // If the timer is saturated we don't want to get a valid number of milliseconds - QVERIFY(deadline.deadline() == std::numeric_limits<qint64>::min()); + QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max()); // Check that the conversion to milliseconds and nanoseconds underflows gracefully deadline.setPreciseDeadline(std::numeric_limits<qint64>::min() / 10, 0, timerType); - QVERIFY(!deadline.isForever()); // On Win/macOS the above underflows, make sure we don't saturate to Forever + QVERIFY(!deadline.isForever()); // The above underflows, make sure we don't saturate to Forever QVERIFY(deadline.deadline() == std::numeric_limits<qint64>::min()); QVERIFY(deadline.deadlineNSecs() == std::numeric_limits<qint64>::min()); + + // Check that subtracting max() twice doesn't make it become positive + deadline.setPreciseDeadline(0); + deadline -= std::numeric_limits<qint64>::max(); + deadline -= std::numeric_limits<qint64>::max(); + QVERIFY(!deadline.isForever()); + QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::min()); + QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::min()); + + // Ditto for adding max() + deadline.setPreciseDeadline(0); + deadline += std::numeric_limits<qint64>::max(); + deadline += std::numeric_limits<qint64>::max(); + QVERIFY(deadline.isForever()); // it's so far in the future it's effectively forever + QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); + + // But we don't un-become forever after saturation + deadline -= std::numeric_limits<qint64>::max(); + QVERIFY(deadline.isForever()); + QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); } void tst_QDeadlineTimer::expire() { - QFETCH_GLOBAL(Qt::TimerType, timerType); - QDeadlineTimer deadline(minResolution, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); @@ -510,20 +523,17 @@ void tst_QDeadlineTimer::expire() QCOMPARE(deadline.remainingTime(), qint64(0)); QCOMPARE(deadline.remainingTimeNSecs(), qint64(0)); - QVERIFY(deadline.deadline() != 0); - QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max()); - QVERIFY(deadline.deadlineNSecs() != 0); - QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadline(), 0); + QCOMPARE_NE(deadline.deadline(), std::numeric_limits<qint64>::max()); + QCOMPARE_NE(deadline.deadlineNSecs(), 0); + QCOMPARE_NE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max()); QCOMPARE(deadline.deadlineNSecs(), previousDeadline); } void tst_QDeadlineTimer::stdchrono() { -#if !__has_include(<chrono>) - QSKIP("std::chrono not found on this system"); -#else using namespace std::chrono; - QFETCH_GLOBAL(Qt::TimerType, timerType); + using namespace std::chrono_literals; // create some forevers QDeadlineTimer deadline = milliseconds::max(); @@ -573,163 +583,157 @@ void tst_QDeadlineTimer::stdchrono() QCOMPARE(deadline.remainingTimeAsDuration(), nanoseconds::zero()); - /* - Call QTest::qSleep, and return true if the time actually slept is - within \a deviationPercent percent of the requested sleep time. - Otherwise, return false, in which case the test should to abort. - */ - auto sleepHelper = [](int ms, int deviationPercent = 10) -> bool { - auto before = steady_clock::now(); - QTest::qSleep(ms); - auto after = steady_clock::now(); - auto diff = duration_cast<milliseconds>(after - before).count(); - bool inRange = qAbs(diff - ms) < ms * deviationPercent/100.0; - if (!inRange) - qWarning() << "sleeping" << diff << "instead of" << ms << inRange; - return inRange; - }; + QDeadlineTimer now; + bool timersExecuted = false; auto steady_before = steady_clock::now(); auto system_before = system_clock::now(); - if (!sleepHelper(minResolution)) - QSKIP("Slept too long"); - auto now = QDeadlineTimer::current(timerType); - auto steady_reference = steady_clock::now(); - auto system_reference = system_clock::now(); - if (!sleepHelper(minResolution)) - QSKIP("Slept too long"); - - auto sampling_start = steady_clock::now(); - auto steady_deadline = now.deadline<steady_clock>(); - auto system_deadline = now.deadline<system_clock>(); - auto steady_after = steady_clock::now(); - auto system_after = system_clock::now(); - auto sampling_end = steady_clock::now(); - - auto sampling_diff = duration_cast<milliseconds>(sampling_end - sampling_start).count(); - if (sampling_diff > minResolution/2) { - qWarning() << "Sampling clock took" << sampling_diff << "ms"; - QSKIP("Sampling clock took too long, aborting test", Abort); - } - auto total_diff = duration_cast<milliseconds>(steady_after - steady_before).count(); - if (total_diff >= 3*minResolution) { - qWarning() << "Measurement took" << total_diff << "ms"; - QSKIP("Measurement took too long, aborting test", Abort); + decltype(steady_before) steady_after, steady_deadline; + decltype(system_before) system_after, system_deadline; + + QTimer::singleShot(minResolution, Qt::PreciseTimer, [&]() { + now = QDeadlineTimer::current(timerType); + QTimer::singleShot(minResolution, Qt::PreciseTimer, [&]() { + steady_deadline = now.deadline<steady_clock>(); + system_deadline = now.deadline<system_clock>(); + steady_after = steady_clock::now(); + system_after = system_clock::now(); + timersExecuted = true; + }); + }); + + QTRY_VERIFY2_WITH_TIMEOUT(timersExecuted, + "Looks like timers didn't fire on time.", 4 * minResolution); + + { + qint64 before = duration_cast<nanoseconds>(steady_before.time_since_epoch()).count(); + qint64 after = duration_cast<nanoseconds>(steady_after.time_since_epoch()).count(); + QCOMPARE_GT(now.deadlineNSecs(), before); + QCOMPARE_LT(now.deadlineNSecs(), after); } { - auto reference = duration_cast<milliseconds>(steady_after - steady_reference).count(); - auto diff = duration_cast<milliseconds>(steady_after - steady_deadline).count(); - QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff))); + auto diff = duration_cast<milliseconds>(steady_after - steady_deadline); + QCOMPARE_GT(diff.count(), minResolution / 2); + QCOMPARE_LT(diff.count(), 3 * minResolution / 2); QDeadlineTimer dt_after(steady_after, timerType); - QVERIFY2(now < dt_after, - ("now = " + QLocale().toString(now.deadlineNSecs()) + - "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1()); + QCOMPARE_LT(now, dt_after); + QT_TEST_ALL_COMPARISON_OPS(now, dt_after, Qt::strong_ordering::less); - reference = duration_cast<milliseconds>(steady_reference - steady_before).count(); - diff = duration_cast<milliseconds>(steady_deadline - steady_before).count(); - QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff))); + diff = duration_cast<milliseconds>(steady_deadline - steady_before); + QCOMPARE_GT(diff.count(), minResolution / 2); + QCOMPARE_LT(diff.count(), 3 * minResolution / 2); QDeadlineTimer dt_before(steady_before, timerType); - QVERIFY2(now > dt_before, - ("now = " + QLocale().toString(now.deadlineNSecs()) + - "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1()); + QCOMPARE_GT(now, dt_before); + QT_TEST_ALL_COMPARISON_OPS(now, dt_before, Qt::strong_ordering::greater); } { - auto reference = duration_cast<milliseconds>(system_after - system_reference).count(); - auto diff = duration_cast<milliseconds>(system_after - system_deadline).count(); - QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff))); QDeadlineTimer dt_after(system_after, timerType); - QVERIFY2(now < dt_after, - ("now = " + QLocale().toString(now.deadlineNSecs()) + - "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1()); - - reference = duration_cast<milliseconds>(system_reference - system_before).count(); - diff = duration_cast<milliseconds>(steady_deadline - steady_before).count(); - QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff))); QDeadlineTimer dt_before(system_before, timerType); - QVERIFY2(now > dt_before, - ("now = " + QLocale().toString(now.deadlineNSecs()) + - "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1()); + auto diff = duration_cast<milliseconds>(system_after - system_deadline); + QCOMPARE_GT(diff.count(), minResolution / 2); + QCOMPARE_LT(diff.count(), 3 * minResolution / 2); + QDeadlineTimer dt_after(system_after, timerType); + QCOMPARE_LT(now, dt_after); + QT_TEST_ALL_COMPARISON_OPS(now, dt_after, Qt::strong_ordering::less); + + diff = duration_cast<milliseconds>(system_deadline - system_before); + QCOMPARE_GT(diff.count(), minResolution / 2); + QCOMPARE_LT(diff.count(), 3 * minResolution / 2); + QDeadlineTimer dt_before(system_before, timerType); + QCOMPARE_GT(now, dt_before); + QT_TEST_ALL_COMPARISON_OPS(now, dt_before, Qt::strong_ordering::greater); } // make it regular now = QDeadlineTimer::current(timerType); - deadline.setRemainingTime(milliseconds(4 * minResolution), timerType); + deadline.setRemainingTime(4ms * minResolution, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTimeAsDuration() > milliseconds(3 * minResolution)); - QVERIFY(deadline.remainingTimeAsDuration() < milliseconds(5 * minResolution)); - QVERIFY(deadline.remainingTimeAsDuration() > nanoseconds(3000000 * minResolution)); - QVERIFY(deadline.remainingTimeAsDuration() < nanoseconds(5000000 * minResolution)); - QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + milliseconds(3 * minResolution))); - QVERIFY(deadline.deadline<steady_clock>() < (steady_clock::now() + milliseconds(5 * minResolution))); - QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + milliseconds(3 * minResolution))); - QVERIFY(deadline.deadline<system_clock>() < (system_clock::now() + milliseconds(5 * minResolution))); - if (timerType == Qt::CoarseTimer) { - QVERIFY(deadline > (now + milliseconds(3 * minResolution))); - QVERIFY(deadline < (now + milliseconds(5 * minResolution))); - QVERIFY(deadline > (now + nanoseconds(3000000 * minResolution))); - QVERIFY(deadline < (now + nanoseconds(5000000 * minResolution))); - QVERIFY(deadline > milliseconds(3 * minResolution)); - QVERIFY(deadline < milliseconds(5 * minResolution)); - QVERIFY(deadline > nanoseconds(3000000 * minResolution)); - QVERIFY(deadline < nanoseconds(5000000 * minResolution)); - QVERIFY(deadline >= steady_clock::now()); - QVERIFY(deadline >= system_clock::now()); - } + QCOMPARE_GT(deadline.remainingTimeAsDuration(), 3ms * minResolution); + QCOMPARE_LT(deadline.remainingTimeAsDuration(), 5ms * minResolution); + QCOMPARE_GT(deadline.remainingTimeAsDuration(), 3'000'000ns * minResolution); + QCOMPARE_LT(deadline.remainingTimeAsDuration(), 5'000'000ns * minResolution); + QCOMPARE_GT(deadline.deadline<steady_clock>(), (steady_clock::now() + 3ms * minResolution)); + QCOMPARE_LT(deadline.deadline<steady_clock>(), (steady_clock::now() + 5ms * minResolution)); + QCOMPARE_GT(deadline.deadline<system_clock>(), (system_clock::now() + 3ms * minResolution)); + QCOMPARE_LT(deadline.deadline<system_clock>(), (system_clock::now() + 5ms * minResolution)); + QCOMPARE_GT((deadline.deadline<steady_clock, milliseconds>()), + steady_clock::now() + 3ms * minResolution); + QCOMPARE_LT((deadline.deadline<steady_clock, milliseconds>()), + steady_clock::now() + 5ms * minResolution); + QCOMPARE_GT((deadline.deadline<system_clock, milliseconds>()), + system_clock::now() + 3ms * minResolution); + QCOMPARE_LT((deadline.deadline<system_clock, milliseconds>()), + system_clock::now() + 5ms * minResolution); + QCOMPARE_GT(deadline, now + 3ms * minResolution); + QCOMPARE_LT(deadline, now + 5ms * minResolution); + QCOMPARE_GT(deadline, now + 3000000ns * minResolution); + QCOMPARE_LT(deadline, now + 5000000ns * minResolution); + QCOMPARE_GT(deadline, 3ms * minResolution); + QCOMPARE_LT(deadline, 5ms * minResolution); + QCOMPARE_GT(deadline, 3000000ns * minResolution); + QCOMPARE_LT(deadline, 5000000ns * minResolution); + QCOMPARE_GE(deadline, steady_clock::now()); + QCOMPARE_GE(deadline, system_clock::now()); + QT_TEST_ALL_COMPARISON_OPS(deadline, now + 3ms * minResolution, Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(deadline, now + 5ms * minResolution, Qt::strong_ordering::less); + QT_TEST_ALL_COMPARISON_OPS(deadline, now + 3000000ns * minResolution, Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(deadline, now + 5000000ns * minResolution, Qt::strong_ordering::less); + QT_TEST_ALL_COMPARISON_OPS(deadline, 3ms * minResolution, Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(deadline, 5ms * minResolution, Qt::strong_ordering::less); + QT_TEST_ALL_COMPARISON_OPS(deadline, steady_clock::now(), Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(deadline, system_clock::now(), Qt::strong_ordering::greater); now = QDeadlineTimer::current(timerType); - deadline = QDeadlineTimer(seconds(1), timerType); + deadline = QDeadlineTimer(1s, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTimeAsDuration() > (seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.remainingTimeAsDuration() <= seconds(1)); - QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + seconds(1) + milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + seconds(1) + milliseconds(minResolution))); - if (timerType == Qt::CoarseTimer) { - QVERIFY(deadline > (seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline <= seconds(1)); - } + QCOMPARE_GT(deadline.remainingTimeAsDuration(), 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.remainingTimeAsDuration(), 1s); + QCOMPARE_GT(deadline.deadline<steady_clock>(), steady_clock::now() + 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<steady_clock>(), steady_clock::now() + 1s + 1ms * minResolution); + QCOMPARE_GT(deadline.deadline<system_clock>(), system_clock::now() + 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<system_clock>(), system_clock::now() + 1s + 1ms * minResolution); + QCOMPARE_GT(deadline, 1s - 1ms * minResolution); + QCOMPARE_LE(deadline, 1s); now = QDeadlineTimer::current(timerType); - deadline.setRemainingTime(hours(1), timerType); + deadline.setRemainingTime(1h, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTimeAsDuration() > (hours(1) - milliseconds(minResolution))); - QVERIFY(deadline.remainingTimeAsDuration() <= hours(1)); - QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + hours(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + hours(1) + milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + hours(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + hours(1) + milliseconds(minResolution))); + QCOMPARE_GT(deadline.remainingTimeAsDuration(), 1h - 1ms * minResolution); + QCOMPARE_LE(deadline.remainingTimeAsDuration(), 1h); + QCOMPARE_GT(deadline.deadline<steady_clock>(), steady_clock::now() + 1h - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<steady_clock>(), steady_clock::now() + 1h + 1ms * minResolution); + QCOMPARE_GT(deadline.deadline<system_clock>(), system_clock::now() + 1h - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<system_clock>(), system_clock::now() + 1h + 1ms * minResolution); now = QDeadlineTimer::current(timerType); - deadline.setDeadline(system_clock::now() + seconds(1), timerType); + deadline.setDeadline(system_clock::now() + 1s, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTimeAsDuration() > (seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.remainingTimeAsDuration() <= seconds(1)); - QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + seconds(1) + milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + seconds(1) + milliseconds(minResolution))); + QCOMPARE_GT(deadline.remainingTimeAsDuration(), 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.remainingTimeAsDuration(), 1s); + QCOMPARE_GT(deadline.deadline<steady_clock>(), steady_clock::now() + 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<steady_clock>(), steady_clock::now() + 1s + 1ms * minResolution); + QCOMPARE_GT(deadline.deadline<system_clock>(), system_clock::now() + 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<system_clock>(), system_clock::now() + 1s + 1ms * minResolution); now = QDeadlineTimer::current(timerType); - deadline.setDeadline(steady_clock::now() + seconds(1), timerType); + deadline.setDeadline(steady_clock::now() + 1s, timerType); QVERIFY(!deadline.hasExpired()); QVERIFY(!deadline.isForever()); QCOMPARE(deadline.timerType(), timerType); - QVERIFY(deadline.remainingTimeAsDuration() > (seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.remainingTimeAsDuration() <= seconds(1)); - QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + seconds(1) + milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + seconds(1) - milliseconds(minResolution))); - QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + seconds(1) + milliseconds(minResolution))); -#endif + QCOMPARE_GT(deadline.remainingTimeAsDuration(), 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.remainingTimeAsDuration(), 1s); + QCOMPARE_GT(deadline.deadline<steady_clock>(), steady_clock::now() + 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<steady_clock>(), steady_clock::now() + 1s + 1ms * minResolution); + QCOMPARE_GT(deadline.deadline<system_clock>(), system_clock::now() + 1s - 1ms * minResolution); + QCOMPARE_LE(deadline.deadline<system_clock>(), system_clock::now() + 1s + 1ms * minResolution); } QTEST_MAIN(tst_QDeadlineTimer) |