Revision control
Copy as Markdown
// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qtestsupport_core.h"
#include <thread>
using namespace std::chrono_literals;
QT_BEGIN_NAMESPACE
// ### Qt 7: reduce the default: QTBUG-138160
Q_CONSTINIT std::atomic<std::chrono::milliseconds> QTest::defaultTryTimeout{5s};
/*!
\variable QTest::defaultTryTimeout
\since 6.11
This global variable stores the default timeout used by the \c {QTRY_*}
functions and \l qWait.
The most typical use case for this variable is to modify the timeout
for an entire test:
\snippet code/src_qtestlib_qtestcase.cpp set defaultTryTimeout
However, you can also set it for a specific scope, using
\l QAtomicScopedValueRollback:
\snippet code/src_qtestlib_qtestcase.cpp rollback defaultTryTimeout
To access the value, call \c load():
\snippet code/src_qtestlib_qtestcase.cpp get defaultTryTimeout
It can also be set for a single run with the \c -trytimeout command-line
option.
*/
/*!
\overload
Sleeps for \a ms milliseconds, blocking execution of the test.
Equivalent to calling:
\code
QTest::qSleep(std::chrono::milliseconds{ms});
\endcode
*/
void QTest::qSleep(int ms)
{
QTest::qSleep(std::chrono::milliseconds{ms});
}
/*!
\since 6.7
Sleeps for \a msecs, blocking execution of the test.
This method will not do any event processing and will leave your test
unresponsive. Network communication might time out while sleeping.
Use \l {QTest::qWait()} to do non-blocking sleeping.
\a msecs must be greater than 0ms.
\note Starting from Qt 6.7, this function is implemented using
\c {std::this_thread::sleep_for}, so the accuracy of time spent depends
on the Standard Library implementation. Before Qt 6.7 this function called
either \c nanosleep() on Unix or \c Sleep() on Windows, so the accuracy of
time spent in this function depended on the operating system.
Example:
\snippet code/src_qtestlib_qtestcase.cpp 23
\sa {QTest::qWait()}
*/
void QTest::qSleep(std::chrono::milliseconds msecs)
{
Q_ASSERT(msecs > 0ms);
std::this_thread::sleep_for(msecs);
}
/*! \fn template <typename Functor> bool QTest::qWaitFor(Functor predicate, int timeout)
\since 5.10
\overload
Waits for \a timeout milliseconds or until the \a predicate returns true.
This is equivalent to calling:
\code
qWaitFor(predicate, QDeadlineTimer(timeout));
\endcode
*/
/*! \fn template <typename Functor> bool QTest::qWaitFor(Functor predicate, QDeadlineTimer deadline)
\since 6.7
Waits until \a deadline has expired, or until \a predicate returns true, whichever
happens first.
Returns \c true if \a predicate returned true at any point, otherwise returns \c false.
Example:
\snippet code/src_corelib_kernel_qtestsupport_core.cpp 2
The code above will wait for the object to become ready, for a
maximum of three seconds.
*/
/*!
\overload
Waits for \a msecs. Equivalent to calling:
\code
QTest::qWait(std::chrono::milliseconds{msecs});
\endcode
*/
Q_CORE_EXPORT void QTest::qWait(int msecs)
{
qWait(std::chrono::milliseconds{msecs});
}
/*!
\since 6.7
Waits for \a msecs. While waiting, events will be processed and
your test will stay responsive to user interface events or network communication.
Example:
\snippet code/src_corelib_kernel_qtestsupport_core.cpp 1
The code above will wait until the network server is responding for a
maximum of about 12.5 seconds.
The \l{QTRY_COMPARE()}{QTRY_*} macros are usually a better choice than
qWait(). qWait() always pauses for the full timeout, which can leave the
test idle and slow down execution.
The \c {QTRY_*} macros poll the condition until it succeeds or the timeout
expires. Your test therefore continues as soon as possible and stays more
reliable. If the condition still fails, the macros double the timeout once
and report the new value so that you can adjust it.
For example, rewrite the code above as:
\code
QTRY_VERIFY_WITH_TIMEOUT(!myNetworkServerNotResponding(), 12.5s);
\endcode
\sa QTest::qSleep(), QSignalSpy::wait(), QTRY_VERIFY_WITH_TIMEOUT()
*/
Q_CORE_EXPORT void QTest::qWait(std::chrono::milliseconds msecs)
{
// Ideally this method would be implemented in terms of qWaitFor(), with a
// predicate that always returns false, but qWaitFor() uses the 1-arg overload
// of processEvents(), which doesn't handle events posted in this round of event
// processing, which, together with the 10ms qSleep() after every processEvents(),
// lead to a 10x slow-down in some webengine tests.
Q_ASSERT(QCoreApplication::instance());
using namespace std::chrono;
QDeadlineTimer deadline(msecs, Qt::PreciseTimer);
do {
QCoreApplication::processEvents(QEventLoop::AllEvents, deadline);
QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
// If dealine is Forever, processEvents() has already looped forever
if (deadline.isForever())
break;
msecs = ceil<milliseconds>(deadline.remainingTimeAsDuration());
if (msecs == 0ms)
break;
QTest::qSleep(std::min(10ms, msecs));
} while (!deadline.hasExpired());
}
QT_END_NAMESPACE