QLine(F): use comparison helper macros

Also explicitly add QLineF vs QLine comparison. Previously such
comparison was implicitly converting QLine to QLineF, and doing the
fuzzy comparison.
The new operators are directly calling operator==(QPointF, QPoint),
which also does the fuzzy comparison, so the old behavior is preserved.

Remove the old relational operators using QT_CORE_REMOVED_SINCE, but
also wrap the new operators in !defined(QT_CORE_REMOVED_SINCE).
That is required, because on Windows the instantiation of
QMetaTypeInterface<QLine(F)> happens in removed_api.cpp (as both
qline.h and qmetatype.h are already included there). If we just add
removed member operators into removed_api.cpp, the metatype interface
will not be able to create an equals() function, because of the
ambiguity in equality operators (member vs friend). That's why we have
to exclude the new friend operators from removed_api.cpp.

Done-with: Fabian Kosmale <fabian.kosmale@qt.io>
Task-number: QTBUG-120308
Change-Id: Ibbf5ec077f69c75da0d36a8be5596acd0fcd44d0
Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>

2 files changed, 74 insertions, 0 deletions

diff --git a/tests/auto/corelib/tools/qline/CMakeLists.txt b/tests/auto/corelib/tools/qline/CMakeLists.txt
index 17a3a1bcef..7d9fdf51a9 100644
--- a/tests/auto/corelib/tools/qline/CMakeLists.txt
+++ b/tests/auto/corelib/tools/qline/CMakeLists.txt
@@ -14,6 +14,8 @@ endif()
 qt_internal_add_test(tst_qline
     SOURCES
         tst_qline.cpp
+    LIBRARIES
+        Qt::TestPrivate
 )
 
 ## Scopes:
diff --git a/tests/auto/corelib/tools/qline/tst_qline.cpp b/tests/auto/corelib/tools/qline/tst_qline.cpp
index 51f1f8ac79..80214707e4 100644
--- a/tests/auto/corelib/tools/qline/tst_qline.cpp
+++ b/tests/auto/corelib/tools/qline/tst_qline.cpp
@@ -4,6 +4,7 @@
 #include <QTest>
 #include <qline.h>
 #include <qmath.h>
+#include <private/qcomparisontesthelper_p.h>
 
 #include <array>
 
@@ -11,6 +12,10 @@ class tst_QLine : public QObject
 {
     Q_OBJECT
 private slots:
+    void testComparisonCompiles();
+    void testComparison_data();
+    void testComparison();
+
     void testIntersection();
     void testIntersection_data();
 
@@ -42,6 +47,73 @@ private slots:
 
 const qreal epsilon = sizeof(qreal) == sizeof(double) ? 1e-8 : 1e-4;
 
+void tst_QLine::testComparisonCompiles()
+{
+    QTestPrivate::testEqualityOperatorsCompile<QLine>();
+    QTestPrivate::testEqualityOperatorsCompile<QLineF>();
+    QTestPrivate::testEqualityOperatorsCompile<QLineF, QLine>();
+}
+
+void tst_QLine::testComparison_data()
+{
+    QTest::addColumn<double>("xa1");
+    QTest::addColumn<double>("ya1");
+    QTest::addColumn<double>("xa2");
+    QTest::addColumn<double>("ya2");
+    QTest::addColumn<double>("xb1");
+    QTest::addColumn<double>("yb1");
+    QTest::addColumn<double>("xb2");
+    QTest::addColumn<double>("yb2");
+    QTest::addColumn<bool>("result");
+    QTest::addColumn<bool>("floatResult");
+    QTest::addColumn<bool>("mixedResult");
+
+    auto row = [&](double xa1, double ya1, double xa2, double ya2,
+                   double xb1, double yb1, double xb2, double yb2,
+                   bool result, bool floatResult, bool mixedResult)
+    {
+        QString str;
+        QDebug dbg(&str);
+        dbg.nospace() << "[(" << xa1 << ", " << ya1 << "); (" << xa2 << ", " << ya2 << ")] vs [("
+                      << xb1 << ", " << yb1 << "); (" << xb2 << ", " << yb2 << ")]";
+        QTest::addRow("%s", str.toLatin1().constData())
+                << xa1 << ya1 << xa2 << ya2 << xb1 << yb1 << xb2 << yb2
+                << result << floatResult << mixedResult;
+    };
+
+    constexpr static qreal qreal_min = std::numeric_limits<qreal>::min();
+
+    row(-1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, true, true, true);
+    row(-1.1, -0.9, 1.1, 0.9, -1.0, -1.0, 1.0, 1.0, true, false, false);
+    row(-1.0, -1.0, 1.0, 1.0, -0.9, -1.1, 0.9, 1.1,  true, false, true);
+    row(-qreal_min, -1.0, 1.0, qreal_min, 0.0, -1.1, 0.9, 0.0,  true, false, true);
+}
+
+void tst_QLine::testComparison()
+{
+    QFETCH(double, xa1);
+    QFETCH(double, ya1);
+    QFETCH(double, xa2);
+    QFETCH(double, ya2);
+    QFETCH(double, xb1);
+    QFETCH(double, yb1);
+    QFETCH(double, xb2);
+    QFETCH(double, yb2);
+    QFETCH(bool, result);
+    QFETCH(bool, floatResult);
+    QFETCH(bool, mixedResult);
+
+    const QLineF l1f(xa1, ya1, xa2, ya2);
+    const QLine l1 = l1f.toLine();
+
+    const QLineF l2f(xb1, yb1, xb2, yb2);
+    const QLine l2 = l2f.toLine();
+
+    QT_TEST_EQUALITY_OPS(l1, l2, result);
+    QT_TEST_EQUALITY_OPS(l1f, l2f, floatResult);
+    QT_TEST_EQUALITY_OPS(l1f, l2, mixedResult);
+}
+
 void tst_QLine::testSet()
 {
     {