Fixed QGraphicsScene autotest failure in task250680_childClip.

The path comparison is too strict. Even though the paths are equivalent
(represent the same area) the comparison fails as they don't have the
same representation. If we simplify the clip path and use the more
generic path comparison approach from the QPathClipper autotest the test
passes.

Reviewed-by: Olivier Goffart

2 files changed, 133 insertions, 82 deletions

diff --git a/tests/auto/qpathclipper/pathcompare.h b/tests/auto/qpathclipper/pathcompare.h
new file mode 100644
index 0000000..eb25e4c
--- /dev/null
+++ b/tests/auto/qpathclipper/pathcompare.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef PATHCOMPARE_H
+#define PATHCOMPARE_H
+
+#include <qmath.h>
+
+namespace QPathCompare {
+
+static const int precision = 8;
+static const qreal epsilon = qPow(0.1, precision);
+
+static inline bool fuzzyIsZero(qreal x, qreal relative)
+{
+    if (qAbs(relative) < epsilon)
+        return qAbs(x) < epsilon;
+    else
+        return qAbs(x / relative) < epsilon;
+}
+
+static bool fuzzyCompare(const QPointF &a, const QPointF &b)
+{
+    const QPointF delta = a - b;
+
+    const qreal x = qMax(qAbs(a.x()), qAbs(b.x()));
+    const qreal y = qMax(qAbs(a.y()), qAbs(b.y()));
+
+    return fuzzyIsZero(delta.x(), x) && fuzzyIsZero(delta.y(), y);
+}
+
+static bool isClosed(const QPainterPath &path)
+{
+    if (path.elementCount() == 0)
+        return false;
+
+    QPointF first = path.elementAt(0);
+    QPointF last = path.elementAt(path.elementCount() - 1);
+
+    return fuzzyCompare(first, last);
+}
+
+// rotation and direction independent path comparison
+// allows paths to be shifted or reversed relative to each other
+static bool comparePaths(const QPainterPath &actual, const QPainterPath &expected)
+{
+    const int endActual = isClosed(actual) ? actual.elementCount() - 1 : actual.elementCount();
+    const int endExpected = isClosed(expected) ? expected.elementCount() - 1 : expected.elementCount();
+
+    if (endActual != endExpected)
+        return false;
+
+    for (int i = 0; i < endActual; ++i) {
+        int k = 0;
+        for (k = 0; k < endActual; ++k) {
+            int i1 = k;
+            int i2 = (i + k) % endActual;
+
+            QPointF a = actual.elementAt(i1);
+            QPointF b = expected.elementAt(i2);
+
+            if (!fuzzyCompare(a, b))
+                break;
+        }
+
+        if (k == endActual)
+            return true;
+
+        for (k = 0; k < endActual; ++k) {
+            int i1 = k;
+            int i2 = (i + endActual - k) % endActual;
+
+            QPointF a = actual.elementAt(i1);
+            QPointF b = expected.elementAt(i2);
+
+            if (!fuzzyCompare(a, b))
+                break;
+        }
+
+        if (k == endActual)
+            return true;
+    }
+
+    return false;
+}
+
+}
+
+#endif
diff --git a/tests/auto/qpathclipper/tst_qpathclipper.cpp b/tests/auto/qpathclipper/tst_qpathclipper.cpp
index 9e37988..38d253a 100644
--- a/tests/auto/qpathclipper/tst_qpathclipper.cpp
+++ b/tests/auto/qpathclipper/tst_qpathclipper.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 #include "private/qpathclipper_p.h"
 #include "paths.h"
+#include "pathcompare.h"
 
 #include <QtTest/QtTest>
 
@@ -430,82 +431,6 @@ void tst_QPathClipper::clip_data()
                                         << samplePath14();
 }
 
-static const int precision = 8;
-static const qreal epsilon = pow(0.1, precision);
-
-static inline bool fuzzyIsZero(qreal x, qreal relative)
-{
-    if (qAbs(relative) < epsilon)
-        return qAbs(x) < epsilon;
-    else
-        return qAbs(x / relative) < epsilon;
-}
-
-static bool fuzzyCompare(const QPointF &a, const QPointF &b)
-{
-    const QPointF delta = a - b;
-
-    const qreal x = qMax(qAbs(a.x()), qAbs(b.x()));
-    const qreal y = qMax(qAbs(a.y()), qAbs(b.y()));
-
-    return fuzzyIsZero(delta.x(), x) && fuzzyIsZero(delta.y(), y);
-}
-
-static bool isClosed(const QPainterPath &path)
-{
-    if (path.elementCount() == 0)
-        return false;
-
-    QPointF first = path.elementAt(0);
-    QPointF last = path.elementAt(path.elementCount() - 1);
-
-    return fuzzyCompare(first, last);
-}
-
-// rotation and direction independent path comparison
-// allows paths to be shifted or reversed relative to each other
-static bool comparePaths(const QPainterPath &actual, const QPainterPath &expected)
-{
-    const int endActual = isClosed(actual) ? actual.elementCount() - 1 : actual.elementCount();
-    const int endExpected = isClosed(expected) ? expected.elementCount() - 1 : expected.elementCount();
-
-    if (endActual != endExpected)
-        return false;
-
-    for (int i = 0; i < endActual; ++i) {
-        int k = 0;
-        for (k = 0; k < endActual; ++k) {
-            int i1 = k;
-            int i2 = (i + k) % endActual;
-
-            QPointF a = actual.elementAt(i1);
-            QPointF b = expected.elementAt(i2);
-
-            if (!fuzzyCompare(a, b))
-                break;
-        }
-
-        if (k == endActual)
-            return true;
-
-        for (k = 0; k < endActual; ++k) {
-            int i1 = k;
-            int i2 = (i + endActual - k) % endActual;
-
-            QPointF a = actual.elementAt(i1);
-            QPointF b = expected.elementAt(i2);
-
-            if (!fuzzyCompare(a, b))
-                break;
-        }
-
-        if (k == endActual)
-            return true;
-    }
-
-    return false;
-}
-
 // sanity check to make sure comparePaths declared above works
 void tst_QPathClipper::testComparePaths()
 {
@@ -515,12 +440,12 @@ void tst_QPathClipper::testComparePaths()
     a.addRect(0, 0, 10, 10);
     b.addRect(0, 0, 10.00001, 10.00001);
 
-    QVERIFY(!comparePaths(a, b));
+    QVERIFY(!QPathCompare::comparePaths(a, b));
 
     b = QPainterPath();
     b.addRect(0, 0, 10.00000000001, 10.00000000001);
 
-    QVERIFY(comparePaths(a, b));
+    QVERIFY(QPathCompare::comparePaths(a, b));
 
     b = QPainterPath();
     b.moveTo(10, 0);
@@ -528,9 +453,9 @@ void tst_QPathClipper::testComparePaths()
     b.lineTo(0, 10);
     b.lineTo(10, 10);
 
-    QVERIFY(comparePaths(a, b));
+    QVERIFY(QPathCompare::comparePaths(a, b));
     b.lineTo(10, 0);
-    QVERIFY(comparePaths(a, b));
+    QVERIFY(QPathCompare::comparePaths(a, b));
 
     b = QPainterPath();
     b.moveTo(10, 0);
@@ -538,7 +463,7 @@ void tst_QPathClipper::testComparePaths()
     b.lineTo(0, 0);
     b.lineTo(10, 10);
 
-    QVERIFY(!comparePaths(a, b));
+    QVERIFY(!QPathCompare::comparePaths(a, b));
 }
 
 void tst_QPathClipper::clip()
@@ -553,7 +478,7 @@ void tst_QPathClipper::clip()
     QPathClipper clipper(subject, clip);
     QPainterPath x = clipper.clip(op);
 
-    QVERIFY(comparePaths(x, result));
+    QVERIFY(QPathCompare::comparePaths(x, result));
 }
 
 static inline QPointF randomPointInRect(const QRectF &rect)