tst_Selftests: rewrite this with templates instead of macro

Otherwise it's undebuggable.

Change-Id: I3c79b7e08fa346988dfefffd171ee81fefde63b0
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>

1 files changed, 41 insertions, 33 deletions

diff --git a/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp b/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp
index d198d621e1..b6eb5c870c 100644
--- a/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp
+++ b/tests/auto/testlib/selftests/extendedcompare/tst_extendedcompare.cpp
@@ -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()