qt/qtopcua/tests/auto/codegenerator/tst_codegen.cpp

Revision control

++ // Copyright (C) 2024 basysKom GmbH, opensource@basyskom.com
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include <generated/codegentestbinarydeencoder.h>
++ #include <generated/codegentestdatatypes.h>
++ #include <generated/codegentestnodeids.h>
++ #include <generated2/csvonlytestnodeids.h>
++
++ #include <QtOpcUa/QOpcUaClient>
++ #include <QtOpcUa/QOpcUaNode>
++ #include <QtOpcUa/QOpcUaProvider>
++
++ #include <QtCore/QCoreApplication>
++ #include <QtCore/QOperatingSystemVersion>
++ #include <QtCore/QElapsedTimer>
++ #include <QtCore/QProcess>
++ #include <QtCore/QScopedPointer>
++ #include <QtNetwork/QTcpServer>
++ #include <QtNetwork//QTcpSocket>
++ #include <QtTest/QSignalSpy>
++ #include <QTest>
++
++ using namespace Qt::Literals::StringLiterals;
++
++ const auto signalSpyTimeout = std::chrono::milliseconds(10000);
++
++ class OpcuaConnector
++ {
++ public:
++ OpcuaConnector(QOpcUaClient *client, const QOpcUaEndpointDescription &endPoint)
++ : opcuaClient(client)
++ {
++ QVERIFY(opcuaClient != nullptr);
++ QSignalSpy connectedSpy(opcuaClient, &QOpcUaClient::connected);
++ QSignalSpy disconnectedSpy(opcuaClient, &QOpcUaClient::disconnected);
++ QSignalSpy stateSpy(opcuaClient, &QOpcUaClient::stateChanged);
++
++ opcuaClient->connectToEndpoint(endPoint);
++ stateSpy.wait();
++ if (stateSpy.size() != 2)
++ stateSpy.wait();
++
++ QCOMPARE(connectedSpy.size(), 1); // one connected signal fired
++ QCOMPARE(disconnectedSpy.size(), 0); // zero disconnected signals fired
++ QCOMPARE(stateSpy.size(), 2);
++ QCOMPARE(stateSpy.at(0).at(0), QOpcUaClient::ClientState::Connecting);
++ QCOMPARE(stateSpy.at(1).at(0), QOpcUaClient::ClientState::Connected);
++
++ QCOMPARE(stateSpy.at(0).at(0).value<QOpcUaClient::ClientState>(),
++ QOpcUaClient::ClientState::Connecting);
++ QCOMPARE(stateSpy.at(1).at(0).value<QOpcUaClient::ClientState>(),
++ QOpcUaClient::ClientState::Connected);
++
++ stateSpy.clear();
++ connectedSpy.clear();
++ disconnectedSpy.clear();
++
++ QVERIFY(opcuaClient->endpoint() == endPoint);
++ }
++
++ ~OpcuaConnector()
++ {
++ QSignalSpy connectedSpy(opcuaClient, &QOpcUaClient::connected);
++ QSignalSpy disconnectedSpy(opcuaClient, &QOpcUaClient::disconnected);
++ QSignalSpy stateSpy(opcuaClient, &QOpcUaClient::stateChanged);
++ QSignalSpy errorSpy(opcuaClient, &QOpcUaClient::errorChanged);
++
++ QVERIFY(opcuaClient != nullptr);
++ if (opcuaClient->state() == QOpcUaClient::Connected) {
++
++ QSignalSpy stateSpy(opcuaClient, &QOpcUaClient::stateChanged);
++
++ opcuaClient->disconnectFromEndpoint();
++ stateSpy.wait(signalSpyTimeout);
++
++ // Once the test has failed, QSignalSpy::wait() returns right away without actually waiting for anything.
++ // Processing events manually satisfies the checks below and prevents all following tests from failing
++ // because of an unexpected initial client state.
++ if (stateSpy.size() < 2) {
++ QElapsedTimer t;
++ t.start();
++ do {
++ QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
++ } while (t.durationElapsed() < signalSpyTimeout && stateSpy.size() < 2);
++ }
++
++ QVERIFY(opcuaClient->state() == QOpcUaClient::Disconnected);
++
++ QCOMPARE(connectedSpy.size(), 0);
++ QCOMPARE(disconnectedSpy.size(), 1);
++ QCOMPARE(stateSpy.size(), 2);
++ QCOMPARE(stateSpy.at(0).at(0).value<QOpcUaClient::ClientState>(),
++ QOpcUaClient::ClientState::Closing);
++ QCOMPARE(stateSpy.at(1).at(0).value<QOpcUaClient::ClientState>(),
++ QOpcUaClient::ClientState::Disconnected);
++ QCOMPARE(errorSpy.size(), 0);
++ }
++
++ opcuaClient = nullptr;
++ }
++
++ QOpcUaClient *opcuaClient;
++ };
++
++ #define defineDataMethod(name) void name()\
++ {\
++ QTest::addColumn<QOpcUaClient *>("opcuaClient");\
++ for (auto *client : std::as_const(m_clients))\
++ QTest::newRow(client->backend().toLatin1().constData()) << client;\
++ }
++
++ class Tst_GeneratedDataTypes : public QObject
++ {
++ Q_OBJECT
++
++ public:
++ Tst_GeneratedDataTypes();
++
++ private slots:
++ void initTestCase();
++ void cleanupTestCase();
++
++ defineDataMethod(checkGeneratedDecoding_data)
++ void checkGeneratedDecoding();
++ defineDataMethod(checkGeneratedEncoding_data)
++ void checkGeneratedEncoding();
++ defineDataMethod(testNodeIdsOnly_data)
++ defineDataMethod(checkRecursionLimit_data)
++ void checkRecursionLimit();
++ void testNodeIdsOnly();
++
++ private:
++ QString envOrDefault(const char *env, QString def)
++ {
++ return qEnvironmentVariableIsSet(env) ? QString::fromUtf8(qgetenv(env).constData()) : def;
++ }
++
++ QString makeTestModelId(TestModelNodeId id)
++ {
++ return QOpcUa::nodeIdFromInteger(4, static_cast<int>(id));
++ }
++
++ QUrl m_discoveryEndpoint;
++ QOpcUaProvider m_opcUa;
++ QStringList m_backends;
++ QList<QOpcUaClient *> m_clients;
++ QProcess m_serverProcess;
++ QString m_testServerPath;
++ QOpcUaEndpointDescription m_endpoint;
++ };
++
++ #define READ_VARIABLE_NODE_VALUE(NODE) \
++ { \
++ QSignalSpy attributeReadSpy(NODE.data(), &QOpcUaNode::attributeRead);\
++ NODE->readAttributes(QOpcUa::NodeAttribute::Value); \
++ attributeReadSpy.wait(signalSpyTimeout); \
++ QCOMPARE(attributeReadSpy.count(), 1); \
++ QCOMPARE(attributeReadSpy.at(0).at(0).value<QOpcUa::NodeAttributes>(), QOpcUa::NodeAttribute::Value); \
++ QCOMPARE(NODE->attributeError(QOpcUa::NodeAttribute::Value), QOpcUa::UaStatusCode::Good); \
++ }
++
++ #define WRITE_VALUE_ATTRIBUTE(NODE, VALUE, TYPE) \
++ { \
++ QSignalSpy resultSpy(NODE.data(), &QOpcUaNode::attributeWritten); \
++ NODE->writeAttribute(QOpcUa::NodeAttribute::Value, VALUE, TYPE); \
++ resultSpy.wait(signalSpyTimeout); \
++ QCOMPARE(resultSpy.size(), 1); \
++ QCOMPARE(resultSpy.at(0).at(0).value<QOpcUa::NodeAttribute>(), QOpcUa::NodeAttribute::Value); \
++ QCOMPARE(resultSpy.at(0).at(1).value<QOpcUa::UaStatusCode>(), QOpcUa::UaStatusCode::Good); \
++ }
++
++ Tst_GeneratedDataTypes::Tst_GeneratedDataTypes()
++ {
++ m_backends = QOpcUaProvider::availableBackends();
++ }
++
++ void Tst_GeneratedDataTypes::initTestCase()
++ {
++ #if defined(Q_OS_MACOS)
++ const bool runsOnCI = qgetenv("QTEST_ENVIRONMENT").split(' ').contains("ci");
++ const auto osVer = QOperatingSystemVersion::current();
++ if (runsOnCI && osVer >= QOperatingSystemVersion::MacOSTahoe)
++ QSKIP("The tests fails on macOS 26 in CI: QTBUG-139354");
++ #endif
++
++ const quint16 defaultPort = 43344;
++ const QHostAddress defaultHost(QHostAddress::LocalHost);
++
++ for (const auto &backend: std::as_const(m_backends)) {
++ QVariantMap backendOptions;
++
++ QOpcUaClient *client = m_opcUa.createClient(backend, backendOptions);
++ QVERIFY2(client != nullptr,
++ u"Loading backend failed: %1"_s.arg(backend).toLatin1().data());
++ client->setParent(this);
++ qDebug() << "Using SDK plugin:" << client->backend();
++ m_clients.append(client);
++ }
++
++ if (qEnvironmentVariableIsEmpty("OPCUA_HOST") && qEnvironmentVariableIsEmpty("OPCUA_PORT")) {
++ m_testServerPath = qApp->applicationDirPath()
++
++ #if defined(Q_OS_MACOS)
++ + "/../../open62541-testserver/open62541-testserver.app/Contents/MacOS/open62541-testserver"_L1
++ #else
++
++ #if defined(Q_OS_WIN) && !defined(TESTS_CMAKE_SPECIFIC_PATH)
++ + "/.."_L1
++ #endif
++ + "/../../open62541-testserver/open62541-testserver"_L1
++ #ifdef Q_OS_WIN
++ + ".exe"_L1
++ #endif
++
++ #endif
++ ;
++ if (!QFile::exists(m_testServerPath)) {
++ qDebug() << "Server Path:" << m_testServerPath;
++ QSKIP("all auto tests rely on an open62541-based test-server");
++ }
++
++ // In this case the test is supposed to open its own server.
++ // Unfortunately there is no way to check if the server has started up successfully
++ // because of missing error handling.
++ // This checks will detect other servers blocking the port.
++
++ // Check for running server
++ QTcpSocket socket;
++ socket.connectToHost(defaultHost, defaultPort);
++ QVERIFY2(socket.waitForConnected(1500) == false, "Server is already running");
++
++ // Check for running server which does not respond
++ QTcpServer server;
++ QVERIFY2(server.listen(defaultHost, defaultPort) == true, "Port is occupied by another process. Check for defunct server.");
++ server.close();
++
++ m_serverProcess.start(m_testServerPath);
++ QVERIFY2(m_serverProcess.waitForStarted(), qPrintable(m_serverProcess.errorString()));
++
++ // Check if server is up and running
++ QVERIFY(m_serverProcess.state() == QProcess::Running);
++
++ QTest::qSleep(100);
++ socket.connectToHost(defaultHost, defaultPort);
++ if (!socket.waitForConnected(5000))
++ {
++ bool success = false;
++ for (int i = 0; i < 50; ++i) {
++ QTest::qSleep(100);
++ socket.connectToHost(defaultHost, defaultPort);
++ if (socket.waitForConnected(5000)) {
++ success = true;
++ break;
++ }
++ }
++
++ if (!success)
++ QFAIL("Server does not run");
++ }
++
++ socket.disconnectFromHost();
++ }
++ QString host = envOrDefault("OPCUA_HOST", defaultHost.toString());
++ QString port = envOrDefault("OPCUA_PORT", QString::number(defaultPort));
++ m_discoveryEndpoint.setUrl("opc.tcp://%1:%2"_L1.arg(host, port));
++ qDebug() << "Using endpoint:" << m_discoveryEndpoint;
++
++ QOpcUaClient *client = m_clients.first();
++ if (client) {
++ QSignalSpy endpointSpy(m_clients.first(), &QOpcUaClient::endpointsRequestFinished);
++
++ client->requestEndpoints(m_discoveryEndpoint);
++ endpointSpy.wait(signalSpyTimeout);
++ QCOMPARE(endpointSpy.size(), 1);
++
++ const auto desc = endpointSpy.at(0).at(0).value<QList<QOpcUaEndpointDescription>>();
++ QVERIFY(desc.size() > 0);
++ QCOMPARE(endpointSpy.at(0).at(2).value<QUrl>(), m_discoveryEndpoint);
++
++ m_endpoint = desc.first();
++ }
++ }
++
++ void Tst_GeneratedDataTypes::checkGeneratedDecoding()
++ {
++ QFETCH(QOpcUaClient *, opcuaClient);
++ OpcuaConnector connector(opcuaClient, m_endpoint);
++
++ // Check against the default values of the test nodes on the server
++ // They must not have been modified by previous test runs if OPCUA_HOST and OPCUA_PORT is used
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_NestedStruct)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestStructType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtTestStructType>(success);
++ QVERIFY(success);
++
++ QCOMPARE(decoded.stringMember(), u"TestString"_s);
++ QCOMPARE(decoded.localizedTextMember(), QOpcUaLocalizedText(u"en"_s, u"TestText"_s));
++ QCOMPARE(decoded.qualifiedNameMember(), QOpcUaQualifiedName(1, u"TestName"_s));
++ QCOMPARE(decoded.int64ArrayMember(), QList<qint64>({ std::numeric_limits<qint64>::max(),
++ std::numeric_limits<qint64>::max() - 1,
++ std::numeric_limits<qint64>::min() }));
++ QCOMPARE(decoded.nestedStructMember().doubleSubtypeMember(), 42);
++ QCOMPARE(decoded.nestedStructArrayMember().size(), 2);
++ QCOMPARE(decoded.nestedStructArrayMember().at(0).doubleSubtypeMember(), 23);
++ QCOMPARE(decoded.nestedStructArrayMember().at(1).doubleSubtypeMember(), 42);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_UnionWithFirstMember)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestUnionType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtTestUnionType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded.switchField(), CodegenTestQtTestUnionType::SwitchField::Member1);
++ QCOMPARE(decoded.member1(), 42);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_UnionWithSecondMember)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestUnionType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtTestUnionType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded.switchField(), CodegenTestQtTestUnionType::SwitchField::Member2);
++ QCOMPARE(decoded.member2().doubleSubtypeMember(), 23);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithOptionalField)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtStructWithOptionalFieldType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtStructWithOptionalFieldType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded.mandatoryMember(), 42);
++ QVERIFY(decoded.optionalMemberSpecified());
++ QCOMPARE(decoded.optionalMember(), 23);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWihoutOptionalField)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtStructWithOptionalFieldType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtStructWithOptionalFieldType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded.mandatoryMember(), 42);
++ QVERIFY(!decoded.optionalMemberSpecified());
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithDiagnosticInfo)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestStructWithDiagnosticInfo_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtTestStructWithDiagnosticInfo>(success);
++ QVERIFY(success);
++
++ QCOMPARE(decoded.diagnosticInfoMember().hasSymbolicId(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().symbolicId(), 1);
++ QCOMPARE(decoded.diagnosticInfoMember().hasNamespaceUri(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().namespaceUri(), 2);
++ QCOMPARE(decoded.diagnosticInfoMember().hasLocalizedText(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().localizedText(), 4); // FIXME Swapped with locale due to a bug in open62541
++ QCOMPARE(decoded.diagnosticInfoMember().hasLocale(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().locale(), 3); // FIXME Swapped with localizedText due to a bug in open62541
++ QCOMPARE(decoded.diagnosticInfoMember().hasAdditionalInfo(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().additionalInfo(), u"My additional info"_s);
++ QCOMPARE(decoded.diagnosticInfoMember().hasInnerStatusCode(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().innerStatusCode(), QOpcUa::UaStatusCode::BadInternalError);
++ QCOMPARE(decoded.diagnosticInfoMember().hasInnerDiagnosticInfo(), true);
++
++ QCOMPARE(decoded.diagnosticInfoMember().innerDiagnosticInfo().hasAdditionalInfo(), true);
++ QCOMPARE(decoded.diagnosticInfoMember().innerDiagnosticInfo().additionalInfo(), u"My inner additional info"_s);
++
++ QCOMPARE(decoded.diagnosticInfoArrayMember().size(), 2);
++ QCOMPARE(decoded.diagnosticInfoArrayMember().at(0), decoded.diagnosticInfoMember());
++ QCOMPARE(decoded.diagnosticInfoArrayMember().at(1).hasLocale(), true);
++ QCOMPARE(decoded.diagnosticInfoArrayMember().at(1).locale(), 1);
++ QCOMPARE(decoded.diagnosticInfoArrayMember().at(1).hasInnerStatusCode(), true);
++ QCOMPARE(decoded.diagnosticInfoArrayMember().at(1).innerStatusCode(), QOpcUa::UaStatusCode::BadTypeMismatch);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithDataValue)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestStructWithDataValue_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtTestStructWithDataValue>(success);
++ QVERIFY(success);
++
++ const QStringList expectedValue = {
++ u"TestString 1"_s, u"TestString 2"_s,
++ u"TestString 3"_s, u"TestString 4"_s
++ };
++
++ const auto variant = decoded.dataValueMember().value().value<QOpcUaVariant>();
++ QCOMPARE(variant.isArray(), true);
++ QList<qint32> expectedDimensions = {2, 2};
++ QCOMPARE(variant.arrayDimensions(), expectedDimensions);
++ QCOMPARE(variant.type(), QOpcUaVariant::ValueType::String);
++ QCOMPARE(variant.value(), expectedValue);
++
++ QCOMPARE(decoded.dataValueMember().statusCode(), QOpcUa::UaStatusCode::BadInternalError);
++ QCOMPARE(decoded.dataValueMember().serverTimestamp(), QDateTime::fromMSecsSinceEpoch(1698655307000));
++ QCOMPARE(decoded.dataValueMember().sourceTimestamp(), QDateTime::fromMSecsSinceEpoch(1698655306000));
++ QCOMPARE(decoded.dataValueMember().serverPicoseconds(), 23);
++ QCOMPARE(decoded.dataValueMember().sourcePicoseconds(), 42);
++
++ QCOMPARE(decoded.variantMember().isArray(), false);
++ QVERIFY(decoded.variantMember().arrayDimensions().empty());
++ QCOMPARE(decoded.variantMember().type(), QOpcUaVariant::ValueType::UInt64);
++ QCOMPARE(decoded.variantMember().value().value<quint64>(), 42);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_RecursiveStruct)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext.encodingTypeId(), makeTestModelId(TestModelNodeId::QtRecursiveTestStruct_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder codec(ext);
++
++ bool success = false;
++ const auto decoded = codec.decode<CodegenTestQtRecursiveTestStruct>(success);
++ QVERIFY(success);
++
++ QCOMPARE(decoded.stringMember(), u"Outer string"_s);
++ QCOMPARE(decoded.recursiveArrayMember().size(), 2);
++ QCOMPARE(decoded.recursiveArrayMember().at(0).stringMember(), u"Nested string 1"_s);
++ QCOMPARE(decoded.recursiveArrayMember().at(0).recursiveArrayMember().size(), 1);
++ QCOMPARE(decoded.recursiveArrayMember().at(0).recursiveArrayMember().at(0).stringMember(), u"Innermost string"_s);
++ QCOMPARE(decoded.recursiveArrayMember().at(0).recursiveArrayMember().at(0).recursiveArrayMember().size(), 0);
++ QCOMPARE(decoded.recursiveArrayMember().at(1).stringMember(), u"Nested string 2"_s);
++ QCOMPARE(decoded.recursiveArrayMember().at(1).recursiveArrayMember().size(), 0);
++ }
++ }
++
++ void Tst_GeneratedDataTypes::checkGeneratedEncoding()
++ {
++ QFETCH(QOpcUaClient *, opcuaClient);
++ OpcuaConnector connector(opcuaClient, m_endpoint);
++
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_NestedStruct)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtTestStructType data;
++ data.setStringMember(u"TestString"_s);
++ data.setLocalizedTextMember(QOpcUaLocalizedText(u"en"_s, u"TestText"_s));
++ data.setQualifiedNameMember(QOpcUaQualifiedName(1, u"TestName"_s));
++ data.setInt64ArrayMember({ std::numeric_limits<qint64>::max(),
++ std::numeric_limits<qint64>::max() - 1,
++ std::numeric_limits<qint64>::min() });
++
++ CodegenTestQtInnerTestStructType i1, i2;
++ i1.setDoubleSubtypeMember(24.0);
++ i2.setDoubleSubtypeMember(43.0);
++
++ data.setNestedStructMember(i2);
++ data.setNestedStructArrayMember({ i1, i2 });
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtTestStructType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtTestStructType>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_NestedStruct)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestStructType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtTestStructType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_UnionWithFirstMember)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtTestUnionType data;
++ data.setMember1(43);
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtTestUnionType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtTestUnionType>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_UnionWithFirstMember)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestUnionType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtTestUnionType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_UnionWithSecondMember)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtInnerTestStructType inner;
++ inner.setDoubleSubtypeMember(43);
++ CodegenTestQtTestUnionType data;
++ data.setMember2(inner);
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtTestUnionType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtTestUnionType>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_UnionWithSecondMember)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestUnionType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtTestUnionType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithOptionalField)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtStructWithOptionalFieldType data;
++ data.setMandatoryMember(24);
++ data.setOptionalMemberSpecified(true);
++ data.setOptionalMember(43);
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtStructWithOptionalFieldType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtStructWithOptionalFieldType>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithOptionalField)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtStructWithOptionalFieldType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtStructWithOptionalFieldType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWihoutOptionalField)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtStructWithOptionalFieldType data;
++ data.setMandatoryMember(24);
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtStructWithOptionalFieldType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtStructWithOptionalFieldType>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWihoutOptionalField)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtStructWithOptionalFieldType_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtStructWithOptionalFieldType>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithDiagnosticInfo)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtTestStructWithDiagnosticInfo data;
++
++ QOpcUaDiagnosticInfo di1;
++ di1.setHasSymbolicId(true);
++ di1.setSymbolicId(2);
++ di1.setHasNamespaceUri(true);
++ di1.setNamespaceUri(3);
++ di1.setHasLocalizedText(true);
++ di1.setLocalizedText(4);
++ di1.setHasLocale(true);
++ di1.setLocale(5);
++ di1.setHasAdditionalInfo(true);
++ di1.setAdditionalInfo(u"My additional info"_s);
++ di1.setHasInnerStatusCode(true);
++ di1.setInnerStatusCode(QOpcUa::UaStatusCode::BadInternalError);
++ di1.setHasInnerDiagnosticInfo(true);
++
++ QOpcUaDiagnosticInfo inner;
++ inner.setHasAdditionalInfo(true);
++ inner.setAdditionalInfo(u"My inner additional info"_s);
++ di1.setInnerDiagnosticInfo(inner);
++
++ QOpcUaDiagnosticInfo di2;
++ di2.setHasLocale(true);
++ di2.setLocale(1);
++ di2.setHasInnerStatusCode(true);
++ di2.setInnerStatusCode(QOpcUa::UaStatusCode::BadAlreadyExists);
++
++ data.setDiagnosticInfoMember(di1);
++ data.setDiagnosticInfoArrayMember({ di1, di2 });
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtTestStructWithDiagnosticInfo_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtTestStructWithDiagnosticInfo>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithDiagnosticInfo)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestStructWithDiagnosticInfo_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtTestStructWithDiagnosticInfo>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithDataValue)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtTestStructWithDataValue data;
++
++ QOpcUaDataValue dv;
++ dv.setValue(QOpcUaVariant(QOpcUaVariant::ValueType::Double, 23.0));
++ dv.setStatusCode(QOpcUa::UaStatusCode::UncertainInitialValue);
++ dv.setSourceTimestamp(QDateTime::currentDateTime());
++ dv.setSourcePicoseconds(24);
++ dv.setServerTimestamp(QDateTime::currentDateTime());
++ dv.setServerPicoseconds(43);
++ data.setDataValueMember(dv);
++
++ QOpcUaVariant var;
++ var.setArrayDimensions({ 3, 3});
++ var.setValue(QOpcUaVariant::ValueType::Double,
++ QVariant::fromValue(QList<double>{ 1, 2, 3, 4, 5, 6, 7, 8, 9 }));
++ data.setVariantMember(var);
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtTestStructWithDataValue_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtTestStructWithDataValue>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_StructWithDataValue)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtTestStructWithDataValue_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtTestStructWithDataValue>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++
++ {
++ QScopedPointer<QOpcUaNode> node(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_RecursiveStruct)));
++ QVERIFY(node != nullptr);
++
++ CodegenTestQtRecursiveTestStruct data;
++ CodegenTestQtRecursiveTestStruct nested1;
++ CodegenTestQtRecursiveTestStruct innermost;
++ CodegenTestQtRecursiveTestStruct nested2;
++
++ data.setStringMember(u"My outer string"_s);
++ nested1.setStringMember(u"My nested string 1"_s);
++ nested2.setStringMember(u"My nested string 2"_s);
++ innermost.setStringMember(u"My innermost string"_s);
++ nested2.setRecursiveArrayMember({ innermost });
++ data.setRecursiveArrayMember({ nested1, nested2 });
++
++ QOpcUaExtensionObject ext(makeTestModelId(TestModelNodeId::QtRecursiveTestStruct_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder encoder(ext);
++ QCOMPARE(encoder.encode<CodegenTestQtRecursiveTestStruct>(data), true);
++
++ WRITE_VALUE_ATTRIBUTE(node, ext, QOpcUa::Types::ExtensionObject);
++ node.reset(opcuaClient->node(makeTestModelId(TestModelNodeId::DecoderTestNodes_RecursiveStruct)));
++ QVERIFY(node != nullptr);
++ READ_VARIABLE_NODE_VALUE(node);
++
++ auto ext2 = node->valueAttribute().value<QOpcUaExtensionObject>();
++ QCOMPARE(ext2.encodingTypeId(), makeTestModelId(TestModelNodeId::QtRecursiveTestStruct_Encoding_DefaultBinary));
++ CodegenTestBinaryDeEncoder decoder(ext2);
++
++ bool success = false;
++ const auto decoded = decoder.decode<CodegenTestQtRecursiveTestStruct>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, data);
++ }
++ }
++
++ void Tst_GeneratedDataTypes::checkRecursionLimit()
++ {
++ CodegenTestQtRecursiveTestStruct outer;
++ for (int i = 0; i < 499; ++i) {
++ CodegenTestQtRecursiveTestStruct next;
++ next.setRecursiveArrayMember({ outer });
++ outer = next;
++ }
++
++ // 500 levels, should be ok
++ {
++ QByteArray data;
++ CodegenTestBinaryDeEncoder decoder(&data);
++ bool success = decoder.encode(outer);
++ QVERIFY(success);
++
++ const auto decoded = decoder.decode<CodegenTestQtRecursiveTestStruct>(success);
++ QVERIFY(success);
++ QCOMPARE(decoded, outer);
++ }
++
++ // 501 levels, failure expected
++ {
++ CodegenTestQtRecursiveTestStruct next;
++ next.setRecursiveArrayMember({ outer });
++ outer = next;
++
++ QByteArray data;
++ CodegenTestBinaryDeEncoder decoder(&data);
++ bool success = decoder.encode(outer);
++ QVERIFY(success);
++
++ const auto decoded = decoder.decode<CodegenTestQtRecursiveTestStruct>(success);
++ QVERIFY(!success);
++ QCOMPARE(decoded, {});
++ }
++ }
++
++ void Tst_GeneratedDataTypes::testNodeIdsOnly()
++ {
++ QCOMPARE(static_cast<int>(CsvOnlyTestNodeId::Unknown), 0);
++ QCOMPARE(static_cast<int>(CsvOnlyTestNodeId::TestId1), 1);
++ QCOMPARE(static_cast<int>(CsvOnlyTestNodeId::TestId2), 2);
++ QCOMPARE(static_cast<int>(CsvOnlyTestNodeId::TestId3), 3);
++ }
++
++ void Tst_GeneratedDataTypes::cleanupTestCase()
++ {
++ if (m_serverProcess.state() == QProcess::Running) {
++ m_serverProcess.kill();
++ m_serverProcess.waitForFinished(2000);
++ }
++ }
++
++ int main(int argc, char *argv[])
++ {
++ QCoreApplication app(argc, argv);
++
++ QTEST_SET_MAIN_SOURCE_PATH
++
++ // run tests for all available backends
++ QStringList availableBackends = QOpcUaProvider::availableBackends();
++ if (availableBackends.empty()) {
++ qDebug("No OPCUA backends found, skipping tests.");
++ return EXIT_SUCCESS;
++ }
++
++ Tst_GeneratedDataTypes tc;
++ return QTest::qExec(&tc, argc, argv);
++ }
++
++ #include "tst_codegen.moc"
++