Revision control
Copy as Markdown
// Copyright (C) 2017 Ford Motor Company
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include "rep_MyInterface_replica.h"
#include "rep_ExtPodInterface_merged.h"
#include <QCoreApplication>
#include <QtRemoteObjects/qremoteobjectnode.h>
#include <QtTest/QtTest>
class tst_Client_Process : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase()
{
m_repNode.reset(new QRemoteObjectNode);
m_rep.reset(m_repNode->acquire<MyInterfaceReplica>());
connect(m_rep.data(), &MyInterfaceReplica::notified, this, [&]() { m_notified = true; });
connect(m_rep.data(), &MyInterfaceReplica::initialValueChanged, this, [&]() {
// this value is only set when the replica first connects to the source
QCOMPARE(m_notified, false);
QCOMPARE(m_rep->initialValue(), 18);
});
QVERIFY(m_rep->waitForSource());
}
void testRun()
{
auto reply = m_rep->start();
QVERIFY(reply.waitForFinished());
// BEGIN: Testing
QSignalSpy advanceSpy(m_rep.data(), &MyInterfaceReplica::advance);
QSignalSpy spy(m_rep.data(), &MyInterfaceReplica::enum1Changed);
QVERIFY(advanceSpy.wait());
QCOMPARE(spy.size(), 2);
// END: Testing
reply = m_rep->stop();
QVERIFY(reply.waitForFinished());
}
void testEnumDetails()
{
QHash<QByteArray, int> kvs = {{"First", 0}, {"Second", 1}, {"Third", 2}};
QScopedPointer<QRemoteObjectDynamicReplica> rep(m_repNode->acquireDynamic("MyInterface"));
QVERIFY(rep->waitForSource());
auto mo = rep->metaObject();
int enumIdx = mo->indexOfEnumerator("Enum1");
QVERIFY(enumIdx != -1);
auto enumerator = mo->enumerator(enumIdx);
QCOMPARE(enumerator.name(), "Enum1");
QCOMPARE(enumerator.keyCount(), 3);
for (int i = 0; i < 3; ++i) {
auto key = enumerator.key(i);
auto val = enumerator.value(i);
auto it = kvs.find(key);
QVERIFY(it != kvs.end());
QCOMPARE(*it, val);
kvs.erase(it);
}
int propIdx = mo->indexOfProperty("enum1");
QVERIFY(propIdx != -1);
auto property = mo->property(propIdx);
property.write(rep.data(), 1);
QTRY_COMPARE(property.read(rep.data()).toInt(), 1);
}
void testMethodSignalParamDetails()
{
QScopedPointer<QRemoteObjectDynamicReplica> rep(m_repNode->acquireDynamic("MyInterface"));
QVERIFY(rep->waitForSource());
auto mo = rep->metaObject();
int signalIdx = mo->indexOfSignal("testEnumParamsInSignals(MyInterfaceReplica::Enum1,bool,QString)");
QVERIFY(signalIdx != -1);
auto simm = mo->method(signalIdx);
{
QCOMPARE(simm.parameterCount(), 3);
auto paramNames = simm.parameterNames();
QCOMPARE(paramNames.size(), 3);
QCOMPARE(paramNames.at(0), QByteArrayLiteral("enumSignalParam"));
QCOMPARE(paramNames.at(1), QByteArrayLiteral("signalParam2"));
QCOMPARE(paramNames.at(2), QByteArrayLiteral("__repc_variable_1"));
QCOMPARE(simm.parameterMetaType(0), QMetaType::fromType<MyInterfaceReplica::Enum1>());
QCOMPARE(simm.parameterMetaType(1), QMetaType::fromType<bool>());
QCOMPARE(simm.parameterMetaType(2), QMetaType::fromType<QString>());
}
int slotIdx = mo->indexOfSlot("testEnumParamsInSlots(MyInterfaceReplica::Enum1,bool,int)");
QVERIFY(slotIdx != -1);
auto slmm = mo->method(slotIdx);
{
QCOMPARE(slmm .parameterCount(), 3);
auto paramNames = slmm .parameterNames();
QCOMPARE(paramNames.size(), 3);
QCOMPARE(paramNames.at(0), QByteArrayLiteral("enumSlotParam"));
QCOMPARE(paramNames.at(1), QByteArrayLiteral("slotParam2"));
QCOMPARE(paramNames.at(2), QByteArrayLiteral("__repc_variable_1"));
}
MyInterfaceReplica::Enum1 enumVal = {};
mo->invokeMethod(rep.data(), "testEnumParamsInSlots",
Q_ARG(MyInterfaceReplica::Enum1, enumVal),
Q_ARG(bool, true), Q_ARG(int, 1234));
int enumIdx = mo->indexOfProperty("enum1");
QVERIFY(enumIdx != -1);
QTRY_COMPARE(mo->property(enumIdx).read(rep.data()).toInt(), 0);
int startedIdx = mo->indexOfProperty("started");
QVERIFY(startedIdx != -1);
QTRY_COMPARE(mo->property(startedIdx).read(rep.data()).toBool(), true);
}
void testMethodSignal()
{
QScopedPointer<MyInterfaceReplica> rep(new MyInterfaceReplica());
rep->setNode(m_repNode.get());
QVERIFY(rep->waitForSource());
rep->testEnumParamsInSlots(MyInterfaceReplica::Second, false, 74);
connect(rep.data(), &MyInterfaceReplica::testEnumParamsInSignals, this,
[](MyInterfaceReplica::Enum1 enumSignalParam) { QCOMPARE(enumSignalParam, MyInterfaceReplica::Second); });
QTRY_COMPARE(rep->enum1(), MyInterfaceReplica::Second);
QTRY_COMPARE(rep->started(), false);
}
void testExtPodListSignals()
{
QScopedPointer<MyInterfaceReplica> rep(new MyInterfaceReplica());
rep->setNode(m_repNode.get());
QVERIFY(rep->waitForSource());
auto list = QList { ExtPOD(1, 1.1f, QStringLiteral("v1")),
ExtPOD(2, 2.2f, QStringLiteral("v2")) };
rep->testExtPODListSlot(list);
QSignalSpy spy(rep.data(), &MyInterfaceReplica::testExtPODListSignal);
connect(rep.data(), &MyInterfaceReplica::testExtPODListSignal,
this, [list](const QList<ExtPOD> &l) { QCOMPARE(l, list); });
QTRY_COMPARE(spy.size(), 1);
}
void testPod()
{
QScopedPointer<QRemoteObjectDynamicReplica> podRep(m_repNode->acquireDynamic("PodInterface"));
QVERIFY(podRep->waitForSource());
QVariant value = podRep->property("myPod");
const QMetaObject *mo = value.metaType().metaObject();
const void *gadget = value.constData();
QMetaProperty iProp = mo->property(mo->indexOfProperty("i"));
QVariant iValue = iProp.readOnGadget(gadget);
QCOMPARE(iValue.toInt(), 1);
QMetaProperty fProp = mo->property(mo->indexOfProperty("f"));
QVariant fValue = fProp.readOnGadget(gadget);
QCOMPARE(fValue.toFloat(), 5.0f);
QMetaProperty sProp = mo->property(mo->indexOfProperty("s"));
QVariant sValue = sProp.readOnGadget(gadget);
QCOMPARE(sValue.toString(), QString(QLatin1String("test")));
}
void cleanupTestCase()
{
auto reply = m_rep->quit();
QVERIFY(reply.waitForFinished());
m_rep.reset();
QVERIFY(QMetaType::fromName("MyPOD").isValid());
m_repNode.reset();
QVERIFY(!QMetaType::fromName("MyPOD").isValid());
}
private:
QScopedPointer<QRemoteObjectNode> m_repNode;
QScopedPointer<MyInterfaceReplica> m_rep;
bool m_notified = false;
};
QTEST_MAIN(tst_Client_Process)
#include "main.moc"