From f778074aaac5b579f7eefca30d792bb85b03af90 Mon Sep 17 00:00:00 2001 From: Rainer Keller Date: Mon, 17 Sep 2018 13:50:59 +0200 Subject: tests: Use QCOMPARE where possible Provides valuable information in the log file in case a test fails. Change-Id: I8f785722bcbf7ee7b2e6441516fddd89ed434023 Reviewed-by: Alex Blasche --- tests/auto/qopcuaclient/tst_client.cpp | 413 +++++++++++++++++---------------- 1 file changed, 207 insertions(+), 206 deletions(-) diff --git a/tests/auto/qopcuaclient/tst_client.cpp b/tests/auto/qopcuaclient/tst_client.cpp index 45310bc..8910fdb 100644 --- a/tests/auto/qopcuaclient/tst_client.cpp +++ b/tests/auto/qopcuaclient/tst_client.cpp @@ -490,7 +490,7 @@ private: NODE->readAttributes(QOpcUaNode::mandatoryBaseAttributes()); \ attributeReadSpy.wait(); \ QCOMPARE(attributeReadSpy.count(), 1); \ - QVERIFY(attributeReadSpy.at(0).at(0).value() == QOpcUaNode::mandatoryBaseAttributes()); \ + QCOMPARE(attributeReadSpy.at(0).at(0).value(), QOpcUaNode::mandatoryBaseAttributes()); \ QVERIFY(QOpcUa::isSuccessStatus(NODE->attributeError(QOpcUa::NodeAttribute::NodeId)) == true); \ QVERIFY(QOpcUa::isSuccessStatus(NODE->attributeError(QOpcUa::NodeAttribute::NodeClass)) == true); \ QVERIFY(QOpcUa::isSuccessStatus(NODE->attributeError(QOpcUa::NodeAttribute::BrowseName)) == true); \ @@ -503,7 +503,7 @@ private: NODE->readAttributes(QOpcUaNode::mandatoryBaseAttributes() | QOpcUa::NodeAttribute::Value); \ attributeReadSpy.wait(); \ QCOMPARE(attributeReadSpy.count(), 1); \ - QVERIFY(attributeReadSpy.at(0).at(0).value() == (QOpcUaNode::mandatoryBaseAttributes() | QOpcUa::NodeAttribute::Value)); \ + QCOMPARE(attributeReadSpy.at(0).at(0).value(), (QOpcUaNode::mandatoryBaseAttributes() | QOpcUa::NodeAttribute::Value)); \ QVERIFY(QOpcUa::isSuccessStatus(NODE->attributeError(QOpcUa::NodeAttribute::NodeId)) == true); \ QVERIFY(QOpcUa::isSuccessStatus(NODE->attributeError(QOpcUa::NodeAttribute::NodeClass)) == true); \ QVERIFY(QOpcUa::isSuccessStatus(NODE->attributeError(QOpcUa::NodeAttribute::BrowseName)) == true); \ @@ -592,13 +592,13 @@ void Tst_QOpcUaClient::connectToInvalid() QTest::qWait(50); if (opcuaClient->state() == QOpcUaClient::Disconnected) break; - QVERIFY(opcuaClient->state() == QOpcUaClient::Connecting); + QCOMPARE(opcuaClient->state(), QOpcUaClient::Connecting); } QVERIFY(opcuaClient->state() == QOpcUaClient::Connected || opcuaClient->state() == QOpcUaClient::Disconnected); QUrl url = opcuaClient->url(); - QVERIFY(url == QUrl("opc.tcp:127.0.0.1:1234")); + QCOMPARE(url, QUrl("opc.tcp:127.0.0.1:1234")); } void Tst_QOpcUaClient::connectAndDisconnect() @@ -620,12 +620,12 @@ void Tst_QOpcUaClient::connectInvalidPassword() opcuaClient->connectToEndpoint(url); connectSpy.wait(); - QVERIFY(connectSpy.count() == 2); - QVERIFY(connectSpy.at(0).at(0) == QOpcUaClient::Connecting); - QVERIFY(connectSpy.at(1).at(0) == QOpcUaClient::Disconnected); + QCOMPARE(connectSpy.count(), 2); + QCOMPARE(connectSpy.at(0).at(0), QOpcUaClient::Connecting); + QCOMPARE(connectSpy.at(1).at(0), QOpcUaClient::Disconnected); - QVERIFY(opcuaClient->url() == url); - QVERIFY(opcuaClient->error() == QOpcUaClient::AccessDenied); + QCOMPARE(opcuaClient->url(), url); + QCOMPARE(opcuaClient->error(), QOpcUaClient::AccessDenied); } void Tst_QOpcUaClient::connectAndDisconnectPassword() @@ -641,19 +641,19 @@ void Tst_QOpcUaClient::connectAndDisconnectPassword() opcuaClient->connectToEndpoint(url); connectSpy.wait(); - QVERIFY(connectSpy.count() == 2); - QVERIFY(connectSpy.at(0).at(0) == QOpcUaClient::Connecting); - QVERIFY(connectSpy.at(1).at(0) == QOpcUaClient::Connected); + QCOMPARE(connectSpy.count(), 2); + QCOMPARE(connectSpy.at(0).at(0), QOpcUaClient::Connecting); + QCOMPARE(connectSpy.at(1).at(0), QOpcUaClient::Connected); - QVERIFY(opcuaClient->url() == url); - QVERIFY(opcuaClient->error() == QOpcUaClient::NoError); + QCOMPARE(opcuaClient->url(), url); + QCOMPARE(opcuaClient->error(), QOpcUaClient::NoError); connectSpy.clear(); opcuaClient->disconnectFromEndpoint(); connectSpy.wait(); - QVERIFY(connectSpy.count() == 2); - QVERIFY(connectSpy.at(0).at(0) == QOpcUaClient::Closing); - QVERIFY(connectSpy.at(1).at(0) == QOpcUaClient::Disconnected); + QCOMPARE(connectSpy.count(), 2); + QCOMPARE(connectSpy.at(0).at(0), QOpcUaClient::Closing); + QCOMPARE(connectSpy.at(1).at(0), QOpcUaClient::Disconnected); } void Tst_QOpcUaClient::findServers() @@ -700,7 +700,7 @@ void Tst_QOpcUaClient::requestEndpoints() QCOMPARE(desc[0].securityMode(), QOpcUa::QEndpointDescription::MessageSecurityMode::None); QCOMPARE(desc[0].serverCertificate(), QByteArray()); - QVERIFY(desc[0].userIdentityTokens().size() == 2); + QCOMPARE(desc[0].userIdentityTokens().size(), 2); QCOMPARE(desc[0].userIdentityTokens()[0].policyId(), QStringLiteral("open62541-anonymous-policy")); QCOMPARE(desc[0].userIdentityTokens()[0].tokenType(), QOpcUa::QUserTokenPolicy::TokenType::Anonymous); QCOMPARE(desc[0].userIdentityTokens()[1].policyId(), QStringLiteral("open62541-username-policy")); @@ -799,7 +799,7 @@ void Tst_QOpcUaClient::readInvalidNode() QCOMPARE(node->attribute(QOpcUa::NodeAttribute::DisplayName), QVariant()); QCOMPARE(node->attributeError(QOpcUa::NodeAttribute::DisplayName), QOpcUa::UaStatusCode::BadNodeIdUnknown); - QVERIFY(QOpcUa::errorCategory(node->attributeError(QOpcUa::NodeAttribute::DisplayName)) == QOpcUa::ErrorCategory::NodeError); + QCOMPARE(QOpcUa::errorCategory(node->attributeError(QOpcUa::NodeAttribute::DisplayName)), QOpcUa::ErrorCategory::NodeError); QVERIFY(QOpcUa::isSuccessStatus(node->attributeError(QOpcUa::NodeAttribute::DisplayName)) == false); } @@ -858,16 +858,16 @@ void Tst_QOpcUaClient::writeMultipleAttributes() if (writeSpy.size() < 2) writeSpy.wait(); - QVERIFY(writeSpy.size() == 2); - QVERIFY(writeSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::DisplayName); - QVERIFY(writeSpy.at(0).at(1).value() == QOpcUa::UaStatusCode::BadUserAccessDenied); - QVERIFY(node->attributeError(QOpcUa::NodeAttribute::DisplayName) == QOpcUa::UaStatusCode::BadUserAccessDenied); - QVERIFY(QOpcUa::errorCategory(node->attributeError(QOpcUa::NodeAttribute::DisplayName)) == QOpcUa::ErrorCategory::PermissionError); + QCOMPARE(writeSpy.size(), 2); + QCOMPARE(writeSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::DisplayName); + QCOMPARE(writeSpy.at(0).at(1).value(), QOpcUa::UaStatusCode::BadUserAccessDenied); + QCOMPARE(node->attributeError(QOpcUa::NodeAttribute::DisplayName), QOpcUa::UaStatusCode::BadUserAccessDenied); + QCOMPARE(QOpcUa::errorCategory(node->attributeError(QOpcUa::NodeAttribute::DisplayName)), QOpcUa::ErrorCategory::PermissionError); - QVERIFY(writeSpy.at(1).at(0).value() == QOpcUa::NodeAttribute::Value); - QVERIFY(writeSpy.at(1).at(1).value() == QOpcUa::UaStatusCode::Good); - QVERIFY(node->attributeError(QOpcUa::NodeAttribute::Value) == QOpcUa::UaStatusCode::Good); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == QOpcUa::QQualifiedName(2, QStringLiteral("TestString"))); + QCOMPARE(writeSpy.at(1).at(0).value(), QOpcUa::NodeAttribute::Value); + QCOMPARE(writeSpy.at(1).at(1).value(), QOpcUa::UaStatusCode::Good); + QCOMPARE(node->attributeError(QOpcUa::NodeAttribute::Value), QOpcUa::UaStatusCode::Good); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), QOpcUa::QQualifiedName(2, QStringLiteral("TestString"))); } void Tst_QOpcUaClient::readEmptyArrayVariable() @@ -995,7 +995,7 @@ void Tst_QOpcUaClient::getRootNode() QVERIFY(root->client() == opcuaClient); READ_MANDATORY_BASE_NODE(root) - QVERIFY(root->attribute(QOpcUa::NodeAttribute::DisplayName).value().text() == QLatin1String("Root")); + QCOMPARE(root->attribute(QOpcUa::NodeAttribute::DisplayName).value().text(), QLatin1String("Root")); QString nodeId = root->nodeId(); QCOMPARE(nodeId, QOpcUa::ns0ID(QOpcUa::NodeIds::NS0::RootFolder)); @@ -1372,14 +1372,14 @@ void Tst_QOpcUaClient::dataChangeSubscription() node->enableMonitoring(QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(100, QOpcUaMonitoringParameters::SubscriptionType::Exclusive)); monitoringEnabledSpy.wait(); - QVERIFY(monitoringEnabledSpy.size() == 1); - QVERIFY(monitoringEnabledSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::Value); - QVERIFY(node->monitoringStatus(QOpcUa::NodeAttribute::Value).statusCode() == 0); + QCOMPARE(monitoringEnabledSpy.size(), 1); + QCOMPARE(monitoringEnabledSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::Value); + QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::Value).statusCode(), QOpcUa::UaStatusCode::Good); QOpcUaMonitoringParameters valueStatus = node->monitoringStatus(QOpcUa::NodeAttribute::Value); QVERIFY(valueStatus.subscriptionId() != 0); QVERIFY(valueStatus.monitoredItemId() != 0); - QVERIFY(valueStatus.statusCode() == 0); + QCOMPARE(valueStatus.statusCode(), QOpcUa::UaStatusCode::Good); WRITE_VALUE_ATTRIBUTE(node, QVariant(double(42)), QOpcUa::Types::Double); dataChangeSpy.wait(); @@ -1389,8 +1389,8 @@ void Tst_QOpcUaClient::dataChangeSubscription() QVERIFY(dataChangeSpy.size() >= 1); int index = dataChangeSpy.size() == 1 ? 0 : 1; - QVERIFY(dataChangeSpy.at(index).at(0).value() == QOpcUa::NodeAttribute::Value); - QVERIFY(dataChangeSpy.at(index).at(1) == double(42)); + QCOMPARE(dataChangeSpy.at(index).at(0).value(), QOpcUa::NodeAttribute::Value); + QCOMPARE(dataChangeSpy.at(index).at(1), double(42)); monitoringEnabledSpy.clear(); dataChangeSpy.clear(); @@ -1399,38 +1399,38 @@ void Tst_QOpcUaClient::dataChangeSubscription() valueStatus.subscriptionId())); monitoringEnabledSpy.wait(); - QVERIFY(monitoringEnabledSpy.size() == 1); - QVERIFY(monitoringEnabledSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::DisplayName); - QVERIFY(node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName).statusCode() == 0); + QCOMPARE(monitoringEnabledSpy.size(), 1); + QCOMPARE(monitoringEnabledSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::DisplayName); + QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName).statusCode(), QOpcUa::UaStatusCode::Good); QOpcUaMonitoringParameters displayNameStatus = node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName); - QVERIFY(displayNameStatus.subscriptionId() == valueStatus.subscriptionId()); + QCOMPARE(displayNameStatus.subscriptionId(), valueStatus.subscriptionId()); QVERIFY(displayNameStatus.monitoredItemId() != 0); - QVERIFY(displayNameStatus.statusCode() == 0); + QCOMPARE(displayNameStatus.statusCode(), QOpcUa::UaStatusCode::Good); dataChangeSpy.wait(); - QVERIFY(dataChangeSpy.size() == 1); - QVERIFY(dataChangeSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::DisplayName); - QVERIFY(dataChangeSpy.at(0).at(1).value().text() == QLatin1String("TestNode.ReadWrite")); + QCOMPARE(dataChangeSpy.size(), 1); + QCOMPARE(dataChangeSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::DisplayName); + QCOMPARE(dataChangeSpy.at(0).at(1).value().text(), QLatin1String("TestNode.ReadWrite")); monitoringEnabledSpy.clear(); dataChangeSpy.clear(); node->enableMonitoring(QOpcUa::NodeAttribute::NodeId, QOpcUaMonitoringParameters(100)); monitoringEnabledSpy.wait(); - QVERIFY(monitoringEnabledSpy.size() == 1); - QVERIFY(monitoringEnabledSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::NodeId); + QCOMPARE(monitoringEnabledSpy.size(), 1); + QCOMPARE(monitoringEnabledSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::NodeId); QVERIFY(node->monitoringStatus(QOpcUa::NodeAttribute::NodeId).subscriptionId() != valueStatus.subscriptionId()); - QVERIFY(node->monitoringStatus(QOpcUa::NodeAttribute::NodeId).statusCode() == 0); + QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::NodeId).statusCode(), QOpcUa::UaStatusCode::Good); QOpcUaMonitoringParameters nodeIdStatus = node->monitoringStatus(QOpcUa::NodeAttribute::NodeId); QVERIFY(nodeIdStatus.subscriptionId() != valueStatus.subscriptionId()); QVERIFY(nodeIdStatus.monitoredItemId() != 0); - QVERIFY(nodeIdStatus.statusCode() == 0); + QCOMPARE(nodeIdStatus.statusCode(), QOpcUa::UaStatusCode::Good); dataChangeSpy.wait(); - QVERIFY(dataChangeSpy.size() == 1); - QVERIFY(dataChangeSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::NodeId); - QVERIFY(dataChangeSpy.at(0).at(1) == QLatin1String("ns=3;s=TestNode.ReadWrite")); + QCOMPARE(dataChangeSpy.size(), 1); + QCOMPARE(dataChangeSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::NodeId); + QCOMPARE(dataChangeSpy.at(0).at(1), QLatin1String("ns=3;s=TestNode.ReadWrite")); QVector attrs; @@ -1446,11 +1446,11 @@ void Tst_QOpcUaClient::dataChangeSubscription() QOpcUa::NodeAttribute temp = it.at(0).value(); QVERIFY(attrs.contains(temp)); QVERIFY(it.at(1).value() & QOpcUaMonitoringParameters::Parameter::PublishingInterval); - QVERIFY(it.at(2) == QOpcUa::UaStatusCode::Good); + QCOMPARE(it.at(2), QOpcUa::UaStatusCode::Good); QCOMPARE(node->monitoringStatus(temp).publishingInterval(), 200.0); attrs.remove(attrs.indexOf(temp)); } - QVERIFY(attrs.size() == 0); + QCOMPARE(attrs.size(), 0); QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::Value).publishingInterval(), 200.0); QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName).publishingInterval(), 200.0); @@ -1464,18 +1464,18 @@ void Tst_QOpcUaClient::dataChangeSubscription() if (monitoringDisabledSpy.size() < 3) monitoringDisabledSpy.wait(); - QVERIFY(monitoringDisabledSpy.size() == 3); + QCOMPARE(monitoringDisabledSpy.size(), 3); attrs = {QOpcUa::NodeAttribute::Value, QOpcUa::NodeAttribute::DisplayName, QOpcUa::NodeAttribute::NodeId}; for (auto it : qAsConst(monitoringDisabledSpy)) { QOpcUa::NodeAttribute temp = it.at(0).value(); QVERIFY(attrs.contains(temp)); - QVERIFY(node->monitoringStatus(temp).subscriptionId() == 0); - QVERIFY(node->monitoringStatus(temp).monitoredItemId() == 0); - QVERIFY(node->monitoringStatus(temp).statusCode() == QOpcUa::UaStatusCode::BadNoEntryExists); + QCOMPARE(node->monitoringStatus(temp).subscriptionId(), (quint32)0); + QCOMPARE(node->monitoringStatus(temp).monitoredItemId(), (quint32)0); + QCOMPARE(node->monitoringStatus(temp).statusCode(), QOpcUa::UaStatusCode::BadNoEntryExists); attrs.remove(attrs.indexOf(temp)); } - QVERIFY(attrs.size() == 0); + QCOMPARE(attrs.size(), 0); } void Tst_QOpcUaClient::dataChangeSubscriptionInvalidNode() @@ -1491,10 +1491,10 @@ void Tst_QOpcUaClient::dataChangeSubscriptionInvalidNode() noDataNode->enableMonitoring(QOpcUa::NodeAttribute::Value, settings); monitoringEnabledSpy.wait(); - QVERIFY(monitoringEnabledSpy.size() == 1); - QVERIFY(monitoringEnabledSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::Value); - QVERIFY(noDataNode->monitoringStatus(QOpcUa::NodeAttribute::Value).statusCode() == QOpcUa::UaStatusCode::BadAttributeIdInvalid); - QVERIFY(noDataNode->monitoringStatus(QOpcUa::NodeAttribute::Value).subscriptionId() == 0); + QCOMPARE(monitoringEnabledSpy.size(), 1); + QCOMPARE(monitoringEnabledSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::Value); + QCOMPARE(noDataNode->monitoringStatus(QOpcUa::NodeAttribute::Value).statusCode(), QOpcUa::UaStatusCode::BadAttributeIdInvalid); + QCOMPARE(noDataNode->monitoringStatus(QOpcUa::NodeAttribute::Value).subscriptionId(), (quint32)0); } void Tst_QOpcUaClient::dataChangeSubscriptionSharing() @@ -1513,28 +1513,28 @@ void Tst_QOpcUaClient::dataChangeSubscriptionSharing() node->enableMonitoring(QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(50)); monitoringEnabledSpy.wait(); - QVERIFY(monitoringEnabledSpy.size() == 1); - QVERIFY(monitoringEnabledSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::Value); - QVERIFY(node->monitoringStatus(QOpcUa::NodeAttribute::Value).statusCode() == QOpcUa::UaStatusCode::Good); + QCOMPARE(monitoringEnabledSpy.size(), 1); + QCOMPARE(monitoringEnabledSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::Value); + QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::Value).statusCode(), QOpcUa::UaStatusCode::Good); QOpcUaMonitoringParameters valueStatus = node->monitoringStatus(QOpcUa::NodeAttribute::Value); QVERIFY(valueStatus.subscriptionId() != 0); - QVERIFY(valueStatus.statusCode() == QOpcUa::UaStatusCode::Good); + QCOMPARE(valueStatus.statusCode(), QOpcUa::UaStatusCode::Good); monitoringEnabledSpy.clear(); node->enableMonitoring(QOpcUa::NodeAttribute::DisplayName, QOpcUaMonitoringParameters(25)); monitoringEnabledSpy.wait(); - QVERIFY(monitoringEnabledSpy.size() == 1); - QVERIFY(monitoringEnabledSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::DisplayName); - QVERIFY(node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName).statusCode() == QOpcUa::UaStatusCode::Good); + QCOMPARE(monitoringEnabledSpy.size(), 1); + QCOMPARE(monitoringEnabledSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::DisplayName); + QCOMPARE(node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName).statusCode(), QOpcUa::UaStatusCode::Good); QOpcUaMonitoringParameters displayNameStatus = node->monitoringStatus(QOpcUa::NodeAttribute::DisplayName); - QVERIFY(displayNameStatus.subscriptionId() == valueStatus.subscriptionId()); - QVERIFY(displayNameStatus.statusCode() == QOpcUa::UaStatusCode::Good); + QCOMPARE(displayNameStatus.subscriptionId(), valueStatus.subscriptionId()); + QCOMPARE(displayNameStatus.statusCode(), QOpcUa::UaStatusCode::Good); - QVERIFY(valueStatus.subscriptionId() == displayNameStatus.subscriptionId()); + QCOMPARE(valueStatus.subscriptionId(), displayNameStatus.subscriptionId()); QCOMPARE(valueStatus.publishingInterval(), displayNameStatus.publishingInterval()); QCOMPARE(valueStatus.publishingInterval(), 100.0); @@ -1545,17 +1545,17 @@ void Tst_QOpcUaClient::dataChangeSubscriptionSharing() if (monitoringDisabledSpy.size() < 2) monitoringDisabledSpy.wait(); - QVERIFY(monitoringDisabledSpy.size() == 2); + QCOMPARE(monitoringDisabledSpy.size(), 2); QVector attrs = {QOpcUa::NodeAttribute::Value, QOpcUa::NodeAttribute::DisplayName}; for (auto it : qAsConst(monitoringDisabledSpy)) { auto temp = it.at(0).value(); QVERIFY(attrs.contains(temp)); - QVERIFY(node->monitoringStatus(temp).subscriptionId() == 0); - QVERIFY(node->monitoringStatus(temp).statusCode() == QOpcUa::UaStatusCode::BadNoEntryExists); + QCOMPARE(node->monitoringStatus(temp).subscriptionId(), (quint32)0); + QCOMPARE(node->monitoringStatus(temp).statusCode(), QOpcUa::UaStatusCode::BadNoEntryExists); attrs.removeOne(temp); } - QVERIFY(attrs.size() == 0); + QCOMPARE(attrs.size(), 0); } void Tst_QOpcUaClient::methodCall() @@ -2037,8 +2037,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant booleanArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(booleanArray.type() == QVariant::List); - QVERIFY(booleanArray.toList().length() == 3); + QCOMPARE(booleanArray.type(), QVariant::List); + QCOMPARE(booleanArray.toList().length(), 3); QCOMPARE(booleanArray.toList()[0].type(), QVariant::Bool); QCOMPARE(booleanArray.toList()[0].toBool(), true); QCOMPARE(booleanArray.toList()[1].toBool(), false); @@ -2048,8 +2048,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant int32Array = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(int32Array.type() == QVariant::List); - QVERIFY(int32Array.toList().length() == 3); + QCOMPARE(int32Array.type(), QVariant::List); + QCOMPARE(int32Array.toList().length(), 3); QCOMPARE(int32Array.toList()[0].type(), QVariant::Int); QCOMPARE(int32Array.toList()[0].toInt(), std::numeric_limits::min()); QCOMPARE(int32Array.toList()[1].toInt(), (std::numeric_limits::max)()); @@ -2059,8 +2059,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant uint32Array = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(uint32Array.type() == QVariant::List); - QVERIFY(uint32Array.toList().length() == 3); + QCOMPARE(uint32Array.type(), QVariant::List); + QCOMPARE(uint32Array.toList().length(), 3); QCOMPARE(uint32Array.toList()[0].type(), QVariant::UInt); QCOMPARE(uint32Array.toList()[0].toUInt(), std::numeric_limits::min()); QCOMPARE(uint32Array.toList()[1].toUInt(), (std::numeric_limits::max)()); @@ -2070,8 +2070,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant doubleArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(doubleArray.type() == QVariant::List); - QVERIFY(doubleArray.toList().length() == 3); + QCOMPARE(doubleArray.type(), QVariant::List); + QCOMPARE(doubleArray.toList().length(), 3); QCOMPARE(doubleArray.toList()[0].type(), QVariant::Double); QCOMPARE(doubleArray.toList()[0].toDouble(), double(23.5)); QCOMPARE(doubleArray.toList()[1].toDouble(), double(23.6)); @@ -2081,9 +2081,9 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant floatArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(floatArray.type() == QVariant::List); - QVERIFY(floatArray.toList().length() == 3); - QVERIFY(floatArray.toList()[0].userType() == QMetaType::Float); + QCOMPARE(floatArray.type(), QVariant::List); + QCOMPARE(floatArray.toList().length(), 3); + QCOMPARE(floatArray.toList()[0].userType(), QMetaType::Float); QCOMPARE(floatArray.toList()[0].toFloat(), float(23.5)); QCOMPARE(floatArray.toList()[1].toFloat(), float(23.6)); QCOMPARE(floatArray.toList()[2].toFloat(), float(23.7)); @@ -2092,8 +2092,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant stringArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(stringArray.type() == QVariant::List); - QVERIFY(stringArray.toList().length() == 3); + QCOMPARE(stringArray.type(), QVariant::List); + QCOMPARE(stringArray.toList().length(), 3); QCOMPARE(stringArray.toList()[0].type(), QVariant::String); QCOMPARE(stringArray.toList()[0].toString(), QStringLiteral("Test1")); QCOMPARE(stringArray.toList()[1].toString(), QStringLiteral("Test2")); @@ -2103,41 +2103,41 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant dateTimeArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(dateTimeArray.type() == QVariant::List); - QVERIFY(dateTimeArray.toList().length() == 3); + QCOMPARE(dateTimeArray.type(), QVariant::List); + QCOMPARE(dateTimeArray.toList().length(), 3); QCOMPARE(dateTimeArray.toList()[0].type(), QVariant::DateTime); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.LocalizedText")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant ltArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(ltArray.type() == QVariant::List); - QVERIFY(ltArray.toList().length() == 3); - QVERIFY(ltArray.toList()[0].value() == localizedTexts[0]); - QVERIFY(ltArray.toList()[1].value() == localizedTexts[1]); - QVERIFY(ltArray.toList()[2].value() == localizedTexts[2]); + QCOMPARE(ltArray.type(), QVariant::List); + QCOMPARE(ltArray.toList().length(), 3); + QCOMPARE(ltArray.toList()[0].value(), localizedTexts[0]); + QCOMPARE(ltArray.toList()[1].value(), localizedTexts[1]); + QCOMPARE(ltArray.toList()[2].value(), localizedTexts[2]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.UInt16")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant uint16Array = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(uint16Array.type() == QVariant::List); - QVERIFY(uint16Array.toList().length() == 3); - QVERIFY(uint16Array.toList()[0].userType() == QMetaType::UShort); - QVERIFY(uint16Array.toList()[0] == std::numeric_limits::min()); - QVERIFY(uint16Array.toList()[1] == (std::numeric_limits::max)()); - QVERIFY(uint16Array.toList()[2] == quint16(10)); + QCOMPARE(uint16Array.type(), QVariant::List); + QCOMPARE(uint16Array.toList().length(), 3); + QCOMPARE(uint16Array.toList()[0].userType(), QMetaType::UShort); + QCOMPARE(uint16Array.toList()[0], std::numeric_limits::min()); + QCOMPARE(uint16Array.toList()[1], (std::numeric_limits::max)()); + QCOMPARE(uint16Array.toList()[2], quint16(10)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.Int16")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant int16Array = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(int16Array.type() == QVariant::List); - QVERIFY(int16Array.toList().length() == 3); - QVERIFY(int16Array.toList()[0].userType() == QMetaType::Short); - QVERIFY(int16Array.toList()[0] == std::numeric_limits::min()); - QVERIFY(int16Array.toList()[1] == (std::numeric_limits::max)()); - QVERIFY(int16Array.toList()[2] == qint16(10)); + QCOMPARE(int16Array.type(), QVariant::List); + QCOMPARE(int16Array.toList().length(), 3); + QCOMPARE(int16Array.toList()[0].userType(), QMetaType::Short); + QCOMPARE(int16Array.toList()[0], std::numeric_limits::min()); + QCOMPARE(int16Array.toList()[1], (std::numeric_limits::max)()); + QCOMPARE(int16Array.toList()[2], qint16(10)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.UInt64")); QVERIFY(node != nullptr); @@ -2146,51 +2146,52 @@ void Tst_QOpcUaClient::readArray() QCOMPARE(uint64Array.type(), QVariant::List); QCOMPARE(uint64Array.toList().length(), 3); QCOMPARE(uint64Array.toList()[0].type(), QVariant::ULongLong); - QVERIFY(uint64Array.toList()[0] == std::numeric_limits::min()); - QVERIFY(uint64Array.toList()[1] == (std::numeric_limits::max)()); - QVERIFY(uint64Array.toList()[2] == quint64(10)); + QCOMPARE(uint64Array.toList()[0], std::numeric_limits::min()); + QCOMPARE(uint64Array.toList()[1], (std::numeric_limits::max)()); + QCOMPARE(uint64Array.toList()[2], quint64(10)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.Int64")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant int64Array = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(int64Array.type() == QVariant::List && int64Array.toList().length() == 3); + QCOMPARE(int64Array.type(), QVariant::List); + QCOMPARE(int64Array.toList().length(), 3); QCOMPARE(int64Array.toList()[0].type(), QVariant::LongLong); - QVERIFY(int64Array.toList()[0] == std::numeric_limits::min()); - QVERIFY(int64Array.toList()[1] == (std::numeric_limits::max)()); - QVERIFY(int64Array.toList()[2] == qint64(10)); + QCOMPARE(int64Array.toList()[0], std::numeric_limits::min()); + QCOMPARE(int64Array.toList()[1], (std::numeric_limits::max)()); + QCOMPARE(int64Array.toList()[2], qint64(10)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.Byte")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant byteArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(byteArray.type() == QVariant::List); - QVERIFY(byteArray.toList().length() == 3); - QVERIFY(byteArray.toList()[0].userType() == QMetaType::UChar); - QVERIFY(byteArray.toList()[0] == std::numeric_limits::min()); - QVERIFY(byteArray.toList()[1] == (std::numeric_limits::max)()); - QVERIFY(byteArray.toList()[2] == quint8(10)); + QCOMPARE(byteArray.type(), QVariant::List); + QCOMPARE(byteArray.toList().length(), 3); + QCOMPARE(byteArray.toList()[0].userType(), QMetaType::UChar); + QCOMPARE(byteArray.toList()[0], std::numeric_limits::min()); + QCOMPARE(byteArray.toList()[1], (std::numeric_limits::max)()); + QCOMPARE(byteArray.toList()[2], quint8(10)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.ByteString")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant byteStringArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(byteStringArray.type() == QVariant::List); - QVERIFY(byteStringArray.toList().length() == 3); - QVERIFY(byteStringArray.toList()[0].userType() == QMetaType::QByteArray); - QVERIFY(byteStringArray.toList()[0] == "abc"); - QVERIFY(byteStringArray.toList()[1] == "def"); + QCOMPARE(byteStringArray.type(), QVariant::List); + QCOMPARE(byteStringArray.toList().length(), 3); + QCOMPARE(byteStringArray.toList()[0].userType(), QMetaType::QByteArray); + QCOMPARE(byteStringArray.toList()[0], "abc"); + QCOMPARE(byteStringArray.toList()[1], "def"); QByteArray withNull("gh"); withNull.append('\0'); withNull.append("i"); - QVERIFY(byteStringArray.toList()[2] == withNull); + QCOMPARE(byteStringArray.toList()[2], withNull); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.Guid")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant guidArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(guidArray.type() == QVariant::List); - QVERIFY(guidArray.toList().length() == 3); + QCOMPARE(guidArray.type(), QVariant::List); + QCOMPARE(guidArray.toList().length(), 3); QCOMPARE(guidArray.toList()[0].toUuid(), testUuid[0]); QCOMPARE(guidArray.toList()[1].toUuid(), testUuid[1]); QCOMPARE(guidArray.toList()[2].toUuid(), testUuid[2]); @@ -2199,19 +2200,19 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant sbyteArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(sbyteArray.type() == QVariant::List); - QVERIFY(sbyteArray.toList().length() == 3); - QVERIFY(sbyteArray.toList()[0].userType() == QMetaType::SChar); - QVERIFY(sbyteArray.toList()[0] == std::numeric_limits::min()); - QVERIFY(sbyteArray.toList()[1] == (std::numeric_limits::max)()); - QVERIFY(sbyteArray.toList()[2] == qint8(10)); + QCOMPARE(sbyteArray.type(), QVariant::List); + QCOMPARE(sbyteArray.toList().length(), 3); + QCOMPARE(sbyteArray.toList()[0].userType(), QMetaType::SChar); + QCOMPARE(sbyteArray.toList()[0], std::numeric_limits::min()); + QCOMPARE(sbyteArray.toList()[1], (std::numeric_limits::max)()); + QCOMPARE(sbyteArray.toList()[2], qint8(10)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.NodeId")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant nodeIdArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(nodeIdArray.type() == QVariant::List); - QVERIFY(nodeIdArray.toList().length() == 3); + QCOMPARE(nodeIdArray.type(), QVariant::List); + QCOMPARE(nodeIdArray.toList().length(), 3); QCOMPARE(nodeIdArray.toList()[0].type(), QVariant::String); QCOMPARE(nodeIdArray.toList()[0].toString(), QStringLiteral("ns=0;i=0")); QCOMPARE(nodeIdArray.toList()[1].toString(), QStringLiteral("ns=0;i=1")); @@ -2221,18 +2222,18 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node) QVariant qualifiedNameArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(qualifiedNameArray.type() == QVariant::List); - QVERIFY(qualifiedNameArray.toList().length() == 3); - QVERIFY(qualifiedNameArray.toList()[0].value() == QOpcUa::QQualifiedName(0, "Test0")); - QVERIFY(qualifiedNameArray.toList()[1].value() == QOpcUa::QQualifiedName(1, "Test1")); - QVERIFY(qualifiedNameArray.toList()[2].value() == QOpcUa::QQualifiedName(2, "Test2")); + QCOMPARE(qualifiedNameArray.type(), QVariant::List); + QCOMPARE(qualifiedNameArray.toList().length(), 3); + QCOMPARE(qualifiedNameArray.toList()[0].value(), QOpcUa::QQualifiedName(0, "Test0")); + QCOMPARE(qualifiedNameArray.toList()[1].value(), QOpcUa::QQualifiedName(1, "Test1")); + QCOMPARE(qualifiedNameArray.toList()[2].value(), QOpcUa::QQualifiedName(2, "Test2")); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Arrays.StatusCode")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant statusCodeArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(statusCodeArray.type() == QVariant::List); - QVERIFY(statusCodeArray.toList().length() == 3); + QCOMPARE(statusCodeArray.type(), QVariant::List); + QCOMPARE(statusCodeArray.toList().length(), 3); QCOMPARE(statusCodeArray.toList()[0].value(), QOpcUa::UaStatusCode::Good); QCOMPARE(statusCodeArray.toList()[1].value(), QOpcUa::UaStatusCode::BadUnexpectedError); QCOMPARE(statusCodeArray.toList()[2].value(), QOpcUa::UaStatusCode::BadInternalError); @@ -2241,8 +2242,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant rangeArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(rangeArray.type() == QVariant::List); - QVERIFY(rangeArray.toList().length() == 3); + QCOMPARE(rangeArray.type(), QVariant::List); + QCOMPARE(rangeArray.toList().length(), 3); QCOMPARE(rangeArray.toList()[0].value(), testRanges[0]); QCOMPARE(rangeArray.toList()[1].value(), testRanges[1]); QCOMPARE(rangeArray.toList()[2].value(), testRanges[2]); @@ -2251,8 +2252,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant euiArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(euiArray.type() == QVariant::List); - QVERIFY(euiArray.toList().length() == 3); + QCOMPARE(euiArray.type(), QVariant::List); + QCOMPARE(euiArray.toList().length(), 3); QCOMPARE(euiArray.toList()[0].value(), testEUInfos[0]); QCOMPARE(euiArray.toList()[1].value(), testEUInfos[1]); QCOMPARE(euiArray.toList()[2].value(), testEUInfos[2]); @@ -2261,8 +2262,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant complexArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(complexArray.type() == QVariant::List); - QVERIFY(complexArray.toList().length() == 3); + QCOMPARE(complexArray.type(), QVariant::List); + QCOMPARE(complexArray.toList().length(), 3); QCOMPARE(complexArray.toList()[0].value(), testComplex[0]); QCOMPARE(complexArray.toList()[1].value(), testComplex[1]); QCOMPARE(complexArray.toList()[2].value(), testComplex[2]); @@ -2271,8 +2272,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant doubleComplexArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(doubleComplexArray.type() == QVariant::List); - QVERIFY(doubleComplexArray.toList().length() == 3); + QCOMPARE(doubleComplexArray.type(), QVariant::List); + QCOMPARE(doubleComplexArray.toList().length(), 3); QCOMPARE(doubleComplexArray.toList()[0].value(), testDoubleComplex[0]); QCOMPARE(doubleComplexArray.toList()[1].value(), testDoubleComplex[1]); QCOMPARE(doubleComplexArray.toList()[2].value(), testDoubleComplex[2]); @@ -2281,8 +2282,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant axisInfoArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(axisInfoArray.type() == QVariant::List); - QVERIFY(axisInfoArray.toList().length() == 3); + QCOMPARE(axisInfoArray.type(), QVariant::List); + QCOMPARE(axisInfoArray.toList().length(), 3); QCOMPARE(axisInfoArray.toList()[0].value(), testAxisInfo[0]); QCOMPARE(axisInfoArray.toList()[1].value(), testAxisInfo[1]); QCOMPARE(axisInfoArray.toList()[2].value(), testAxisInfo[2]); @@ -2291,8 +2292,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant xVArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(xVArray.type() == QVariant::List); - QVERIFY(xVArray.toList().length() == 3); + QCOMPARE(xVArray.type(), QVariant::List); + QCOMPARE(xVArray.toList().length(), 3); QCOMPARE(xVArray.toList()[0].value(), testXV[0]); QCOMPARE(xVArray.toList()[1].value(), testXV[1]); QCOMPARE(xVArray.toList()[2].value(), testXV[2]); @@ -2318,8 +2319,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node) QVariant xmlElementArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(xmlElementArray.type() == QVariant::List); - QVERIFY(xmlElementArray.toList().length() == 3); + QCOMPARE(xmlElementArray.type(), QVariant::List); + QCOMPARE(xmlElementArray.toList().length(), 3); QCOMPARE(xmlElementArray.toList()[0].type(), QVariant::String); QCOMPARE(xmlElementArray.toList()[0].toString(), xmlElements[0]); QCOMPARE(xmlElementArray.toList()[1].toString(), xmlElements[1]); @@ -2329,8 +2330,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node) QVariant expandedNodeIdArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(expandedNodeIdArray.type() == QVariant::List); - QVERIFY(expandedNodeIdArray.toList().length() == 3); + QCOMPARE(expandedNodeIdArray.type(), QVariant::List); + QCOMPARE(expandedNodeIdArray.toList().length(), 3); QCOMPARE(expandedNodeIdArray.toList()[0].value(), testExpandedNodeId[0]); QCOMPARE(expandedNodeIdArray.toList()[1].value(), testExpandedNodeId[1]); QCOMPARE(expandedNodeIdArray.toList()[2].value(), testExpandedNodeId[2]); @@ -2340,8 +2341,8 @@ void Tst_QOpcUaClient::readArray() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node) QVariant argumentArray = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(argumentArray.type() == QVariant::List); - QVERIFY(argumentArray.toList().length() == 3); + QCOMPARE(argumentArray.type(), QVariant::List); + QCOMPARE(argumentArray.toList().length(), 3); QCOMPARE(argumentArray.toList()[0].value(), testArguments[0]); QCOMPARE(argumentArray.toList()[1].value(), testArguments[1]); QCOMPARE(argumentArray.toList()[2].value(), testArguments[2]); @@ -2532,7 +2533,7 @@ void Tst_QOpcUaClient::readScalar() READ_MANDATORY_VARIABLE_NODE(node); QVariant floatScalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(floatScalar.isValid()); - QVERIFY(floatScalar.userType() == QMetaType::Float); + QCOMPARE(floatScalar.userType(), QMetaType::Float); QCOMPARE(floatScalar.toFloat(), float(42)); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.String")); @@ -2555,23 +2556,23 @@ void Tst_QOpcUaClient::readScalar() READ_MANDATORY_VARIABLE_NODE(node); QVariant ltScalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(ltScalar.isValid()); - QVERIFY(ltScalar.value() == localizedTexts[0]); + QCOMPARE(ltScalar.value(), localizedTexts[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.UInt16")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant uint16Scalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(uint16Scalar.isValid()); - QVERIFY(uint16Scalar.userType() == QMetaType::UShort); - QVERIFY(uint16Scalar == (std::numeric_limits::max)()); + QCOMPARE(uint16Scalar.userType(), QMetaType::UShort); + QCOMPARE(uint16Scalar, (std::numeric_limits::max)()); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Int16")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant int16Scalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(int16Scalar.isValid()); - QVERIFY(int16Scalar.userType() == QMetaType::Short); - QVERIFY(int16Scalar == std::numeric_limits::min()); + QCOMPARE(int16Scalar.userType(), QMetaType::Short); + QCOMPARE(int16Scalar, std::numeric_limits::min()); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.UInt64")); QVERIFY(node != nullptr); @@ -2579,7 +2580,7 @@ void Tst_QOpcUaClient::readScalar() QVariant uint64Scalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(uint64Scalar.isValid()); QCOMPARE(uint64Scalar.type(), QVariant::ULongLong); - QVERIFY(uint64Scalar == (std::numeric_limits::max)()); + QCOMPARE(uint64Scalar, (std::numeric_limits::max)()); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Int64")); QVERIFY(node != nullptr); @@ -2587,41 +2588,41 @@ void Tst_QOpcUaClient::readScalar() QVariant int64Scalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(int64Scalar.isValid()); QCOMPARE(int64Scalar.type(), QVariant::LongLong); - QVERIFY(int64Scalar == std::numeric_limits::min()); + QCOMPARE(int64Scalar, std::numeric_limits::min()); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Byte")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant byteScalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(byteScalar.isValid()); - QVERIFY(byteScalar.userType() == QMetaType::UChar); - QVERIFY(byteScalar == (std::numeric_limits::max)()); + QCOMPARE(byteScalar.userType(), QMetaType::UChar); + QCOMPARE(byteScalar, (std::numeric_limits::max)()); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.SByte")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant sbyteScalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(sbyteScalar.isValid()); - QVERIFY(sbyteScalar.userType() == QMetaType::SChar); - QVERIFY(sbyteScalar == std::numeric_limits::min()); + QCOMPARE(sbyteScalar.userType(), QMetaType::SChar); + QCOMPARE(sbyteScalar, std::numeric_limits::min()); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.ByteString")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant byteStringScalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(byteStringScalar.isValid()); - QVERIFY(byteStringScalar.userType() == QMetaType::QByteArray); + QCOMPARE(byteStringScalar.userType(), QMetaType::QByteArray); QByteArray withNull("gh"); withNull.append('\0'); withNull.append("i"); - QVERIFY(byteStringScalar == withNull); + QCOMPARE(byteStringScalar, withNull); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Guid")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); QVariant guidScalar = node->attribute(QOpcUa::NodeAttribute::Value); QVERIFY(guidScalar.isValid()); - QVERIFY(guidScalar.userType() == QMetaType::QUuid); + QCOMPARE(guidScalar.userType(), QMetaType::QUuid); QCOMPARE(guidScalar.toUuid(), testUuid[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.NodeId")); @@ -2636,7 +2637,7 @@ void Tst_QOpcUaClient::readScalar() QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node) QVariant qualifiedNameScalar = node->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(qualifiedNameScalar.value() == QOpcUa::QQualifiedName(0, "Test0")); + QCOMPARE(qualifiedNameScalar.value(), QOpcUa::QQualifiedName(0, "Test0")); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.StatusCode")); QVERIFY(node != nullptr); @@ -2648,32 +2649,32 @@ void Tst_QOpcUaClient::readScalar() node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Range")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == testRanges[0]); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), testRanges[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.EUInformation")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == testEUInfos[0]); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), testEUInfos[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.ComplexNumber")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == testComplex[0]); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), testComplex[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.DoubleComplexNumber")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == testDoubleComplex[0]); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), testDoubleComplex[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.AxisInformation")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == testAxisInfo[0]); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), testAxisInfo[0]); node.reset(opcuaClient->node("ns=2;s=Demo.Static.Scalar.XV")); QVERIFY(node != nullptr); READ_MANDATORY_VARIABLE_NODE(node); - QVERIFY(node->attribute(QOpcUa::NodeAttribute::Value).value() == testXV[0]); + QCOMPARE(node->attribute(QOpcUa::NodeAttribute::Value).value(), testXV[0]); if (opcuaClient->backend() != QLatin1String("open62541")) qInfo("The uacpp backend currently does not support reading extension objects"); @@ -2729,8 +2730,8 @@ void Tst_QOpcUaClient::indexRange() node->writeAttributeRange(QOpcUa::NodeAttribute::Value, QVariantList({10, 11, 12, 13}), "0:3", QOpcUa::Types::Int32); attributeWrittenSpy.wait(); - QVERIFY(attributeWrittenSpy.size() == 1); - QVERIFY(attributeWrittenSpy.at(0).at(1).value() == QOpcUa::UaStatusCode::Good); + QCOMPARE(attributeWrittenSpy.size(), 1); + QCOMPARE(attributeWrittenSpy.at(0).at(1).value(), QOpcUa::UaStatusCode::Good); QSignalSpy attributeReadSpy(node.data(), &QOpcUaNode::attributeRead); node->readAttributeRange(QOpcUa::NodeAttribute::Value, "0:6"); @@ -2755,8 +2756,8 @@ void Tst_QOpcUaClient::invalidIndexRange() node->writeAttributeRange(QOpcUa::NodeAttribute::Value, QVariantList({10, 11, 12, 13}), "notavalidrange", QOpcUa::Types::Int32); attributeWrittenSpy.wait(); - QVERIFY(attributeWrittenSpy.size() == 1); - QVERIFY(attributeWrittenSpy.at(0).at(1).value() == QOpcUa::UaStatusCode::BadIndexRangeInvalid); + QCOMPARE(attributeWrittenSpy.size(), 1); + QCOMPARE(attributeWrittenSpy.at(0).at(1).value(), QOpcUa::UaStatusCode::BadIndexRangeInvalid); QSignalSpy attributeReadSpy(node.data(), &QOpcUaNode::attributeRead); node->readAttributeRange(QOpcUa::NodeAttribute::Value, "notavalidrange"); @@ -2858,10 +2859,10 @@ void Tst_QOpcUaClient::subscriptionDataChangeFilter() filter.setDeadbandValue(1.0); doubleNode->modifyDataChangeFilter(QOpcUa::NodeAttribute::Value, filter); monitoringModifiedSpy.wait(); - QVERIFY(monitoringModifiedSpy.size() == 1); - QVERIFY(monitoringModifiedSpy.at(0).at(0).value() == QOpcUa::NodeAttribute::Value); + QCOMPARE(monitoringModifiedSpy.size(), 1); + QCOMPARE(monitoringModifiedSpy.at(0).at(0).value(), QOpcUa::NodeAttribute::Value); QVERIFY(monitoringModifiedSpy.at(0).at(1).value() & QOpcUaMonitoringParameters::Parameter::Filter); - QVERIFY(monitoringModifiedSpy.at(0).at(2).value() == QOpcUa::UaStatusCode::Good); + QCOMPARE(monitoringModifiedSpy.at(0).at(2).value(), QOpcUa::UaStatusCode::Good); WRITE_VALUE_ATTRIBUTE(doubleNode, 2.0, QOpcUa::Types::Double); @@ -3190,23 +3191,23 @@ void Tst_QOpcUaClient::stringCharset() READ_MANDATORY_VARIABLE_NODE(localizedScalarNode); QVariant result = stringScalarNode->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(result.toString() == testString); + QCOMPARE(result.toString(), testString); result = localizedScalarNode->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(result.value() == localizedTexts[0]); + QCOMPARE(result.value(), localizedTexts[0]); result = stringArrayNode->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(result.type() == QVariant::List); - QVERIFY(result.toList().length() == 2); - QVERIFY(result.toList()[0].type() == QVariant::String); - QVERIFY(result.toList()[0].toString() == testString); - QVERIFY(result.toList()[1].type() == QVariant::String); - QVERIFY(result.toList()[1].toString() == testString); + QCOMPARE(result.type(), QVariant::List); + QCOMPARE(result.toList().length(), 2); + QCOMPARE(result.toList()[0].type(), QVariant::String); + QCOMPARE(result.toList()[0].toString(), testString); + QCOMPARE(result.toList()[1].type(), QVariant::String); + QCOMPARE(result.toList()[1].toString(), testString); result = localizedArrayNode->attribute(QOpcUa::NodeAttribute::Value); - QVERIFY(result.type() == QVariant::List); - QVERIFY(result.toList().length() == 2); - QVERIFY(result.toList()[0].value() == lt1); - QVERIFY(result.toList()[1].value() == lt2); + QCOMPARE(result.type(), QVariant::List); + QCOMPARE(result.toList().length(), 2); + QCOMPARE(result.toList()[0].value(), lt1); + QCOMPARE(result.toList()[1].value(), lt2); } void Tst_QOpcUaClient::namespaceArray() @@ -3221,7 +3222,7 @@ void Tst_QOpcUaClient::namespaceArray() QCOMPARE(spy.size(), 1); QStringList namespaces = opcuaClient->namespaceArray(); - QVERIFY(namespaces.size() == 4); + QCOMPARE(namespaces.size(), 4); int nsIndex = namespaces.indexOf("http://qt-project.org"); QVERIFY(nsIndex > 0); @@ -3285,7 +3286,7 @@ void Tst_QOpcUaClient::dateTimeConversion() READ_MANDATORY_VARIABLE_NODE(dateTimeScalarNode); QDateTime result = dateTimeScalarNode->attribute(QOpcUa::NodeAttribute::Value).toDateTime(); - QVERIFY(dt == result); + QCOMPARE(dt, result); } void Tst_QOpcUaClient::timeStamps() @@ -3370,7 +3371,7 @@ void Tst_QOpcUaClient::createNodeFromExpandedId() id.setNamespaceUri(QStringLiteral("Test Namespace")); node.reset(opcuaClient->node(id)); QVERIFY(node != nullptr); - QVERIFY(node->nodeId() == QStringLiteral("ns=3;s=TestNode.ReadWrite")); + QCOMPARE(node->nodeId(), QStringLiteral("ns=3;s=TestNode.ReadWrite")); READ_MANDATORY_BASE_NODE(node); QCOMPARE(node->attribute(QOpcUa::NodeAttribute::BrowseName).value(), QOpcUa::QQualifiedName(3, QStringLiteral("TestNode.ReadWrite"))); @@ -3617,7 +3618,7 @@ void Tst_QOpcUaClient::addNamespace() QVERIFY(namespaceUpdatedSpy.size() > 0); QCOMPARE(namespaceChangedSpy.size(), 1); auto updatedNamespaceArray = opcuaClient->namespaceArray(); - QVERIFY(updatedNamespaceArray.size() == namespaceArray.size() + 1); + QCOMPARE(updatedNamespaceArray.size(), namespaceArray.size() + 1); QVERIFY(updatedNamespaceArray.contains(newNamespaceName)); QCOMPARE(methodSpy.at(0).at(1).value(), updatedNamespaceArray.indexOf(newNamespaceName)); } -- cgit v1.2.3