QBitArray: use new comparison helper macros

Replace public friend operators operator==(), operator!=() of
QBitArray to friend method comparesEqual() and
Q_DECLARE_EQUALITY_COMPARABLE macro.

Task-number: QTBUG-120304
Change-Id: I6b47111c144016b3aa05f01c8035c32d164291ad
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>

5 files changed, 116 insertions, 89 deletions

diff --git a/src/corelib/compat/removed_api.cpp b/src/corelib/compat/removed_api.cpp
index 9b7ad48384..c8cc969f81 100644
--- a/src/corelib/compat/removed_api.cpp
+++ b/src/corelib/compat/removed_api.cpp
@@ -929,6 +929,7 @@ QUrl QUrl::fromEncoded(const QByteArray &input, ParsingMode mode)
 #endif // QT_CORE_REMOVED_SINCE(6, 7)
 
 #if QT_CORE_REMOVED_SINCE(6, 8)
+#include "qbitarray.h" // inlined API
 
 #include "qbytearray.h" // inlined API
 
diff --git a/src/corelib/tools/qbitarray.cpp b/src/corelib/tools/qbitarray.cpp
index e311fee51f..e4276d383d 100644
--- a/src/corelib/tools/qbitarray.cpp
+++ b/src/corelib/tools/qbitarray.cpp
@@ -23,6 +23,8 @@ QT_BEGIN_NAMESPACE
     \ingroup shared
     \reentrant
 
+    \compares equality
+
     A QBitArray is an array that gives access to individual bits and
     provides operators (\l{operator&()}{AND}, \l{operator|()}{OR},
     \l{operator^()}{XOR}, and \l{operator~()}{NOT}) that work on
@@ -499,17 +501,17 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
     fast and never fails.
 */
 
-/*! \fn bool QBitArray::operator==(const QBitArray &other) const
+/*! \fn bool QBitArray::operator==(const QBitArray &lhs, const QBitArray &rhs)
 
-    Returns \c true if \a other is equal to this bit array; otherwise
+    Returns \c true if \a lhs is equal to \a rhs bit array; otherwise
     returns \c false.
 
     \sa operator!=()
 */
 
-/*! \fn bool QBitArray::operator!=(const QBitArray &other) const
+/*! \fn bool QBitArray::operator!=(const QBitArray &lhs, const QBitArray &rhs)
 
-    Returns \c true if \a other is not equal to this bit array;
+    Returns \c true if \a lhs is not equal to \a rhs bit array;
     otherwise returns \c false.
 
     \sa operator==()
diff --git a/src/corelib/tools/qbitarray.h b/src/corelib/tools/qbitarray.h
index 4f99e693eb..b9c36b5320 100644
--- a/src/corelib/tools/qbitarray.h
+++ b/src/corelib/tools/qbitarray.h
@@ -116,8 +116,10 @@ public:
     QBitArray operator~() const;
 #endif
 
-    inline bool operator==(const QBitArray &other) const { return d == other.d; }
-    inline bool operator!=(const QBitArray &other) const { return d != other.d; }
+#if QT_CORE_REMOVED_SINCE(6, 8)
+    inline bool operator==(const QBitArray &other) const { return comparesEqual(d, other.d); }
+    inline bool operator!=(const QBitArray &other) const { return !operator==(other); }
+#endif
 
     bool fill(bool aval, qsizetype asize = -1)
     { *this = QBitArray((asize < 0 ? this->size() : asize), aval); return true; }
@@ -134,6 +136,13 @@ public:
     typedef QByteArray::DataPointer DataPtr;
     inline DataPtr &data_ptr() { return d.data_ptr(); }
     inline const DataPtr &data_ptr() const { return d.data_ptr(); }
+
+private:
+    friend bool comparesEqual(const QBitArray &lhs, const QBitArray &rhs) noexcept
+    {
+        return lhs.d == rhs.d;
+    }
+    Q_DECLARE_EQUALITY_COMPARABLE(QBitArray)
 };
 
 class QT6_ONLY(Q_CORE_EXPORT) QBitRef
diff --git a/tests/auto/corelib/tools/qbitarray/CMakeLists.txt b/tests/auto/corelib/tools/qbitarray/CMakeLists.txt
index 802d647abb..ac3bd24bd5 100644
--- a/tests/auto/corelib/tools/qbitarray/CMakeLists.txt
+++ b/tests/auto/corelib/tools/qbitarray/CMakeLists.txt
@@ -14,4 +14,6 @@ endif()
 qt_internal_add_test(tst_qbitarray
     SOURCES
         tst_qbitarray.cpp
+    LIBRARIES
+        Qt::TestPrivate
 )
diff --git a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
index 5fcf444485..f52a368aa9 100644
--- a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
+++ b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
 #include <QTest>
+#include <QtTest/private/qcomparisontesthelper_p.h>
 #include <QtCore/QBuffer>
 #include <QtCore/QDataStream>
 
@@ -39,6 +40,7 @@ class tst_QBitArray : public QObject
 {
     Q_OBJECT
 private slots:
+    void compareCompiles();
     void canHandleIntMaxBits();
     void size_data();
     void size();
@@ -85,6 +87,11 @@ private slots:
     void toUInt32();
 };
 
+void tst_QBitArray::compareCompiles()
+{
+    QTestPrivate::testEqualityOperatorsCompile<QBitArray>();
+}
+
 void tst_QBitArray::canHandleIntMaxBits()
 {
     QElapsedTimer timer;
@@ -126,7 +133,7 @@ void tst_QBitArray::canHandleIntMaxBits()
             QBitArray ba2;
             ds >> ba2;
             QCOMPARE(ds.status(), QDataStream::Status::Ok);
-            QCOMPARE(ba, ba2);
+            QT_TEST_EQUALITY_OPS(ba, ba2, true);
         }
     } catch (const std::bad_alloc &) {
         QSKIP("Failed to allocate sufficient memory");
@@ -266,14 +273,20 @@ void tst_QBitArray::isEmpty()
     QVERIFY(!a1.isEmpty());
     QVERIFY(!a1.isNull());
     QVERIFY(a1.size() == 2);
+
+    QT_TEST_EQUALITY_OPS(a1, a2, false);
+    QT_TEST_EQUALITY_OPS(a2, a3, false);
+    QT_TEST_EQUALITY_OPS(QBitArray(), QBitArray(), true);
+    a3 = a2;
+    QT_TEST_EQUALITY_OPS(a2, a3, true);
 }
 
 void tst_QBitArray::swap()
 {
     QBitArray b1 = QStringToQBitArray("1"), b2 = QStringToQBitArray("10");
     b1.swap(b2);
-    QCOMPARE(b1,QStringToQBitArray("10"));
-    QCOMPARE(b2,QStringToQBitArray("1"));
+    QT_TEST_EQUALITY_OPS(b1,QStringToQBitArray("10"), true);
+    QT_TEST_EQUALITY_OPS(b2,QStringToQBitArray("1"), true);
 }
 
 void tst_QBitArray::fill()
@@ -323,7 +336,7 @@ void tst_QBitArray::toggleBit()
 
     input.toggleBit(index);
 
-    QCOMPARE(input, res);
+    QT_TEST_EQUALITY_OPS(input, res, true);
 }
 
 void tst_QBitArray::operator_andeq_data()
@@ -370,32 +383,32 @@ void tst_QBitArray::operator_andeq()
 
     QBitArray result = input1;
     result &= input2;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1;
     result &= std::move(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1;
     result &= detached(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is commutative
     result = input2;
     result &= input1;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2;
     result &= std::move(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2;
     result &= detached(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is idempotent
     result &= result;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result &= std::move(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result &= detached(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 }
 
 void tst_QBitArray::operator_and()
@@ -405,27 +418,27 @@ void tst_QBitArray::operator_and()
     QFETCH(QBitArray, res);
 
     QBitArray result = input1 & input2;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1 & QBitArray(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1 & detached(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is commutative
     result = input2 & input1;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2 & QBitArray(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2 & detached(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is idempotent
     result = result & result;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = result & QBitArray(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = result & detached(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 }
 
 void tst_QBitArray::operator_oreq_data()
@@ -476,32 +489,32 @@ void tst_QBitArray::operator_oreq()
 
     QBitArray result = input1;
     result |= input2;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1;
     result |= QBitArray(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1;
     result |= detached(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is commutative
     result = input2;
     result |= input1;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2;
     result |= QBitArray(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2;
     result |= detached(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is idempotent
     result |= result;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result |= QBitArray(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result |= detached(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 }
 
 void tst_QBitArray::operator_or()
@@ -511,27 +524,27 @@ void tst_QBitArray::operator_or()
     QFETCH(QBitArray, res);
 
     QBitArray result = input1 | input2;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1 | QBitArray(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1 | detached(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is commutative
     result = input2 | input1;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2 | QBitArray(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2 | detached(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is idempotent
     result = result | result;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = result | QBitArray(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = result | detached(result);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 }
 
 void tst_QBitArray::operator_xoreq_data()
@@ -580,55 +593,55 @@ void tst_QBitArray::operator_xoreq()
 
     QBitArray result = input1;
     result ^= input2;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1;
     result ^= QBitArray(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1;
     result ^= detached(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is commutative
     result = input2;
     result ^= input1;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2;
     result ^= QBitArray(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2;
     result ^= detached(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // XORing with oneself is nilpotent
     result = input1;
     result ^= input1;
-    QCOMPARE(result, QBitArray(input1.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input1.size()), true);
     result = input1;
     result ^= QBitArray(result);
-    QCOMPARE(result, QBitArray(input1.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input1.size()), true);
     result = input1;
     result ^= detached(result);
-    QCOMPARE(result, QBitArray(input1.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input1.size()), true);
 
     result = input2;
     result ^= input2;
-    QCOMPARE(result, QBitArray(input2.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input2.size()), true);
     result = input2;
     result ^= QBitArray(input2);
-    QCOMPARE(result, QBitArray(input2.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input2.size()), true);
     result = input2;
     result ^= detached(input2);
-    QCOMPARE(result, QBitArray(input2.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input2.size()), true);
 
     result = res;
     result ^= res;
-    QCOMPARE(result, QBitArray(res.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(res.size()), true);
     result = res;
     result ^= QBitArray(res);
-    QCOMPARE(result, QBitArray(res.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(res.size()), true);
     result = res;
     result ^= detached(res);
-    QCOMPARE(result, QBitArray(res.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(res.size()), true);
 }
 
 void tst_QBitArray::operator_xor()
@@ -638,41 +651,41 @@ void tst_QBitArray::operator_xor()
     QFETCH(QBitArray, res);
 
     QBitArray result = input1 ^ input2;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1 ^ QBitArray(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input1 ^ detached(input2);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // operation is commutative
     result = input2 ^ input1;
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2 ^ QBitArray(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
     result = input2 ^ detached(input1);
-    QCOMPARE(result, res);
+    QT_TEST_EQUALITY_OPS(result, res, true);
 
     // XORing with oneself is nilpotent
     result = input1 ^ input1;
-    QCOMPARE(result, QBitArray(input1.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input1.size()), true);
     result = input1 ^ QBitArray(input1);
-    QCOMPARE(result, QBitArray(input1.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input1.size()), true);
     result = input1 ^ detached(input1);
-    QCOMPARE(result, QBitArray(input1.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input1.size()), true);
 
     result = input2 ^ input2;
-    QCOMPARE(result, QBitArray(input2.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input2.size()), true);
     result = input2 ^ QBitArray(input2);
-    QCOMPARE(result, QBitArray(input2.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input2.size()), true);
     result = input2 ^ detached(input2);
-    QCOMPARE(result, QBitArray(input2.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(input2.size()), true);
 
     result = res ^ res;
-    QCOMPARE(result, QBitArray(res.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(res.size()), true);
     result = res ^ QBitArray(res);
-    QCOMPARE(result, QBitArray(res.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(res.size()), true);
     result = res ^ detached(res);
-    QCOMPARE(result, QBitArray(res.size()));
+    QT_TEST_EQUALITY_OPS(result, QBitArray(res.size()), true);
 }
 
 void tst_QBitArray::operator_neg_data()
@@ -721,8 +734,8 @@ void tst_QBitArray::operator_neg()
 
     input = ~input;
 
-    QCOMPARE(input, res);
-    QCOMPARE(~~input, res);     // performs two in-place negations
+    QT_TEST_EQUALITY_OPS(input, res, true);
+    QT_TEST_EQUALITY_OPS(~~input, res, true);     // performs two in-place negations
 }
 
 void tst_QBitArray::datastream_data()
@@ -782,15 +795,15 @@ void tst_QBitArray::datastream()
     QCOMPARE(array1.count(true), onBits);
     QCOMPARE(array1.count(false), numBits - onBits);
 
-    QCOMPARE(array1, bits);
-    QCOMPARE(array2, bits);
-    QCOMPARE(array3, bits);
+    QT_TEST_EQUALITY_OPS(array1, bits, true);
+    QT_TEST_EQUALITY_OPS(array2, bits, true);
+    QT_TEST_EQUALITY_OPS(array3, bits, true);
 }
 
 void tst_QBitArray::invertOnNull() const
 {
     QBitArray a;
-    QCOMPARE(a = ~a, QBitArray());
+    QT_TEST_EQUALITY_OPS(a = ~a, QBitArray(), true);
 }
 
 void tst_QBitArray::operator_noteq_data()
@@ -831,7 +844,7 @@ void tst_QBitArray::operator_noteq()
     QFETCH(bool, res);
 
     bool b = input1 != input2;
-    QCOMPARE(b, res);
+    QT_TEST_EQUALITY_OPS(b, res, true);
 }
 
 void tst_QBitArray::resize()
@@ -840,22 +853,22 @@ void tst_QBitArray::resize()
     QBitArray a = QStringToQBitArray(QString("11"));
     a.resize(10);
     QVERIFY(a.size() == 10);
-    QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );
+    QT_TEST_EQUALITY_OPS( a, QStringToQBitArray(QString("1100000000")), true);
 
     a.setBit(9);
     a.resize(9);
     // now the bit in a should have been gone:
-    QCOMPARE( a, QStringToQBitArray(QString("110000000")) );
+    QT_TEST_EQUALITY_OPS( a, QStringToQBitArray(QString("110000000")), true);
 
     // grow the array back and check the new bit
     a.resize(10);
-    QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );
+    QT_TEST_EQUALITY_OPS( a, QStringToQBitArray(QString("1100000000")), true);
 
     // other test with and
     a.resize(9);
     QBitArray b = QStringToQBitArray(QString("1111111111"));
     b &= a;
-    QCOMPARE( b, QStringToQBitArray(QString("1100000000")) );
+    QT_TEST_EQUALITY_OPS( b, QStringToQBitArray(QString("1100000000")), true);
 
 }
 
@@ -909,9 +922,9 @@ void tst_QBitArray::fromBits()
     QFETCH(QBitArray, expected);
 
     QBitArray fromBits = QBitArray::fromBits(data, size);
-    QCOMPARE(fromBits, expected);
+    QT_TEST_EQUALITY_OPS(fromBits, expected, true);
 
-    QCOMPARE(QBitArray::fromBits(fromBits.bits(), fromBits.size()), expected);
+    QT_TEST_EQUALITY_OPS(QBitArray::fromBits(fromBits.bits(), fromBits.size()), expected, true);
 }
 
 void tst_QBitArray::toUInt32_data()