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

**

** 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 <qrect.h>

#include <limits.h>

#include <qdebug.h>

Q_DECLARE_METATYPE(QRectF)

Q_DECLARE_METATYPE(QPointF)

Q_DECLARE_METATYPE(QRect)

Q_DECLARE_METATYPE(QPoint)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QRect : public QObject

{

    Q_OBJECT

public:

    enum QRectCases {

	InvalidQRect, SmallestQRect, MiddleQRect, LargestQRect, SmallestCoordQRect,

	LargestCoordQRect, RandomQRect, NegativeSizeQRect, NegativePointQRect, NullQRect, EmptyQRect,

	MiddleCoordQRect = MiddleQRect

    };

    enum IntCases {

	MinimumInt, MiddleNegativeInt, ZeroInt, MiddlePositiveInt, MaximumInt, RandomInt

    };

    enum QPointCases {

	NullQPoint, SmallestCoordQPoint, MiddleNegCoordQPoint, MiddlePosCoordQPoint, LargestCoordQPoint, NegativeQPoint,

	NegXQPoint, NegYQPoint, RandomQPoint

    };

    tst_QRect();

    virtual ~tst_QRect();

    static QRect getQRectCase( QRectCases c );

    static int getIntCase( IntCases i );

    static QPoint getQPointCase( QPointCases p );

public slots:

    void init();

    void cleanup();

private slots:

    void isNull_data();

    void isNull();

    void newIsEmpty_data();

    void newIsEmpty();

    void newIsValid_data();

    void newIsValid();

    void normalized_data();

    void normalized();

    void left_data();

    void left();

    void top_data();

    void top();

    void right_data();

    void right();

    void bottom_data();

    void bottom();

    /*

    The test framework has a problem with implementing QCOORD as a type that can be used, if it's

    implemented then the 4 tests above have problems.  Ed has been notified.

    void rLeft_data();

    void rLeft();

    void rTop_data();

    void rTop();

    void rRight_data();

    void rRight();

    void rBottom_data();

    void rBottom();

    */

    void x_data();

    void x();

    void y_data();

    void y();

    void setWidthHeight_data();

    void setWidthHeight();

    void setLeft_data();

    void setLeft();

    void setTop_data();

    void setTop();

    void setRight_data();

    void setRight();

    void setBottom_data();

    void setBottom();

    void setX();

    void setY();

    void newSetTopLeft_data();

    void newSetTopLeft();

    void newSetBottomRight_data();

    void newSetBottomRight();

    void newSetTopRight_data();

    void newSetTopRight();

    void newSetBottomLeft_data();

    void newSetBottomLeft();

    void topLeft_data();

    void topLeft();

    void bottomRight_data();

    void bottomRight();

    void topRight_data();

    void topRight();

    void bottomLeft_data();

    void bottomLeft();

    void center_data();

    void center();

    void getRect_data();

    void getRect();

    void getCoords_data();

    void getCoords();

    void newMoveLeft_data();

    void newMoveLeft();

    void newMoveTop_data();

    void newMoveTop();

    void newMoveRight_data();

    void newMoveRight();

    void newMoveBottom_data();

    void newMoveBottom();

    void newMoveTopLeft_data();

    void newMoveTopLeft();

    void newMoveBottomRight_data();

    void newMoveBottomRight();

    /*void newMoveTopRight_data();

    void newMoveTopRight();

    void newMoveBottomLeft_data();

    void newMoveBottomLeft();*/

    void translate_data();

    void translate();

    void moveTop();

    void moveBottom();

    void moveLeft();

    void moveRight();

    void moveTopLeft();

    void moveTopRight();

    void moveBottomLeft();

    void moveBottomRight();

    void setTopLeft();

    void setTopRight();

    void setBottomLeft();

    void setBottomRight();

    void operator_amp();

    void operator_amp_eq();

    void isEmpty();

    void isValid();

    void testAdjust_data();

    void testAdjust();

    void intersectedRect_data();

    void intersectedRect();

    void intersectedRectF_data();

    void intersectedRectF();

    void unitedRect_data();

    void unitedRect();

    void unitedRectF_data();

    void unitedRectF();

    void intersectsRect_data();

    void intersectsRect();

    void intersectsRectF_data();

    void intersectsRectF();

    void containsRect_data();

    void containsRect();

    void containsRectF_data();

    void containsRectF();

    void containsPoint_data();

    void containsPoint();

    void containsPointF_data();

    void containsPointF();

    void smallRects() const;

};

// Used to work around some floating point precision problems.

#define LARGE 1000000000

static bool isLarge(int x) { return x > LARGE || x < -LARGE; }

tst_QRect::tst_QRect()

{

}

tst_QRect::~tst_QRect()

{

}

void tst_QRect::init()

{

}

void tst_QRect::cleanup()

{

}

QRect tst_QRect::getQRectCase( QRectCases c )

{

    // Should return the best variety of possible QRects, if a

    // case is missing, please add it.

    switch ( c ) {

    case InvalidQRect:

	return QRect();

    case SmallestQRect:

	return QRect( 1, 1, 1, 1 );

    case MiddleQRect:

	return QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );

    case LargestQRect:

	return QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX - 1 ) );

    case SmallestCoordQRect:

	return QRect( QPoint( INT_MIN, INT_MIN ), QSize( 1, 1 ) );

    case LargestCoordQRect:

	return QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );

    case RandomQRect:

	return QRect( 100, 200, 11, 16 );

    case NegativeSizeQRect:

	return QRect( 1, 1, -10, -10 );

    case NegativePointQRect:

	return QRect( -10, -10, 5, 5 );

    case NullQRect:

	return QRect( 5, 5, 0, 0 );

    case EmptyQRect:

	return QRect( QPoint( 2, 2 ), QPoint( 1, 1 ) );

    default:

	return QRect();

    }

}

int tst_QRect::getIntCase( IntCases i )

{

    // Should return the best variety of possible ints, if a

    // case is missing, please add it.

    switch ( i ) {

    case MinimumInt:

	return INT_MIN;

    case MiddleNegativeInt:

	return INT_MIN / 2;

    case ZeroInt:

	return 0;

    case MiddlePositiveInt:

	return INT_MAX / 2;

    case MaximumInt:

	return INT_MAX;

    case RandomInt:

	return 4953;

    default:

	return 0;

    }

}

QPoint tst_QRect::getQPointCase( QPointCases p )

{

    // Should return the best variety of possible QPoints, if a

    // case is missing, please add it.

    switch ( p ) {

    case NullQPoint:

	return QPoint();

    case SmallestCoordQPoint:

	return QPoint(INT_MIN,INT_MIN);

    case MiddleNegCoordQPoint:

	return QPoint(INT_MIN/2,INT_MIN/2);

    case MiddlePosCoordQPoint:

	return QPoint(INT_MAX/2,INT_MAX/2);

    case LargestCoordQPoint:

	return QPoint(INT_MAX,INT_MAX);

    case NegXQPoint:

	return QPoint(-12,7);

    case NegYQPoint:

	return QPoint(12,-7);

    case RandomQPoint:

	return QPoint(12,7);

    default:

	return QPoint();

    }

}

void tst_QRect::isNull_data()

{

    QTest::addColumn<QRect>("r");

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

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << true;

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << false;

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << false;

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << false;

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << false;

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << true; // Due to overflow

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << false;

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << false;

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << false;

    QTest::newRow( "NullQRect" ) << getQRectCase( NullQRect ) << true;

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << true;

}

void tst_QRect::isNull()

{

    QFETCH( QRect, r );

    QFETCH( bool, isNull );

    QRectF rf(r);

    QVERIFY( r.isNull() == isNull );

    QVERIFY( rf.isNull() == isNull );

}

void tst_QRect::newIsEmpty_data()

{

    QTest::addColumn<QRect>("r");

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

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << true;

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << false;

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << false;

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << false;

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << false;

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << false;

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << false;

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << true;

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << false;

    QTest::newRow( "NullQRect" ) << getQRectCase( NullQRect ) << true;

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << true;

}

void tst_QRect::newIsEmpty()

{

    // A new test is written so the old one isn't removed

    QFETCH( QRect, r );

    QFETCH( bool, isEmpty );

    QRectF rf(r);

    QVERIFY( r.isEmpty() == isEmpty );

    if (isLarge(r.x()) || isLarge(r.y()) || isLarge(r.width()) || isLarge(r.height()))

        return;

    QVERIFY( rf.isEmpty() == isEmpty );

}

void tst_QRect::newIsValid_data()

{

    QTest::addColumn<QRect>("r");

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

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << false;

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << true;

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << true;

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << true;

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << true;

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << true;

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << true;

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << false;

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << true;

    QTest::newRow( "NullQRect" ) << getQRectCase( NullQRect ) << false;

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << false;

}

void tst_QRect::newIsValid()

{

    // A new test is written so the old one isn't removed

    QFETCH( QRect, r );

    QFETCH( bool, isValid );

    QRectF rf(r);

    QVERIFY( r.isValid() == isValid );

    if (isLarge(r.x()) || isLarge(r.y()) || isLarge(r.width()) || isLarge(r.height()))

        return;

    QVERIFY( rf.isValid() == isValid );

}

void tst_QRect::normalized_data()

{

    QTest::addColumn<QRect>("r");

    QTest::addColumn<QRect>("nr");

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << getQRectCase( InvalidQRect );

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << QRect( 1, 1, 1, 1 );

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect )

				<< QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect )

				 << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX - 1 ) );

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect )

				       << QRect( QPoint( INT_MIN, INT_MIN ), QSize( 1, 1 ) );

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect )

				      << getQRectCase( LargestCoordQRect ); // overflow

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << QRect( 100, 200, 11, 16 );

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << QRect(QPoint(-10,-10),QPoint(1,1));

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << QRect( -10, -10, 5, 5 );

    QTest::newRow( "NullQRect" ) << getQRectCase( NullQRect ) << getQRectCase( NullQRect );

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << getQRectCase( EmptyQRect );

    QTest::newRow( "Task80908") << QRect(100, 200, 100, 0) << QRect(100, 200, 100, 0);

    // Since "NegativeSizeQRect passes, I expect both of these to pass too.

    // This passes, since height() returns -1 before normalization

    QTest::newRow( "Task85023") << QRect(QPoint(100,201), QPoint(199,199)) << QRect(QPoint(100,199), QPoint(199,201));

    // This, on the other hand height() returns 0 before normalization.

    QTest::newRow( "Task85023.1") << QRect(QPoint(100,200), QPoint(199,199)) << QRect(QPoint(100,199), QPoint(199,200));

    QTest::newRow( "Task188109" ) << QRect(QPoint(263, 113), QPoint(136, 112)) << QRect(QPoint(136, 113), QPoint(263, 112));

}

void tst_QRect::normalized()

{

    QFETCH(QRect, r);

    QFETCH(QRect, nr);

    if (QTest::currentDataTag() == QString("Task85023.1"))

        QEXPECT_FAIL("", "due to broken QRect definition (not possible to change)", Continue);

    QCOMPARE(r.normalized(), nr);

}

void tst_QRect::left_data()

{

    QTest::addColumn<QRect>("r");

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

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << 0;

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << 1;

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << int(INT_MIN) / 2;

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << 0;

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << int(INT_MIN);

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << int(INT_MIN);

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << 100;

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << 1;

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << -10;

    QTest::newRow( "NullQRect" ) << getQRectCase( NullQRect ) << 5;

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << 2;

}

void tst_QRect::left()

{

    QFETCH( QRect, r );

    QFETCH( int, left );

    QRectF rf(r);

    QCOMPARE( r.left(), left );

    QCOMPARE(QRectF(rf).left(), qreal(left));

}

void tst_QRect::top_data()

{

    QTest::addColumn<QRect>("r");

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

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << 0;

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << 1;

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << int(INT_MIN) / 2;

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << 0;

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << int(INT_MIN);

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << int(INT_MIN);

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << 200;

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << 1;

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << -10;

    QTest::newRow( "NullQRect" ) << getQRectCase( NullQRect ) << 5;

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << 2;

}

void tst_QRect::top()

{

    QFETCH( QRect, r );

    QFETCH( int, top );

    QCOMPARE( r.top(), top );

    QCOMPARE(QRectF(r).top(), qreal(top));

}

void tst_QRect::right_data()

{

    // We don't test the NullQRect case as the return value is undefined.

    QTest::addColumn<QRect>("r");

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

    QTest::newRow( "InvalidQRect" ) << getQRectCase( InvalidQRect ) << -1;

    QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << 1;

    QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << int(INT_MAX / 2);

    QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << int(INT_MAX) - 1;

    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << int(INT_MIN);

    QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << int(INT_MAX);

    QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << 110;

    QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << -10;

    QTest::newRow( "NegativePointQRect" ) << getQRectCase( NegativePointQRect ) << -6;

    QTest::newRow( "EmptyQRect" ) << getQRectCase( EmptyQRect ) << 1;

}