/****************************************************************************

**

** 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$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qfile.h>

#include <qpainterpath.h>

#include <qpen.h>

#define _USE_MATH_DEFINES

#include <math.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_QPainterPath : public QObject

{

    Q_OBJECT

public:

private slots:

    void getSetCheck();

    void contains_QPointF_data();

    void contains_QPointF();

    void contains_QRectF_data();

    void contains_QRectF();

    void intersects_QRectF_data();

    void intersects_QRectF();

    void testContainsAndIntersects_data();

    void testContainsAndIntersects();

    void testSimplified_data();

    void testSimplified();

    void testStroker_data();

    void testStroker();

    void currentPosition();

    void testOperatorEquals();

    void testOperatorEquals_fuzzy();

    void testOperatorDatastream();

    void testArcMoveTo_data();

    void testArcMoveTo();

    void setElementPositionAt();

    void testOnPath_data();

    void testOnPath();

    void pointAtPercent_data();

    void pointAtPercent();

    void angleAtPercent();

    void arcWinding_data();

    void arcWinding();

    void testToFillPolygons();

    void closing();

    void operators_data();

    void operators();

    void connectPathDuplicatePoint();

    void translate();

};

// Testing get/set functions

void tst_QPainterPath::getSetCheck()

{

    QPainterPathStroker obj1;

    // qreal QPainterPathStroker::width()

    // void QPainterPathStroker::setWidth(qreal)

    obj1.setWidth(0.0);

    QCOMPARE(qreal(1.0), obj1.width()); // Pathstroker sets with to 1 if <= 0

    obj1.setWidth(0.5);

    QCOMPARE(qreal(0.5), obj1.width());

    obj1.setWidth(1.1);

    QCOMPARE(qreal(1.1), obj1.width());

    // qreal QPainterPathStroker::miterLimit()

    // void QPainterPathStroker::setMiterLimit(qreal)

    obj1.setMiterLimit(0.0);

    QCOMPARE(qreal(0.0), obj1.miterLimit());

    obj1.setMiterLimit(1.1);

    QCOMPARE(qreal(1.1), obj1.miterLimit());

    // qreal QPainterPathStroker::curveThreshold()

    // void QPainterPathStroker::setCurveThreshold(qreal)

    obj1.setCurveThreshold(0.0);

    QCOMPARE(qreal(0.0), obj1.curveThreshold());

    obj1.setCurveThreshold(1.1);

    QCOMPARE(qreal(1.1), obj1.curveThreshold());

}

Q_DECLARE_METATYPE(QPainterPath)

Q_DECLARE_METATYPE(QPointF)

Q_DECLARE_METATYPE(QRectF)

void tst_QPainterPath::currentPosition()

{

    QPainterPath p;

    QCOMPARE(p.currentPosition(), QPointF());

    p.moveTo(100, 100);

    QCOMPARE(p.currentPosition(), QPointF(100, 100));

    p.lineTo(200, 200);

    QCOMPARE(p.currentPosition(), QPointF(200, 200));

    p.cubicTo(300, 200, 200, 300, 500, 500);

    QCOMPARE(p.currentPosition(), QPointF(500, 500));

}

void tst_QPainterPath::contains_QPointF_data()

{

    QTest::addColumn<QPainterPath>("path");

    QTest::addColumn<QPointF>("pt");

    QTest::addColumn<bool>("contained");

    QPainterPath path;

    path.addRect(0, 0, 100, 100);

    // #####

    // #   #

    // #   #

    // #   #

    // #####

    QTest::newRow("[0,0] in [0,0,100,100]") << path << QPointF(0, 0) << true;

    QTest::newRow("[99,0] in [0,0,100,100]") << path << QPointF(99, 0) << true;

    QTest::newRow("[0,99] in [0,0,100,100]") << path << QPointF(0, 99) << true;

    QTest::newRow("[99,99] in [0,0,100,100]") << path << QPointF(99, 99) << true;

    QTest::newRow("[99.99,0] in [0,0,100,100]") << path << QPointF(99.99, 0) << true;

    QTest::newRow("[0,99.99] in [0,0,100,100]") << path << QPointF(0, 99.99) << true;

    QTest::newRow("[99.99,99.99] in [0,0,100,100]") << path << QPointF(99.99, 99.99) << true;

    QTest::newRow("[0.01,0.01] in [0,0,100,100]") << path << QPointF(0.01, 0.01) << true;

    QTest::newRow("[0,0.01] in [0,0,100,100]") << path << QPointF(0, 0.01) << true;

    QTest::newRow("[0.01,0] in [0,0,100,100]") << path << QPointF(0.01, 0) << true;

    QTest::newRow("[-0.01,-0.01] in [0,0,100,100]") << path << QPointF(-0.01, -0.01) << false;

    QTest::newRow("[-0,-0.01] in [0,0,100,100]") << path << QPointF(0, -0.01) << false;

    QTest::newRow("[-0.01,0] in [0,0,100,100]") << path << QPointF(-0.01, 0) << false;

    QTest::newRow("[-10,0] in [0,0,100,100]") << path << QPointF(-10, 0) << false;

    QTest::newRow("[100,0] in [0,0,100,100]") << path << QPointF(100, 0) << false;

    QTest::newRow("[0,-10] in [0,0,100,100]") << path << QPointF(0, -10) << false;

    QTest::newRow("[0,100] in [0,0,100,100]") << path << QPointF(0, 100) << false;

    QTest::newRow("[100.1,0] in [0,0,100,100]") << path << QPointF(100.1, 0) << false;

    QTest::newRow("[0,100.1] in [0,0,100,100]") << path << QPointF(0, 100.1) << false;

    path.addRect(50, 50, 100, 100);

    // #####

    // #   #

    // # #####

    // # # # #

    // ##### #

    //   #   #

    //   #####

    QTest::newRow("[49,49] in 2 rects") << path << QPointF(49,49) << true;

    QTest::newRow("[50,50] in 2 rects") << path << QPointF(50,50) << false;

    QTest::newRow("[100,100] in 2 rects") << path << QPointF(100,100) << true;

    path.setFillRule(Qt::WindingFill);

    QTest::newRow("[50,50] in 2 rects (winding)") << path << QPointF(50,50) << true;

    path.addEllipse(0, 0, 150, 150);

    // #####

    // ##  ##

    // # #####

    // # # # #

    // ##### #

    //  ##  ##

    //   #####

    QTest::newRow("[50,50] in complex (winding)") << path << QPointF(50, 50) << true;

    path.setFillRule(Qt::OddEvenFill);

    QTest::newRow("[50,50] in complex (windinf)") << path << QPointF(50, 50) << true;

    QTest::newRow("[49,49] in complex") << path << QPointF(49,49) << false;

    QTest::newRow("[100,100] in complex") << path << QPointF(49,49) << false;

    // unclosed triangle

    path = QPainterPath();

    path.moveTo(100, 100);

    path.lineTo(130, 70);

    path.lineTo(150, 110);

    QTest::newRow("[100,100] in triangle") << path << QPointF(100, 100) << true;

    QTest::newRow("[140,100] in triangle") << path << QPointF(140, 100) << true;

    QTest::newRow("[130,80] in triangle") << path << QPointF(130, 80) << true;

    QTest::newRow("[110,80] in triangle") << path << QPointF(110, 80) << false;

    QTest::newRow("[150,100] in triangle") << path << QPointF(150, 100) << false;

    QTest::newRow("[120,110] in triangle") << path << QPointF(120, 110) << false;

    QRectF base_rect(0, 0, 20, 20);

    path = QPainterPath();

    path.addEllipse(base_rect);

    // not strictly precise, but good enougth to verify fair precision.

    QPainterPath inside;

    inside.addEllipse(base_rect.adjusted(5, 5, -5, -5));

    QPolygonF inside_poly = inside.toFillPolygon();

    for (int i=0; i<inside_poly.size(); ++i)

        QTest::newRow("inside_ellipse") << path << inside_poly.at(i) << true;

    QPainterPath outside;

    outside.addEllipse(base_rect.adjusted(-5, -5, 5, 5));

    QPolygonF outside_poly = outside.toFillPolygon();

    for (int i=0; i<outside_poly.size(); ++i)

        QTest::newRow("outside_ellipse") << path << outside_poly.at(i) << false;

    path = QPainterPath();

    base_rect = QRectF(50, 50, 200, 200);

    path.addEllipse(base_rect);

    path.setFillRule(Qt::WindingFill);

    QTest::newRow("topleft outside ellipse") << path << base_rect.topLeft() << false;

    QTest::newRow("topright outside ellipse") << path << base_rect.topRight() << false;

    QTest::newRow("bottomright outside ellipse") << path << base_rect.bottomRight() << false;

    QTest::newRow("bottomleft outside ellipse") << path << base_rect.bottomLeft() << false;

    // Test horizontal curve segment

    path = QPainterPath();

    path.moveTo(100, 100);

    path.cubicTo(120, 100, 180, 100, 200, 100);

    path.lineTo(150, 200);

    path.closeSubpath();

    QTest::newRow("horizontal cubic, out left") << path << QPointF(0, 100) << false;

    QTest::newRow("horizontal cubic, out right") << path << QPointF(300, 100) <<false;

    QTest::newRow("horizontal cubic, in mid") << path << QPointF(150, 100) << true;

}

void tst_QPainterPath::contains_QPointF()

{

    QFETCH(QPainterPath, path);

    QFETCH(QPointF, pt);

    QFETCH(bool, contained);

    QCOMPARE(path.contains(pt), contained);

}

void tst_QPainterPath::contains_QRectF_data()

{

    QTest::addColumn<QPainterPath>("path");

    QTest::addColumn<QRectF>("rect");

    QTest::addColumn<bool>("contained");

    QPainterPath path;

    path.addRect(0, 0, 100, 100);

    QTest::newRow("same rect") << path << QRectF(0.1, 0.1, 99, 99) << true; // ###

    QTest::newRow("outside") << path << QRectF(-1, -1, 100, 100) << false;

    QTest::newRow("covers") << path << QRectF(-1, -1, 102, 102) << false;

    QTest::newRow("left") << path << QRectF(-10, 50, 5, 5) << false;

    QTest::newRow("top") << path << QRectF(50, -10, 5, 5) << false;

    QTest::newRow("right") << path << QRectF(110, 50, 5, 5) << false;

    QTest::newRow("bottom") << path << QRectF(50, 110, 5, 5) << false;

    path.addRect(50, 50, 100, 100);

    QTest::newRow("r1 top") << path << QRectF(0.1, 0.1, 99, 49) << true;

    QTest::newRow("r1 left") << path << QRectF(0.1, 0.1, 49, 99) << true;

    QTest::newRow("r2 right") << path << QRectF(100.01, 50.1, 49, 99) << true;

    QTest::newRow("r2 bottom") << path << QRectF(50.1, 100.1, 99, 49) << true;

    QTest::newRow("inside 2 rects") << path << QRectF(51, 51, 48, 48) << false;

    QTest::newRow("topRight 2 rects") << path << QRectF(100, 0, 49, 49) << false;

    QTest::newRow("bottomLeft 2 rects") << path << QRectF(0, 100, 49, 49) << false;

    path.setFillRule(Qt::WindingFill);

    QTest::newRow("inside 2 rects (winding)") << path << QRectF(51, 51, 48, 48) << true;

    path.addEllipse(0, 0, 150, 150);

    QTest::newRow("topRight 2 rects") << path << QRectF(100, 25, 24, 24) << true;

    QTest::newRow("bottomLeft 2 rects") << path << QRectF(25, 100, 24, 24) << true;

    path.setFillRule(Qt::OddEvenFill);

    QTest::newRow("inside 2 rects") << path << QRectF(50, 50, 49, 49) << false;

}

void tst_QPainterPath::contains_QRectF()

{

    QFETCH(QPainterPath, path);

    QFETCH(QRectF, rect);

    QFETCH(bool, contained);

    QCOMPARE(path.contains(rect), contained);

}

static inline QPainterPath rectPath(qreal x, qreal y, qreal w, qreal h)

{

    QPainterPath path;

    path.addRect(x, y, w, h);

    path.closeSubpath();

    return path;

}

static inline QPainterPath ellipsePath(qreal x, qreal y, qreal w, qreal h)

{

    QPainterPath path;

    path.addEllipse(x, y, w, h);

    path.closeSubpath();

    return path;

}

static inline QPainterPath linePath(qreal x1, qreal y1, qreal x2, qreal y2)

{

    QPainterPath path;

    path.moveTo(x1, y1);

    path.lineTo(x2, y2);

    return path;

}

void tst_QPainterPath::intersects_QRectF_data()

{

    QTest::addColumn<QPainterPath>("path");

    QTest::addColumn<QRectF>("rect");

    QTest::addColumn<bool>("intersects");

    QPainterPath path;

    path.addRect(0, 0, 100, 100);

    QTest::newRow("same rect") << path << QRectF(0.1, 0.1, 99, 99) << true; // ###

    QTest::newRow("outside") << path << QRectF(-1, -1, 100, 100) << true;

    QTest::newRow("covers") << path << QRectF(-1, -1, 102, 102) << true;

    QTest::newRow("left") << path << QRectF(-10, 50, 5, 5) << false;

    QTest::newRow("top") << path << QRectF(50, -10, 5, 5) << false;

    QTest::newRow("right") << path << QRectF(110, 50, 5, 5) << false;

    QTest::newRow("bottom") << path << QRectF(50, 110, 5, 5) << false;

    path.addRect(50, 50, 100, 100);

    QTest::newRow("r1 top") << path << QRectF(0.1, 0.1, 99, 49) << true;

    QTest::newRow("r1 left") << path << QRectF(0.1, 0.1, 49, 99) << true;

    QTest::newRow("r2 right") << path << QRectF(100.01, 50.1, 49, 99) << true;

    QTest::newRow("r2 bottom") << path << QRectF(50.1, 100.1, 99, 49) << true;

    QTest::newRow("inside 2 rects") << path << QRectF(51, 51, 48, 48) << false;

    path.setFillRule(Qt::WindingFill);

    QTest::newRow("inside 2 rects (winding)") << path << QRectF(51, 51, 48, 48) << true;

    path.addEllipse(0, 0, 150, 150);

    QTest::newRow("topRight 2 rects") << path << QRectF(100, 25, 24, 24) << true;

    QTest::newRow("bottomLeft 2 rects") << path << QRectF(25, 100, 24, 24) << true;

    QTest::newRow("horizontal line") << linePath(0, 0, 10, 0) << QRectF(1, -1, 2, 2) << true;

    QTest::newRow("vertical line") << linePath(0, 0, 0, 10) << QRectF(-1, 1, 2, 2) << true;

}

void tst_QPainterPath::intersects_QRectF()

{

    QFETCH(QPainterPath, path);

    QFETCH(QRectF, rect);

    QFETCH(bool, intersects);

    QCOMPARE(path.intersects(rect), intersects);

}

void tst_QPainterPath::testContainsAndIntersects_data()

{

    QTest::addColumn<QPainterPath>("path");

    QTest::addColumn<QPainterPath>("candidate");

    QTest::addColumn<bool>("contained");

    QTest::addColumn<bool>("intersects");

    QTest::newRow("rect vs small ellipse (upper left)") << rectPath(0, 0, 100, 100) << ellipsePath(0, 0, 50, 50) << false << true;

    QTest::newRow("rect vs small ellipse (upper right)") << rectPath(0, 0, 100, 100) << ellipsePath(50, 0, 50, 50) << false << true;

    QTest::newRow("rect vs small ellipse (lower right)") << rectPath(0, 0, 100, 100) << ellipsePath(50, 50, 50, 50) << false << true;

    QTest::newRow("rect vs small ellipse (lower left)") << rectPath(0, 0, 100, 100) << ellipsePath(0, 50, 50, 50) << false << true;

    QTest::newRow("rect vs small ellipse (centered)") << rectPath(0, 0, 100, 100) << ellipsePath(25, 25, 50, 50) << true << true;

    QTest::newRow("rect vs equal ellipse") << rectPath(0, 0, 100, 100) << ellipsePath(0, 0, 100, 100) << false << true;

    QTest::newRow("rect vs big ellipse") << rectPath(0, 0, 100, 100) << ellipsePath(-10, -10, 120, 120) << false << true;

    QPainterPath twoEllipses = ellipsePath(0, 0, 100, 100).united(ellipsePath(200, 0, 100, 100));

    QTest::newRow("rect vs two small ellipses") << rectPath(0, 0, 100, 100) << ellipsePath(25, 25, 50, 50).united(ellipsePath(225, 25, 50, 50)) << false << true;

    QTest::newRow("rect vs two equal ellipses") << rectPath(0, 0, 100, 100) << twoEllipses << false << true;

    QTest::newRow("rect vs self") << rectPath(0, 0, 100, 100) << rectPath(0, 0, 100, 100) << false << true;

    QTest::newRow("ellipse vs self") << ellipsePath(0, 0, 100, 100) << ellipsePath(0, 0, 100, 100) << false << true;

    QPainterPath twoRects = rectPath(0, 0, 100, 100).united(rectPath(200, 0, 100, 100));

    QTest::newRow("two rects vs small ellipse (upper left)") << twoRects << ellipsePath(0, 0, 50, 50) << false << true;

    QTest::newRow("two rects vs small ellipse (upper right)") << twoRects << ellipsePath(50, 0, 50, 50) << false << true;

    QTest::newRow("two rects vs small ellipse (lower right)") << twoRects << ellipsePath(50, 50, 50, 50) << false << true;

    QTest::newRow("two rects vs small ellipse (lower left)") << twoRects << ellipsePath(0, 50, 50, 50) << false << true;

    QTest::newRow("two rects vs small ellipse (centered)") << twoRects << ellipsePath(25, 25, 50, 50) << true << true;

    QTest::newRow("two rects vs equal ellipse") << twoRects << ellipsePath(0, 0, 100, 100) << false << true;

    QTest::newRow("two rects vs big ellipse") << twoRects << ellipsePath(-10, -10, 120, 120) << false << true;

    QTest::newRow("two rects vs two small ellipses") << twoRects << ellipsePath(25, 25, 50, 50).united(ellipsePath(225, 25, 50, 50)) << true << true;

    QTest::newRow("two rects vs two equal ellipses") << twoRects << ellipsePath(0, 0, 100, 100).united(ellipsePath(200, 0, 100, 100)) << false << true;

    QTest::newRow("two rects vs self") << twoRects << twoRects << false << true;

    QTest::newRow("two ellipses vs self") << twoEllipses << twoEllipses << false << true;

    QPainterPath windingRect = rectPath(0, 0, 100, 100);

    windingRect.addRect(25, 25, 100, 50);

    windingRect.setFillRule(Qt::WindingFill);

    QTest::newRow("rect with winding rule vs tall rect") << windingRect << rectPath(40, 20, 20, 60) << true << true;

    QTest::newRow("rect with winding rule vs self") << windingRect << windingRect << false << true;

    QPainterPath thickFrame = rectPath(0, 0, 100, 100).subtracted(rectPath(25, 25, 50, 50));

    QPainterPath thinFrame = rectPath(10, 10, 80, 80).subtracted(rectPath(15, 15, 70, 70));

    QTest::newRow("thin frame in thick frame") << thickFrame << thinFrame << true << true;

    QTest::newRow("rect in thick frame") << thickFrame << rectPath(40, 40, 20, 20) << false << false;

    QTest::newRow("rect in thin frame") << thinFrame << rectPath(40, 40, 20, 20) << false << false;

    QPainterPath ellipses;

    ellipses.addEllipse(0, 0, 10, 10);

    ellipses.addEllipse(4, 4, 2, 2);

    ellipses.setFillRule(Qt::WindingFill);

    // the definition of QPainterPath::intersects() and contains() is fill-area based,

    QTest::newRow("line in rect") << rectPath(0, 0, 100, 100) << linePath(10, 10, 90, 90) << true << true;

    QTest::newRow("horizontal line in rect") << rectPath(0, 0, 100, 100) << linePath(10, 50, 90, 50) << true << true;

    QTest::newRow("vertical line in rect") << rectPath(0, 0, 100, 100) << linePath(50, 10, 50, 90) << true << true;

    QTest::newRow("line through rect") << rectPath(0, 0, 100, 100) << linePath(-10, -10, 110, 110) << false << true;

    QTest::newRow("line through rect 2") << rectPath(0, 0, 100, 100) << linePath(-10, 0, 110, 100) << false << true;

    QTest::newRow("line through rect 3") << rectPath(0, 0, 100, 100) << linePath(5, 10, 110, 100) << false << true;

    QTest::newRow("line through rect 4") << rectPath(0, 0, 100, 100) << linePath(-10, 0, 90, 90) << false << true;

    QTest::newRow("horizontal line through rect") << rectPath(0, 0, 100, 100) << linePath(-10, 50, 110, 50) << false << true;

    QTest::newRow("vertical line through rect") << rectPath(0, 0, 100, 100) << linePath(50, -10, 50, 110) << false << true;

    QTest::newRow("line vs line") << linePath(0, 0, 10, 10) << linePath(10, 0, 0, 10) << false << true;

    QTest::newRow("line in rect with hole") << rectPath(0, 0, 10, 10).subtracted(rectPath(2, 2, 6, 6)) << linePath(4, 4, 6, 6) << false << false;

    QTest::newRow("line in ellipse") << ellipses << linePath(3, 5, 7, 5) << false << true;

    QTest::newRow("line in ellipse 2") << ellipses << linePath(4.5, 5, 5.5, 5) << true << true;

    QTest::newRow("winding ellipse") << ellipses << ellipsePath(4, 4, 2, 2) << false << true;

    QTest::newRow("winding ellipse 2") << ellipses << ellipsePath(4.5, 4.5, 1, 1) << true << true;

    ellipses.setFillRule(Qt::OddEvenFill);

    QTest::newRow("odd even ellipse") << ellipses << ellipsePath(4, 4, 2, 2) << false << true;

    QTest::newRow("odd even ellipse 2") << ellipses << ellipsePath(4.5, 4.5, 1, 1) << false << false;

}

void tst_QPainterPath::testContainsAndIntersects()

{

    QFETCH(QPainterPath, path);

    QFETCH(QPainterPath, candidate);

    QFETCH(bool, contained);

    QFETCH(bool, intersects);

    QCOMPARE(path.intersects(candidate), intersects);

    QCOMPARE(path.contains(candidate), contained);

}

void tst_QPainterPath::testSimplified_data()

{

    QTest::addColumn<QPainterPath>("path");

    QTest::addColumn<int>("elements");

    QTest::newRow("rect") << rectPath(0, 0, 10, 10) << 5;

    QTest::newRow("ellipse") << ellipsePath(0, 0, 10, 10) << 13;

    QPainterPath twoRects = rectPath(0, 0, 10, 10);

    twoRects.addPath(rectPath(5, 0, 10, 10));

    QTest::newRow("two rects (odd)") << twoRects << 10;

    twoRects.setFillRule(Qt::WindingFill);

    QTest::newRow("two rects (winding)") << twoRects << 5;