1 files changed, 45 insertions, 41 deletions

diff --git a/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp b/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp
index d198d621e1..70a7798667 100644
--- a/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp
+++ b/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp
@@ -1,5 +1,5 @@
 // Copyright (C) 2022 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
 #include <QTest>
 #include <QtCore/qtimer.h>
@@ -93,11 +93,13 @@ static ClassWithPointerGetter getClassForValue(int val)
 // various toString() overloads
 namespace QTest {
 
-char *toString(const int *val)
+template <> char *toString(const int *const &val)
 {
     return val ? toString(*val) : toString(nullptr);
 }
 
+} // namespace QTest
+
 char *toString(const MyClass &val)
 {
     char *msg = new char[128];
@@ -117,8 +119,6 @@ char *toString(const MyClass *val)
     return toString(nullptr);
 }
 
-} // namespace QTest
-
 enum MyUnregisteredEnum { MyUnregisteredEnumValue1, MyUnregisteredEnumValue2 };
 
 class tst_ExtendedCompare : public QObject
@@ -161,107 +161,115 @@ void tst_ExtendedCompare::initTestCase_data()
     QTest::newRow("GE") << QTest::ComparisonOperation::GreaterThanOrEqual;
 }
 
-#define GENERATE_DATA_FOR_TYPE(Type, val1, val2) \
-do { \
-    Q_ASSERT(val1 < val2); \
-    QTest::addColumn<Type>("lhs"); \
-    QTest::addColumn<Type>("rhs"); \
-    QTest::newRow("left == right") << val1 << val1; \
-    QTest::newRow("left < right") << val1 << val2; \
-    QTest::newRow("left > right") << val2 << val1; \
-} while (false)
-
-#define EXECUTE_COMPARISON_FOR_TYPE(Type) \
-do { \
-    QFETCH_GLOBAL(QTest::ComparisonOperation, operation); \
-    QFETCH(Type, lhs); \
-    QFETCH(Type, rhs); \
-    COMPARE_WITH_TYPE(operation, lhs, rhs); \
-} while (false)
+template <typename T> static void generateData(T val1, T val2)
+{
+    Q_ASSERT(val1 < val2);
+    QTest::addColumn<T>("lhs");
+    QTest::addColumn<T>("rhs");
+    QTest::newRow("left == right") << val1 << val1;
+    QTest::newRow("left < right") << val1 << val2;
+    QTest::newRow("left > right") << val2 << val1;
+}
+
+template <typename T> static void executeComparison()
+{
+    QFETCH_GLOBAL(QTest::ComparisonOperation, operation);
+    QFETCH(T, lhs);
+    QFETCH(T, rhs);
+    switch (operation) {
+    case QTest::ComparisonOperation::CustomCompare:      QCOMPARE(lhs, rhs); break;
+    case QTest::ComparisonOperation::Equal:              QCOMPARE_EQ(lhs, rhs); break;
+    case QTest::ComparisonOperation::NotEqual:           QCOMPARE_NE(lhs, rhs); break;
+    case QTest::ComparisonOperation::LessThan:           QCOMPARE_LT(lhs, rhs); break;
+    case QTest::ComparisonOperation::LessThanOrEqual:    QCOMPARE_LE(lhs, rhs); break;
+    case QTest::ComparisonOperation::GreaterThan:        QCOMPARE_GT(lhs, rhs); break;
+    case QTest::ComparisonOperation::GreaterThanOrEqual: QCOMPARE_GE(lhs, rhs); break;
+    }
+}
 
 void tst_ExtendedCompare::compareInts_data()
 {
-    GENERATE_DATA_FOR_TYPE(int, 1, 2);
+    generateData(1, 2);
 }
 
 void tst_ExtendedCompare::compareInts()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(int);
+    executeComparison<int>();
 }
 
 void tst_ExtendedCompare::compareFloats_data()
 {
-    GENERATE_DATA_FOR_TYPE(float, 1.0f, 1.1f);
+    generateData(1.0f, 1.1f);
 }
 
 void tst_ExtendedCompare::compareFloats()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(float);
+    executeComparison<float>();
 }
 
 void tst_ExtendedCompare::compareDoubles_data()
 {
-    GENERATE_DATA_FOR_TYPE(double, 0.0, 0.1);
+    generateData(0.0, 0.1);
 }
 
 void tst_ExtendedCompare::compareDoubles()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(double);
+    executeComparison<double>();
 }
 
 void tst_ExtendedCompare::comparePointers_data()
 {
     static constexpr int values[] = { 1, 2 };
-    GENERATE_DATA_FOR_TYPE(const int *, &values[0], &values[1]);
+    generateData(&values[0], &values[1]);
 }
 
 void tst_ExtendedCompare::comparePointers()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(const int *);
+    executeComparison<const int *>();
 }
 
 void tst_ExtendedCompare::compareToNullptr_data()
 {
     static const int *ptr = nullptr;
     static const int value = 1;
-    GENERATE_DATA_FOR_TYPE(const int *, ptr, &value);
+    generateData(ptr, &value);
 }
 
 void tst_ExtendedCompare::compareToNullptr()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(const int *);
+    executeComparison<const int *>();
 }
 
 void tst_ExtendedCompare::compareUnregistereEnum_data()
 {
-    GENERATE_DATA_FOR_TYPE(MyUnregisteredEnum, MyUnregisteredEnumValue1, MyUnregisteredEnumValue2);
+    generateData(MyUnregisteredEnumValue1, MyUnregisteredEnumValue2);
 }
 
 void tst_ExtendedCompare::compareUnregistereEnum()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(MyUnregisteredEnum);
+    executeComparison<MyUnregisteredEnum>();
 }
 
 void tst_ExtendedCompare::compareRegistereEnum_data()
 {
-    GENERATE_DATA_FOR_TYPE(Qt::DayOfWeek, Qt::Monday, Qt::Sunday);
+    generateData(Qt::Monday, Qt::Sunday);
 }
 
 void tst_ExtendedCompare::compareRegistereEnum()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(Qt::DayOfWeek);
+    executeComparison<Qt::DayOfWeek>();
 }
 
 void tst_ExtendedCompare::compareCustomTypes_data()
 {
     static const MyClass val1(1);
     static const MyClass val2(2);
-    GENERATE_DATA_FOR_TYPE(MyClass, val1, val2);
+    generateData(val1, val2);
 }
 
 void tst_ExtendedCompare::compareCustomTypes()
 {
-    EXECUTE_COMPARISON_FOR_TYPE(MyClass);
+    executeComparison<MyClass>();
 }
 
 void tst_ExtendedCompare::checkComparisonForTemporaryObjects()
@@ -285,8 +293,6 @@ public:
     }
 };
 
-namespace QTest {
-
 char *toString(const ClassWithDeferredSetter &val)
 {
     char *msg = new char[128];
@@ -294,8 +300,6 @@ char *toString(const ClassWithDeferredSetter &val)
     return msg;
 }
 
-} // namespace QTest
-
 void tst_ExtendedCompare::checkComparisonWithTimeout()
 {
     QFETCH_GLOBAL(QTest::ComparisonOperation, operation);