QSignalSpy Class

Documentation des fonctions membres

template <typename PointerToMemberFunction> QSignalSpy::QSignalSpy(const QObject *object, PointerToMemberFunction signal)

Crée un nouvel objet QSignalSpy qui écoute les émissions du signal « signal » provenant de l'objet QObject object . Si QSignalSpy n'est pas en mesure d'écouter un signal valide (par exemple, parce que object est nullptr ou que signal ne désigne pas un signal valide de object), un message d'avertissement explicatif sera affiché à l'aide de qWarning() et les appels suivants à isValid() renverront false.

Exemple :

QSignalSpy spy(myPushButton, &QPushButton::clicked);

QSignalSpy::QSignalSpy(const QObject *obj, QMetaMethod signal)

Crée un nouvel objet `QSignalSpy` qui écoute les émissions du signal ` signal ` provenant de l'objet ` QObject ` obj. Si `QSignalSpy` n'est pas en mesure d'écouter un signal valide (par exemple, parce que ` obj ` est de type ` nullptr ` ou que ` signal ` ne désigne pas un signal valide de ` obj`), un message d'avertissement explicatif sera affiché à l'aide de ` qWarning()` et les appels suivants à ` isValid() ` renverront `false`.

Ce constructeur est pratique à utiliser lorsque le système de méta-objets de Qt est largement utilisé dans un test.

Exemple d'utilisation de base :

QObject object;
auto mo = object.metaObject();
auto signalIndex = mo->indexOfSignal("objectNameChanged(QString)");
auto signal = mo->method(signalIndex);

QSignalSpy spy(&object, signal);
object.setObjectName("A new object name");
QCOMPARE(spy.count(), 1);

Imaginons que nous devions vérifier si toutes les propriétés de la classe ` QWindow ` représentant les dimensions minimales et maximales sont correctement modifiables. L’exemple suivant illustre l’une des approches possibles :

void tst_QWindow::writeMinMaxDimensionalProps_data()
    QTest::addColumn<int>("propertyIndex");

    // Collect all relevant properties
    static const auto mo = QWindow::staticMetaObject;
    for (int i = mo.propertyOffset(); i < mo.propertyCount(); ++i) {
        auto property = mo.property(i);

        // ...that have type int
        if (property.type() == QVariant::Int) {
            static const QRegularExpression re("^minimum|maximum");
            const auto name = property.name();

            // ...and start with "minimum" or "maximum"
            if (re.match(name).hasMatch()) {
                QTest::addRow("%s", name) << i;
            }
        }
    }
}

void tst_QWindow::writeMinMaxDimensionalProps()
{
    QFETCH(int, propertyIndex);

    auto property = QWindow::staticMetaObject.property(propertyIndex);
    QVERIFY(property.isWritable());
    QVERIFY(property.hasNotifySignal());

    QWindow window;
    QSignalSpy spy(&window, property.notifySignal());

    QVERIFY(property.write(&window, 42));
    QCOMPARE(spy.count(), 1);
}

[explicit] QSignalSpy::QSignalSpy(const QObject *object, const char *signal)

Crée un nouvel objet `QSignalSpy` qui écoute les émissions du signal ` signal ` provenant de l'objet ` QObject ` object. Si `QSignalSpy` n'est pas en mesure d'écouter un signal valide (par exemple, parce que ` object ` est de type ` nullptr ` ou que ` signal ` ne désigne pas un signal valide de type ` object`), un message d'avertissement explicatif sera affiché à l'aide de ` qWarning()` et les appels suivants à ` isValid() ` renverront `false`.

Exemple :

QSignalSpy spy(myPushButton, SIGNAL(clicked(bool)));

[noexcept] QSignalSpy::~QSignalSpy()

Destructeur.

[noexcept] bool QSignalSpy::isValid() const

Renvoie « true » si le « signal spy » écoute un signal valide, sinon « false ».

QByteArray QSignalSpy::signal() const

Renvoie le signal normalisé que l'espion est en train d'écouter.

bool QSignalSpy::wait(int timeout)

Il s'agit d'une fonction surchargée, équivalente au passage de ` timeout ` à la surcharge de `chrono` :

wait(std::chrono::milliseconds{timeout});

Renvoie true si le signal a été émis au moins une fois dans timeout, sinon renvoie false.

[since 6.6] bool QSignalSpy::wait(std::chrono::milliseconds timeout = std::chrono::seconds{5})

Lance une boucle d'événements qui s'exécute jusqu'à ce que le signal spécifié soit reçu ou que la durée ` timeout ` soit écoulée, selon la première éventualité.

timeout est une valeur valide de type std::chrono::duration (std::chrono::seconds, std::chrono::milliseconds, etc.).

Renvoie ` true ` si le signal a été émis au moins une fois pendant ` timeout`, sinon renvoie ` false`.

Exemple :

using namespace std::chrono_literals;
QSignalSpy spy(object, signal);
spy.wait(2s);

Cette fonction a été introduite dans Qt 6.6.