def wait(self, ms): """ .. versionadded:: 1.9 Waits for ``ms`` milliseconds. While waiting, events will be processed and your test will stay responsive to user interface events or network communication. """ blocker = MultiSignalBlocker(timeout=ms, raising=False) blocker.wait()
def wait(self, ms): """ .. versionadded:: 1.9 Waits for ``ms`` milliseconds. While waiting, events will be processed and your test will stay responsive to user interface events or network communication. """ blocker = MultiSignalBlocker(timeout=ms) blocker.wait()
def waitSignals(self, signals=None, timeout=1000, raising=None): """ .. versionadded:: 1.4 Stops current test until all given signals are triggered. Used to stop the control flow of a test until all (and only all) signals are emitted or the number of milliseconds specified by ``timeout`` has elapsed. Best used as a context manager:: with qtbot.waitSignals([signal1, signal2], timeout=1000): long_function_that_calls_signals() Also, you can use the :class:`MultiSignalBlocker` directly if the context manager form is not convenient:: blocker = qtbot.waitSignals(signals, timeout=1000) long_function_that_calls_signal() blocker.wait() :param list signals: A list of :class:`Signal` objects to wait for. Set to ``None`` to just use timeout. :param int timeout: How many milliseconds to wait before resuming control flow. :param bool raising: If :class:`QtBot.SignalTimeoutError <pytestqt.plugin.SignalTimeoutError>` should be raised if a timeout occurred. This defaults to ``True`` unless ``qt_wait_signal_raising = false`` is set in the config. :returns: ``MultiSignalBlocker`` object. Call ``MultiSignalBlocker.wait()`` to wait. .. note:: Cannot have both ``signals`` and ``timeout`` equal ``None``, or else you will block indefinitely. We throw an error if this occurs. .. note:: This method is also available as ``wait_signals`` (pep-8 alias) """ if raising is None: raising = self._request.config.getini('qt_wait_signal_raising') blocker = MultiSignalBlocker(timeout=timeout, raising=raising) if signals is not None: for signal in signals: blocker._add_signal(signal) return blocker
def waitSignals(self, signals=None, timeout=1000, raising=None): """ .. versionadded:: 1.4 Stops current test until all given signals are triggered. Used to stop the control flow of a test until all (and only all) signals are emitted or the number of milliseconds specified by ``timeout`` has elapsed. Best used as a context manager:: with qtbot.waitSignals([signal1, signal2], timeout=1000): long_function_that_calls_signals() Also, you can use the :class:`MultiSignalBlocker` directly if the context manager form is not convenient:: blocker = qtbot.waitSignals(signals, timeout=1000) long_function_that_calls_signal() blocker.wait() :param list signals: A list of :class:`Signal`s to wait for. Set to ``None`` to just use timeout. :param int timeout: How many milliseconds to wait before resuming control flow. :param bool raising: If :class:`QtBot.SignalTimeoutError <pytestqt.plugin.SignalTimeoutError>` should be raised if a timeout occurred. :returns: ``MultiSignalBlocker`` object. Call ``MultiSignalBlocker.wait()`` to wait. .. note:: Cannot have both ``signals`` and ``timeout`` equal ``None``, or else you will block indefinitely. We throw an error if this occurs. """ if raising is None: raising = self._request.config.getini('qt_wait_signal_raising') blocker = MultiSignalBlocker(timeout=timeout, raising=raising) if signals is not None: for signal in signals: blocker._add_signal(signal) return blocker
def waitSignals( self, signals=None, timeout=1000, raising=None, check_params_cbs=None, order="none", ): """ .. versionadded:: 1.4 Stops current test until all given signals are triggered. Used to stop the control flow of a test until all (and only all) signals are emitted or the number of milliseconds specified by ``timeout`` has elapsed. Best used as a context manager:: with qtbot.waitSignals([signal1, signal2], timeout=1000): long_function_that_calls_signals() Also, you can use the :class:`MultiSignalBlocker` directly if the context manager form is not convenient:: blocker = qtbot.waitSignals(signals, timeout=1000) long_function_that_calls_signal() blocker.wait() :param list signals: A list of :class:`Signal` objects to wait for. Alternatively: a list of (``Signal, str``) tuples of the form ``(signal, signal_name_as_str)`` to improve the error message that is part of ``TimeoutError``. Set to ``None`` to just use timeout. :param int timeout: How many milliseconds to wait before resuming control flow. :param bool raising: If :class:`QtBot.TimeoutError <pytestqt.plugin.TimeoutError>` should be raised if a timeout occurred. This defaults to ``True`` unless ``qt_default_raising = false`` is set in the config. :param list check_params_cbs: optional list of callables that compare the provided signal parameters to some expected parameters. Each callable has to match the signature of the corresponding signal in ``signals`` (just like a slot function would) and return ``True`` if parameters match, ``False`` otherwise. Instead of a specific callable, ``None`` can be provided, to disable parameter checking for the corresponding signal. If the number of callbacks doesn't match the number of signals ``ValueError`` will be raised. :param str order: Determines the order in which to expect signals: - ``"none"``: no order is enforced - ``"strict"``: signals have to be emitted strictly in the provided order (e.g. fails when expecting signals [a, b] and [a, a, b] is emitted) - ``"simple"``: like "strict", but signals may be emitted in-between the provided ones, e.g. expected ``signals == [a, b, c]`` and actually emitted ``signals = [a, a, b, a, c]`` works (would fail with ``"strict"``). :returns: ``MultiSignalBlocker`` object. Call ``MultiSignalBlocker.wait()`` to wait. .. note:: Cannot have both ``signals`` and ``timeout`` equal ``None``, or else you will block indefinitely. We throw an error if this occurs. .. note:: This method is also available as ``wait_signals`` (pep-8 alias) """ if order not in ["none", "simple", "strict"]: raise ValueError( "order has to be set to 'none', 'simple' or 'strict'") raising = self._should_raise(raising) if check_params_cbs: if len(check_params_cbs) != len(signals): raise ValueError("Number of callbacks ({}) does not " "match number of signals ({})!".format( len(check_params_cbs), len(signals))) blocker = MultiSignalBlocker( timeout=timeout, raising=raising, order=order, check_params_cbs=check_params_cbs, ) if signals is not None: blocker.add_signals(signals) return blocker
def waitSignals(self, signals=None, timeout=1000, raising=None, check_params_cbs=None, order="none"): """ .. versionadded:: 1.4 Stops current test until all given signals are triggered. Used to stop the control flow of a test until all (and only all) signals are emitted or the number of milliseconds specified by ``timeout`` has elapsed. Best used as a context manager:: with qtbot.waitSignals([signal1, signal2], timeout=1000): long_function_that_calls_signals() Also, you can use the :class:`MultiSignalBlocker` directly if the context manager form is not convenient:: blocker = qtbot.waitSignals(signals, timeout=1000) long_function_that_calls_signal() blocker.wait() :param list signals: A list of :class:`Signal` objects to wait for. Alternatively: a list of (``Signal, str``) tuples of the form ``(signal, signal_name_as_str)`` to improve the error message that is part of ``TimeoutError``. Set to ``None`` to just use timeout. :param int timeout: How many milliseconds to wait before resuming control flow. :param bool raising: If :class:`QtBot.TimeoutError <pytestqt.plugin.TimeoutError>` should be raised if a timeout occurred. This defaults to ``True`` unless ``qt_wait_signal_raising = false`` is set in the config. :param list check_params_cbs: optional list of callables that compare the provided signal parameters to some expected parameters. Each callable has to match the signature of the corresponding signal in ``signals`` (just like a slot function would) and return ``True`` if parameters match, ``False`` otherwise. Instead of a specific callable, ``None`` can be provided, to disable parameter checking for the corresponding signal. If the number of callbacks doesn't match the number of signals ``ValueError`` will be raised. :param str order: Determines the order in which to expect signals: - ``"none"``: no order is enforced - ``"strict"``: signals have to be emitted strictly in the provided order (e.g. fails when expecting signals [a, b] and [a, a, b] is emitted) - ``"simple"``: like "strict", but signals may be emitted in-between the provided ones, e.g. expected ``signals == [a, b, c]`` and actually emitted ``signals = [a, a, b, a, c]`` works (would fail with ``"strict"``). :returns: ``MultiSignalBlocker`` object. Call ``MultiSignalBlocker.wait()`` to wait. .. note:: Cannot have both ``signals`` and ``timeout`` equal ``None``, or else you will block indefinitely. We throw an error if this occurs. .. note:: This method is also available as ``wait_signals`` (pep-8 alias) """ if order not in ["none", "simple", "strict"]: raise ValueError("order has to be set to 'none', 'simple' or 'strict'") if raising is None: raising = self._request.config.getini('qt_wait_signal_raising') if check_params_cbs: if len(check_params_cbs) != len(signals): raise ValueError("Number of callbacks ({}) does not " "match number of signals ({})!".format(len(check_params_cbs), len(signals))) blocker = MultiSignalBlocker(timeout=timeout, raising=raising, order=order, check_params_cbs=check_params_cbs) if signals is not None: blocker.add_signals(signals) return blocker