Explicitly =delete {in}equality operators for CAN parser value calsses

... so that the users could not provide their own implementations and
potentially get an ODR violation.

For unit-tests provide
 bool equals(lhs, rhs)
functions instead.

The drawback of this approach is that we need to use
 QVERIFY(equals(actual, expected));
 QVERIFY(!equals(actual, expected));
instead of
 QCOMPARE_EQ(actual, expected);
 QCOMPARE_NE(actual, expected);

The former will produce less informative error messages in case of test
failures.

This commit amends 8db3c1142248e4564e8b90db61ad1bdf13164453.

Change-Id: I6a476f4af84232e9a31705a633de2a2a0647180f
Reviewed-by: André Hartmann <aha_1980@gmx.de>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
(cherry picked from commit 35ca3f143ff464d77c83976add6864bff6824dc1)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

10 files changed, 85 insertions, 66 deletions

diff --git a/src/serialbus/qcanmessagedescription.h b/src/serialbus/qcanmessagedescription.h
index 1cf7b55..522cbd9 100644
--- a/src/serialbus/qcanmessagedescription.h
+++ b/src/serialbus/qcanmessagedescription.h
@@ -59,6 +59,10 @@ private:
     friend class QCanMessageDescriptionPrivate;
 
     friend void qHash(const QCanMessageDescription &desc, size_t seed) noexcept = delete;
+    friend void operator==(const QCanMessageDescription &lhs,
+                           const QCanMessageDescription &rhs) noexcept = delete;
+    friend void operator!=(const QCanMessageDescription &lhs,
+                           const QCanMessageDescription &rhs) noexcept = delete;
 
 #ifndef QT_NO_DEBUG_STREAM
     friend QDebug operator<<(QDebug dbg, const QCanMessageDescription &msg)
diff --git a/src/serialbus/qcansignaldescription.h b/src/serialbus/qcansignaldescription.h
index 89e48c8..65fd1f2 100644
--- a/src/serialbus/qcansignaldescription.h
+++ b/src/serialbus/qcansignaldescription.h
@@ -114,6 +114,10 @@ private:
     friend class QCanSignalDescriptionPrivate;
 
     friend void qHash(const QCanSignalDescription &desc, size_t seed) noexcept = delete;
+    friend void operator==(const QCanSignalDescription &lhs,
+                           const QCanSignalDescription &rhs) noexcept = delete;
+    friend void operator!=(const QCanSignalDescription &lhs,
+                           const QCanSignalDescription &rhs) noexcept = delete;
 
 #ifndef QT_NO_DEBUG_STREAM
     friend QDebug operator<<(QDebug dbg, const QCanSignalDescription &sig)
diff --git a/src/serialbus/qcanuniqueiddescription.h b/src/serialbus/qcanuniqueiddescription.h
index 06b89a2..3d22628 100644
--- a/src/serialbus/qcanuniqueiddescription.h
+++ b/src/serialbus/qcanuniqueiddescription.h
@@ -46,6 +46,10 @@ private:
     friend class QCanUniqueIdDescriptionPrivate;
 
     friend void qHash(const QCanUniqueIdDescription &desc, size_t seed) noexcept = delete;
+    friend void operator==(const QCanUniqueIdDescription &lhs,
+                           const QCanUniqueIdDescription &rhs) noexcept = delete;
+    friend void operator!=(const QCanUniqueIdDescription &lhs,
+                           const QCanUniqueIdDescription &rhs) noexcept = delete;
 };
 
 QT_END_NAMESPACE
diff --git a/tests/auto/qcandbcfileparser/tst_qcandbcfileparser.cpp b/tests/auto/qcandbcfileparser/tst_qcandbcfileparser.cpp
index d86a7d3..9f859f3 100644
--- a/tests/auto/qcandbcfileparser/tst_qcandbcfileparser.cpp
+++ b/tests/auto/qcandbcfileparser/tst_qcandbcfileparser.cpp
@@ -54,7 +54,7 @@ void tst_QCanDbcFileParser::uinqueId()
     expectedDesc.setStartBit(0);
     expectedDesc.setBitLength(29);
 
-    QCOMPARE_EQ(QCanDbcFileParser::uniqueIdDescription(), expectedDesc);
+    QVERIFY(equals(QCanDbcFileParser::uniqueIdDescription(), expectedDesc));
 }
 
 void tst_QCanDbcFileParser::parseFile_data()
@@ -934,7 +934,7 @@ void tst_QCanDbcFileParser::parseFile()
     std::sort(messageDescriptions.begin(), messageDescriptions.end(), messageDescComparator);
     std::sort(expectedMessageDescriptions.begin(), expectedMessageDescriptions.end(),
               messageDescComparator);
-    QCOMPARE_EQ(messageDescriptions, expectedMessageDescriptions);
+    QVERIFY(equals(messageDescriptions, expectedMessageDescriptions));
 }
 
 void tst_QCanDbcFileParser::valueDescriptions()
diff --git a/tests/auto/qcanmessagedescription/tst_qcanmessagedescription.cpp b/tests/auto/qcanmessagedescription/tst_qcanmessagedescription.cpp
index 115e0aa..6369ef0 100644
--- a/tests/auto/qcanmessagedescription/tst_qcanmessagedescription.cpp
+++ b/tests/auto/qcanmessagedescription/tst_qcanmessagedescription.cpp
@@ -64,12 +64,12 @@ void tst_QCanMessageDescription::copy()
     QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
 
     QCanMessageDescription d1(d);
-    QCOMPARE(d1, d);
+    QVERIFY(equals(d1, d));
     QVERIFY(QCanMessageDescriptionPrivate::get(d)->isShared());
     QVERIFY(QCanMessageDescriptionPrivate::get(d1)->isShared());
 
     QCanMessageDescription d2 = d;
-    QCOMPARE(d2, d);
+    QVERIFY(equals(d2, d));
     QVERIFY(QCanMessageDescriptionPrivate::get(d)->isShared());
     QVERIFY(QCanMessageDescriptionPrivate::get(d2)->isShared());
 }
@@ -84,18 +84,18 @@ void tst_QCanMessageDescription::move()
     otherD.setUniqueId(d.uniqueId());
     otherD.setSize(d.size());
     otherD.setSignalDescriptions(d.signalDescriptions());
-    QCOMPARE(otherD, d);
+    QVERIFY(equals(otherD, d));
 
     QCanMessageDescription d1(std::move(d));
-    QCOMPARE(otherD, d1);
+    QVERIFY(equals(otherD, d1));
     QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
 
     QCanMessageDescription d2 = std::move(d1);
-    QCOMPARE(otherD, d2);
+    QVERIFY(equals(otherD, d2));
     QVERIFY(!QCanMessageDescriptionPrivate::get(d2)->isShared());
 
     d = std::move(d2);
-    QCOMPARE(otherD, d);
+    QVERIFY(equals(otherD, d));
     QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
 }
 
@@ -103,7 +103,7 @@ void tst_QCanMessageDescription::comparison()
 {
     {
         QCanMessageDescription d1 = d;
-        QCOMPARE(d1, d);
+        QVERIFY(equals(d1, d));
         // also check that calling const methods does not detach
         d1.isValid();
         d1.uniqueId();
@@ -119,42 +119,42 @@ void tst_QCanMessageDescription::comparison()
     {
         QCanMessageDescription d1 = d;
         d1.setName("test1");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanMessageDescription d1 = d;
         d1.setUniqueId(QtCanBus::UniqueId{456});
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanMessageDescription d1 = d;
         d1.setSize(3);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanMessageDescription d1 = d;
         d1.setTransmitter("t");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanMessageDescription d1 = d;
         d1.setComment("comment");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanMessageDescription d1 = d;
         d1.clearSignalDescriptions();
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
@@ -165,14 +165,14 @@ void tst_QCanMessageDescription::comparison()
     {
         QCanMessageDescription d1 = d;
         d1.addSignalDescription(s);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanMessageDescription d1 = d;
         d1.setSignalDescriptions({ s });
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanMessageDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanMessageDescriptionPrivate::get(d1)->isShared());
     }
diff --git a/tests/auto/qcansignaldescription/tst_qcansignaldescription.cpp b/tests/auto/qcansignaldescription/tst_qcansignaldescription.cpp
index cffd7a0..e36279c 100644
--- a/tests/auto/qcansignaldescription/tst_qcansignaldescription.cpp
+++ b/tests/auto/qcansignaldescription/tst_qcansignaldescription.cpp
@@ -57,12 +57,12 @@ void tst_QCanSignalDescription::copy()
     QCanSignalDescription d1 = d;
     QVERIFY(QCanSignalDescriptionPrivate::get(d)->isShared());
     QVERIFY(QCanSignalDescriptionPrivate::get(d1)->isShared());
-    QCOMPARE(d1, d);
+    QVERIFY(equals(d1, d));
 
     QCanSignalDescription d2(d);
     QVERIFY(QCanSignalDescriptionPrivate::get(d)->isShared());
     QVERIFY(QCanSignalDescriptionPrivate::get(d2)->isShared());
-    QCOMPARE(d2, d);
+    QVERIFY(equals(d2, d));
 }
 
 void tst_QCanSignalDescription::move()
@@ -95,7 +95,7 @@ void tst_QCanSignalDescription::comparison()
 
     {
         QCanSignalDescription d1 = d;
-        QCOMPARE(d1, d);
+        QVERIFY(equals(d1, d));
         // also check that calling const methods does not detach
         d1.isValid();
         d1.name();
@@ -120,91 +120,91 @@ void tst_QCanSignalDescription::comparison()
     {
         QCanSignalDescription d1 = d;
         d1.setName("test1");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setPhysicalUnit("");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setReceiver("");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setComment("comment");
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setDataSource(QtCanBus::DataSource::FrameId);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setDataEndian(QSysInfo::Endian::LittleEndian);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setDataFormat(QtCanBus::DataFormat::Float);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setStartBit(1);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setBitLength(32);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setFactor(3.0);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setOffset(5.5);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setScaling(0.1);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setRange(-10.5, 10.5);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.setMultiplexState(QtCanBus::MultiplexState::SwitchAndSignal);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.clearMultiplexSignals();
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
@@ -212,13 +212,13 @@ void tst_QCanSignalDescription::comparison()
         QCanSignalDescription::MultiplexSignalValues muxValues;
         muxValues.insert("s0", QCanSignalDescription::MultiplexValues{ {1, 1} });
         d1.setMultiplexSignals(muxValues);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanSignalDescription d1 = d;
         d1.addMultiplexSignal("s0", 1);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanSignalDescriptionPrivate::get(d1)->isShared());
     }
 }
diff --git a/tests/auto/qcanuniqueiddescription/tst_qcanuniqueiddescription.cpp b/tests/auto/qcanuniqueiddescription/tst_qcanuniqueiddescription.cpp
index 7c24742..4857be8 100644
--- a/tests/auto/qcanuniqueiddescription/tst_qcanuniqueiddescription.cpp
+++ b/tests/auto/qcanuniqueiddescription/tst_qcanuniqueiddescription.cpp
@@ -51,12 +51,12 @@ void tst_QCanUniqueIdDescription::copy()
     QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d)->isShared());
 
     QCanUniqueIdDescription d1(d);
-    QCOMPARE(d1, d);
+    QVERIFY(equals(d1, d));
     QVERIFY(QCanUniqueIdDescriptionPrivate::get(d)->isShared());
     QVERIFY(QCanUniqueIdDescriptionPrivate::get(d1)->isShared());
 
     QCanUniqueIdDescription d2 = d;
-    QCOMPARE(d2, d);
+    QVERIFY(equals(d2, d));
     QVERIFY(QCanUniqueIdDescriptionPrivate::get(d)->isShared());
     QVERIFY(QCanUniqueIdDescriptionPrivate::get(d2)->isShared());
 }
@@ -73,15 +73,15 @@ void tst_QCanUniqueIdDescription::move()
     otherD.setBitLength(d.bitLength());
 
     QCanUniqueIdDescription d1(std::move(d));
-    QCOMPARE(d1, otherD);
+    QVERIFY(equals(d1, otherD));
     QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d1)->isShared());
 
     QCanUniqueIdDescription d2 = std::move(d1);
-    QCOMPARE(d2, otherD);
+    QVERIFY(equals(d2, otherD));
     QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d2)->isShared());
 
     d = std::move(d2);
-    QCOMPARE(d, otherD);
+    QVERIFY(equals(d, otherD));
     QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d)->isShared());
 }
 
@@ -89,7 +89,7 @@ void tst_QCanUniqueIdDescription::comparison()
 {
     {
         QCanUniqueIdDescription d1 = d;
-        QCOMPARE(d1, d);
+        QVERIFY(equals(d1, d));
         // also check that calling const methods does not detach
         d1.isValid();
         d1.source();
@@ -102,28 +102,28 @@ void tst_QCanUniqueIdDescription::comparison()
     {
         QCanUniqueIdDescription d1 = d;
         d1.setSource(QtCanBus::DataSource::Payload);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanUniqueIdDescription d1 = d;
         d1.setEndian(QSysInfo::Endian::BigEndian);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanUniqueIdDescription d1 = d;
         d1.setStartBit(1);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d1)->isShared());
     }
     {
         QCanUniqueIdDescription d1 = d;
         d1.setBitLength(10);
-        QCOMPARE_NE(d1, d);
+        QVERIFY(!equals(d1, d));
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d)->isShared());
         QVERIFY(!QCanUniqueIdDescriptionPrivate::get(d1)->isShared());
     }
diff --git a/tests/auto/shared/qcanmessagedescription_helpers.h b/tests/auto/shared/qcanmessagedescription_helpers.h
index 4c69a63..8ce55e7 100644
--- a/tests/auto/shared/qcanmessagedescription_helpers.h
+++ b/tests/auto/shared/qcanmessagedescription_helpers.h
@@ -10,21 +10,28 @@
 
 QT_BEGIN_NAMESPACE
 
-inline bool operator==(const QCanMessageDescription &lhs,
-                       const QCanMessageDescription &rhs) noexcept
+inline bool equals(const QCanMessageDescription &lhs, const QCanMessageDescription &rhs) noexcept
 {
     return lhs.uniqueId() == rhs.uniqueId()
             && lhs.name() == rhs.name()
             && lhs.size() == rhs.size()
             && lhs.transmitter() == rhs.transmitter()
             && lhs.comment() == rhs.comment()
-            && lhs.signalDescriptions() == rhs.signalDescriptions();
+            && equals(lhs.signalDescriptions(), rhs.signalDescriptions());
 }
 
-inline bool operator!=(const QCanMessageDescription &lhs,
-                       const QCanMessageDescription &rhs) noexcept
+inline bool equals(const QList<QCanMessageDescription> &lhs,
+                   const QList<QCanMessageDescription> &rhs) noexcept
 {
-    return !(lhs == rhs);
+    if (lhs.size() != rhs.size())
+        return false;
+
+    for (qsizetype idx = 0; idx < lhs.size(); ++idx) {
+        if (!equals(lhs.at(idx), rhs.at(idx)))
+            return false;
+    }
+
+    return true;
 }
 
 QT_END_NAMESPACE
diff --git a/tests/auto/shared/qcansignaldescription_helpers.h b/tests/auto/shared/qcansignaldescription_helpers.h
index 6383150..6d3a0a4 100644
--- a/tests/auto/shared/qcansignaldescription_helpers.h
+++ b/tests/auto/shared/qcansignaldescription_helpers.h
@@ -30,8 +30,7 @@ bool floatingCompare(const T &actual, const T &expected)
     }
 }
 
-inline bool operator==(const QCanSignalDescription &lhs,
-                       const QCanSignalDescription &rhs) noexcept
+inline bool equals(const QCanSignalDescription &lhs, const QCanSignalDescription &rhs) noexcept
 {
     return lhs.name() == rhs.name()
             && lhs.physicalUnit() == rhs.physicalUnit()
@@ -51,10 +50,18 @@ inline bool operator==(const QCanSignalDescription &lhs,
             && lhs.multiplexSignals() == rhs.multiplexSignals();
 }
 
-inline bool operator!=(const QCanSignalDescription &lhs,
-                       const QCanSignalDescription &rhs) noexcept
+inline bool equals(const QList<QCanSignalDescription> &lhs,
+                   const QList<QCanSignalDescription> &rhs) noexcept
 {
-    return !(lhs == rhs);
+    if (lhs.size() != rhs.size())
+        return false;
+
+    for (qsizetype idx = 0; idx < lhs.size(); ++idx) {
+        if (!equals(lhs.at(idx), rhs.at(idx)))
+            return false;
+    }
+
+    return true;
 }
 
 QT_END_NAMESPACE
diff --git a/tests/auto/shared/qcanuniqueiddescription_helpers.h b/tests/auto/shared/qcanuniqueiddescription_helpers.h
index a1932fe..9472d6a 100644
--- a/tests/auto/shared/qcanuniqueiddescription_helpers.h
+++ b/tests/auto/shared/qcanuniqueiddescription_helpers.h
@@ -8,8 +8,7 @@
 
 QT_BEGIN_NAMESPACE
 
-inline bool operator==(const QCanUniqueIdDescription &lhs,
-                       const QCanUniqueIdDescription &rhs) noexcept
+inline bool equals(const QCanUniqueIdDescription &lhs, const QCanUniqueIdDescription &rhs) noexcept
 {
     return lhs.source() == rhs.source()
             && lhs.startBit() == rhs.startBit()
@@ -17,12 +16,6 @@ inline bool operator==(const QCanUniqueIdDescription &lhs,
             && lhs.endian() == rhs.endian();
 }
 
-inline bool operator!=(const QCanUniqueIdDescription &lhs,
-                       const QCanUniqueIdDescription &rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-
 QT_END_NAMESPACE
 
 #endif // QCANUNIQUEIDDESCRIPTION_HELPERS_H