def _processPendingEvents():
"""Process pending application events."""
# Quit the event loop when it becomes idle.
QTimer.singleShot(0, papp.quit)
papp.exec_()
def waitForSignal(sender, senderSignal, timeoutMs, expectedSignalParams=None):
""" Wait up to timeoutMs after calling sender() for senderSignal
to be emitted.
It returns True if the senderSignal was emitted; otherwise,
it returns False. If expectedSignalParams is not None, it
is compared against the parameters emitted by the senderSignal.
This function was inspired by http://stackoverflow.com/questions/2629055/qtestlib-qnetworkrequest-not-executed/2630114#2630114.
"""
# Create a single-shot timer. Could use QTimer.singleShot(),
# but can't cancel this / disconnect it.
timer = QTimer()
timer.setSingleShot(True)
# Create a slot which receives a senderSignal with any number
# of arguments. Check the arguments against their expected
# values, if requested, storing the result in senderSignalArgsWrong[0].
# (I can't use senderSignalArgsWrong = True/False, since
# non-local variables cannot be assigned in another scope).
senderSignalArgsWrong = []
def senderSignalSlot(*args):
# If the senderSignal args should be checked and they
# don't match, then they're wrong. In all other cases,
# they're right.
senderSignalArgsWrong.append(
(expectedSignalParams is not None) and
(expectedSignalParams != args) )
# We received the requested signal, so exit the event loop.
papp.quit()
# Connect both signals to a slot which quits the event loop.
senderSignal.connect(senderSignalSlot)
timer.timeout.connect(papp.quit)
# Start the sender and the timer and at the beginning of the event loop.
# Just calling sender() may cause signals emitted in sender
# not to reach their connected slots.
QTimer.singleShot(0, sender)
timer.start(timeoutMs)
# Catch any exceptions which the EventLoop would otherwise catch
# and not re-raise.
ex = []
def excepthook(type_, value, traceback):
ex.append(value)
if PRINT_EXEC_TRACKBACK:
oeh(type_, value, traceback)
oeh = sys.excepthook
sys.excepthook = excepthook
# Wait for an emitted signal.
papp.exec_()
# If an exception occurred in the event loop, re-raise it.
if ex:
raise ex[0]
# Clean up: don't allow the timer to call app.quit after this
# function exits, which would produce "interesting" behavior.
ret = timer.isActive()
timer.stop()
# Stopping the timer may not cancel timeout signals in the
# event queue. Disconnect the signal to be sure that loop
# will never receive a timeout after the function exits.
# Likewise, disconnect the senderSignal for the same reason.
senderSignal.disconnect(senderSignalSlot)
timer.timeout.disconnect(papp.quit)
# Restore the old exception hook
sys.excepthook = oeh
return ret and senderSignalArgsWrong and (not senderSignalArgsWrong[0])
