1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// 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
#include "qtestsupport_core.h"
#include <thread>
using namespace std::chrono_literals;
QT_BEGIN_NAMESPACE
/*!
\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.
\sa QTest::qSleep(), QSignalSpy::wait()
*/
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
|
