QKeyCombination: use new comparison helper macros

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

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

src/corelib/global/qnamespace.h

@@ -10,6 +10,7 @@
 #endif
 
 #include <QtCore/qglobal.h>
+#include <QtCore/qcompare.h>
 #include <QtCore/qtmetamacros.h>
 
 #if defined(__OBJC__) && !defined(__cplusplus)
@@ -1908,18 +1909,14 @@ public:
         return combination;
     }
 #endif
-
+    bool operator<(QKeyCombination) const = delete;
-    friend constexpr bool operator==(QKeyCombination lhs, QKeyCombination rhs) noexcept
+private:
+    friend constexpr bool comparesEqual(const QKeyCombination &lhs,
+                                        const QKeyCombination &rhs) noexcept
     {
         return lhs.combination == rhs.combination;
     }
-
+    Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QKeyCombination)
-    friend constexpr bool operator!=(QKeyCombination lhs, QKeyCombination rhs) noexcept
-    {
-        return lhs.combination != rhs.combination;
-    }
-
-    bool operator<(QKeyCombination) const = delete;
 };
 
 Q_DECLARE_TYPEINFO(QKeyCombination, Q_RELOCATABLE_TYPE);

src/corelib/global/qnamespace.qdoc

@@ -3407,6 +3407,8 @@
   \since 6.0
   \brief The QKeyCombination class stores a combination of a key with optional modifiers.
 
+  \compares equality
+
   The QKeyCombination class can be used to represent a combination of a key
   with zero or more keyboard modifiers.
 
@@ -3489,14 +3491,14 @@
 #endif
 
 /*!
-  \fn bool QKeyCombination::operator==(QKeyCombination lhs, QKeyCombination rhs) noexcept
+  \fn bool QKeyCombination::operator==(const QKeyCombination &lhs, const QKeyCombination &rhs)
 
   Returns \c true if \a lhs and \a rhs have the same combination
   of key and modifiers, and \c false otherwise.
 */
 
 /*!
-  \fn bool QKeyCombination::operator!=(QKeyCombination lhs, QKeyCombination rhs) noexcept
+  \fn bool QKeyCombination::operator!=(const QKeyCombination &lhs, const QKeyCombination &rhs)
 
   Returns \c true if \a lhs and \a rhs have different combinations
   of key and modifiers, otherwise \c false.

tests/auto/corelib/global/qkeycombination/CMakeLists.txt

@@ -14,4 +14,6 @@ endif()
 qt_internal_add_test(tst_qkeycombination
     SOURCES
         tst_qkeycombination.cpp
+    LIBRARIES
+        Qt::TestPrivate
 )

tests/auto/corelib/global/qkeycombination/tst_qkeycombination.cpp

@@ -3,11 +3,13 @@
 
 #include <QObject>
 #include <QTest>
+#include <QtTest/private/qcomparisontesthelper_p.h>
 
 class tst_QKeyCombination : public QObject
 {
     Q_OBJECT
 private slots:
+    void compareCompiles();
     void construction();
     void operator_eq();
     void operator_or();
@@ -24,6 +26,11 @@ constexpr auto bitwiseOr(T ... args)
     return (... | ((int)args));
 }
 
+void tst_QKeyCombination::compareCompiles()
+{
+    QTestPrivate::testEqualityOperatorsCompile<QKeyCombination>();
+}
+
 void tst_QKeyCombination::construction()
 {
     {
@@ -131,145 +138,125 @@ void tst_QKeyCombination::operator_eq()
     // default
     {
         QKeyCombination a, b;
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     // key only
     {
         QKeyCombination a;
         QKeyCombination b(Qt::Key_X);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::Key_Y);
         QKeyCombination b;
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::Key_Y);
         QKeyCombination b(Qt::Key_X);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::Key_F1);
         QKeyCombination b(Qt::Key_F1);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     // modifier only
     {
         QKeyCombination a;
         QKeyCombination b(Qt::CTRL);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::CTRL);
         QKeyCombination b;
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::CTRL);
         QKeyCombination b(Qt::SHIFT);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::CTRL);
         QKeyCombination b(Qt::CTRL);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     {
         QKeyCombination a(Qt::CTRL);
         QKeyCombination b(Qt::ControlModifier);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     {
         QKeyCombination a(Qt::ControlModifier);
         QKeyCombination b(Qt::CTRL);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     {
         QKeyCombination a(Qt::ControlModifier);
         QKeyCombination b(Qt::ControlModifier);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     // key and modifier
     {
         QKeyCombination a(Qt::Key_A);
         QKeyCombination b(Qt::SHIFT, Qt::Key_A);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::CTRL, Qt::Key_A);
         QKeyCombination b(Qt::SHIFT, Qt::Key_A);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::SHIFT, Qt::Key_A);
         QKeyCombination b(Qt::SHIFT, Qt::Key_A);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     {
         QKeyCombination a(Qt::SHIFT, Qt::Key_A);
         QKeyCombination b(Qt::SHIFT, Qt::Key_Escape);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::SHIFT, Qt::Key_A);
         QKeyCombination b(Qt::ShiftModifier, Qt::Key_A);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     {
         QKeyCombination a(Qt::SHIFT | Qt::CTRL, Qt::Key_A);
         QKeyCombination b(Qt::ControlModifier | Qt::ShiftModifier, Qt::Key_A);
-        QVERIFY(a == b);
+        QT_TEST_EQUALITY_OPS(a, b, true);
-        QVERIFY(!(a != b));
     }
 
     // corner cases
     {
         QKeyCombination a(Qt::CTRL);
         QKeyCombination b(Qt::Key_Control);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 
     {
         QKeyCombination a(Qt::ALT);
         QKeyCombination b(Qt::Key_Alt);
-        QVERIFY(a != b);
+        QT_TEST_EQUALITY_OPS(a, b, false);
-        QVERIFY(!(a == b));
     }
 }