1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <qrect.h>

    45 #include <limits.h>

    46 #include <qdebug.h>

    47 

    48 Q_DECLARE_METATYPE(QRectF)

    49 Q_DECLARE_METATYPE(QPointF)

    50 Q_DECLARE_METATYPE(QRect)

    51 Q_DECLARE_METATYPE(QPoint)

    52 

    53 //TESTED_CLASS=

    54 //TESTED_FILES=

    55 

    56 class tst_QRect : public QObject

    57 {

    58     Q_OBJECT

    59 public:

    60     enum QRectCases {

    61 	InvalidQRect, SmallestQRect, MiddleQRect, LargestQRect, SmallestCoordQRect,

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

    63 	MiddleCoordQRect = MiddleQRect

    64     };

    65 

    66     enum IntCases {

    67 	MinimumInt, MiddleNegativeInt, ZeroInt, MiddlePositiveInt, MaximumInt, RandomInt

    68     };

    69 

    70     enum QPointCases {

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

    72 	NegXQPoint, NegYQPoint, RandomQPoint

    73     };

    74 

    75     tst_QRect();

    76     virtual ~tst_QRect();

    77 

    78 

    79     static QRect getQRectCase( QRectCases c );

    80     static int getIntCase( IntCases i );

    81     static QPoint getQPointCase( QPointCases p );

    82 

    83 public slots:

    84     void init();

    85     void cleanup();

    86 private slots:

    87     void isNull_data();

    88     void isNull();

    89     void newIsEmpty_data();

    90     void newIsEmpty();

    91     void newIsValid_data();

    92     void newIsValid();

    93     void normalized_data();

    94     void normalized();

    95     void left_data();

    96     void left();

    97     void top_data();

    98     void top();

    99     void right_data();

   100     void right();

   101     void bottom_data();

   102     void bottom();

   103     /*

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

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

   106     void rLeft_data();

   107     void rLeft();

   108     void rTop_data();

   109     void rTop();

   110     void rRight_data();

   111     void rRight();

   112     void rBottom_data();

   113     void rBottom();

   114     */

   115     void x_data();

   116     void x();

   117     void y_data();

   118     void y();

   119     void setWidthHeight_data();

   120     void setWidthHeight();

   121     void setLeft_data();

   122     void setLeft();

   123     void setTop_data();

   124     void setTop();

   125     void setRight_data();

   126     void setRight();

   127     void setBottom_data();

   128     void setBottom();

   129     void setX();

   130     void setY();

   131     void newSetTopLeft_data();

   132     void newSetTopLeft();

   133     void newSetBottomRight_data();

   134     void newSetBottomRight();

   135     void newSetTopRight_data();

   136     void newSetTopRight();

   137     void newSetBottomLeft_data();

   138     void newSetBottomLeft();

   139     void topLeft_data();

   140     void topLeft();

   141     void bottomRight_data();

   142     void bottomRight();

   143     void topRight_data();

   144     void topRight();

   145     void bottomLeft_data();

   146     void bottomLeft();

   147     void center_data();

   148     void center();

   149     void getRect_data();

   150     void getRect();

   151     void getCoords_data();

   152     void getCoords();

   153     void newMoveLeft_data();

   154     void newMoveLeft();

   155     void newMoveTop_data();

   156     void newMoveTop();

   157     void newMoveRight_data();

   158     void newMoveRight();

   159     void newMoveBottom_data();

   160     void newMoveBottom();

   161     void newMoveTopLeft_data();

   162     void newMoveTopLeft();

   163     void newMoveBottomRight_data();

   164     void newMoveBottomRight();

   165     /*void newMoveTopRight_data();

   166     void newMoveTopRight();

   167     void newMoveBottomLeft_data();

   168     void newMoveBottomLeft();*/

   169 

   170     void translate_data();

   171     void translate();

   172 

   173     void moveTop();

   174     void moveBottom();

   175     void moveLeft();

   176     void moveRight();

   177     void moveTopLeft();

   178     void moveTopRight();

   179     void moveBottomLeft();

   180     void moveBottomRight();

   181     void setTopLeft();

   182     void setTopRight();

   183     void setBottomLeft();

   184     void setBottomRight();

   185     void operator_amp();

   186     void operator_amp_eq();

   187     void isEmpty();

   188     void isValid();

   189 

   190     void testAdjust_data();

   191     void testAdjust();

   192 

   193     void intersectedRect_data();

   194     void intersectedRect();

   195     void intersectedRectF_data();

   196     void intersectedRectF();

   197     void unitedRect_data();

   198     void unitedRect();

   199     void unitedRectF_data();

   200     void unitedRectF();

   201     void intersectsRect_data();

   202     void intersectsRect();

   203     void intersectsRectF_data();

   204     void intersectsRectF();

   205     void containsRect_data();

   206     void containsRect();

   207     void containsRectF_data();

   208     void containsRectF();

   209     void containsPoint_data();

   210     void containsPoint();

   211     void containsPointF_data();

   212     void containsPointF();

   213     void smallRects() const;

   214 };

   215 

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

   217 #define LARGE 1000000000

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

   219 

   220 

   221 tst_QRect::tst_QRect()

   222 {

   223 }

   224 

   225 tst_QRect::~tst_QRect()

   226 {

   227 }

   228 

   229 void tst_QRect::init()

   230 {

   231 }

   232 

   233 void tst_QRect::cleanup()

   234 {

   235 }

   236 

   237 QRect tst_QRect::getQRectCase( QRectCases c )

   238 {

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

   240     // case is missing, please add it.

   241 

   242     switch ( c ) {

   243     case InvalidQRect:

   244 	return QRect();

   245     case SmallestQRect:

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

   247     case MiddleQRect:

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

   249     case LargestQRect:

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

   251     case SmallestCoordQRect:

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

   253     case LargestCoordQRect:

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

   255     case RandomQRect:

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

   257     case NegativeSizeQRect:

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

   259     case NegativePointQRect:

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

   261     case NullQRect:

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

   263     case EmptyQRect:

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

   265     default:

   266 	return QRect();

   267     }

   268 }

   269 

   270 int tst_QRect::getIntCase( IntCases i )

   271 {

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

   273     // case is missing, please add it.

   274 

   275     switch ( i ) {

   276     case MinimumInt:

   277 	return INT_MIN;

   278     case MiddleNegativeInt:

   279 	return INT_MIN / 2;

   280     case ZeroInt:

   281 	return 0;

   282     case MiddlePositiveInt:

   283 	return INT_MAX / 2;

   284     case MaximumInt:

   285 	return INT_MAX;

   286     case RandomInt:

   287 	return 4953;

   288     default:

   289 	return 0;

   290     }

   291 }

   292 

   293 QPoint tst_QRect::getQPointCase( QPointCases p )

   294 {

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

   296     // case is missing, please add it.

   297     switch ( p ) {

   298     case NullQPoint:

   299 	return QPoint();

   300     case SmallestCoordQPoint:

   301 	return QPoint(INT_MIN,INT_MIN);

   302     case MiddleNegCoordQPoint:

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

   304     case MiddlePosCoordQPoint:

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

   306     case LargestCoordQPoint:

   307 	return QPoint(INT_MAX,INT_MAX);

   308     case NegXQPoint:

   309 	return QPoint(-12,7);

   310     case NegYQPoint:

   311 	return QPoint(12,-7);

   312     case RandomQPoint:

   313 	return QPoint(12,7);

   314     default:

   315 	return QPoint();

   316     }

   317 }

   318 

   319 void tst_QRect::isNull_data()

   320 {

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

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

   323 

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

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

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

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

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

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

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

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

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

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

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

   335 }

   336 

   337 void tst_QRect::isNull()

   338 {

   339     QFETCH( QRect, r );

   340     QFETCH( bool, isNull );

   341 

   342     QRectF rf(r);

   343 

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

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

   346 }

   347 

   348 void tst_QRect::newIsEmpty_data()

   349 {

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

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

   352 

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

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

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

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

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

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

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

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

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

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

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

   364 }

   365 

   366 void tst_QRect::newIsEmpty()

   367 {

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

   369     QFETCH( QRect, r );

   370     QFETCH( bool, isEmpty );

   371 

   372     QRectF rf(r);

   373 

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

   375 

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

   377         return;

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

   379 }

   380 

   381 void tst_QRect::newIsValid_data()

   382 {

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

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

   385 

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

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

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

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

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

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

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

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

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

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

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

   397 }

   398 

   399 void tst_QRect::newIsValid()

   400 {

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

   402     QFETCH( QRect, r );

   403     QFETCH( bool, isValid );

   404 

   405     QRectF rf(r);

   406 

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

   408 

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

   410         return;

   411 

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

   413 }

   414 

   415 void tst_QRect::normalized_data()

   416 {

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

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

   419 

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

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

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

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

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

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

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

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

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

   429 				      << getQRectCase( LargestCoordQRect ); // overflow

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

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

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

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

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

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

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

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

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

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

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

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

   442 }

   443 

   444 void tst_QRect::normalized()

   445 {

   446     QFETCH(QRect, r);

   447     QFETCH(QRect, nr);

   448 

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

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

   451     QCOMPARE(r.normalized(), nr);

   452 }

   453 

   454 void tst_QRect::left_data()

   455 {

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

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

   458 

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

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

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

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

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

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

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

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

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

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

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

   470 }

   471 

   472 void tst_QRect::left()

   473 {

   474     QFETCH( QRect, r );

   475     QFETCH( int, left );

   476 

   477     QRectF rf(r);

   478 

   479     QCOMPARE( r.left(), left );

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

   481 }

   482 

   483 void tst_QRect::top_data()

   484 {

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

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

   487 

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

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

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

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

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

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

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

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

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

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

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

   499 }

   500 

   501 void tst_QRect::top()

   502 {

   503     QFETCH( QRect, r );

   504     QFETCH( int, top );

   505 

   506     QCOMPARE( r.top(), top );

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

   508 }

   509 

   510 void tst_QRect::right_data()

   511 {

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

   513 

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

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

   516 

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

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

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

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

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

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

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

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

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

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

   527 }

   528 

   529 void tst_QRect::right()

   530 {

   531     QFETCH( QRect, r );

   532     QFETCH( int, right );

   533 

   534     QCOMPARE( r.right(), right );

   535 

   536     if (isLarge(r.width()))

   537         return;

   538     QCOMPARE(QRectF(r).right(), qreal(right+1));

   539 }

   540 

   541 void tst_QRect::bottom_data()

   542 {

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

   544 

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

   546     QTest::addColumn<int>("bottom");

   547 

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

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

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

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

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

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

   554     QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << 215;

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

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

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

   558 }

   559 

   560 

   561 void tst_QRect::bottom()

   562 {

   563     QFETCH( QRect, r );

   564     QFETCH( int, bottom );

   565 

   566     QCOMPARE( r.bottom(), bottom );

   567 

   568     if (isLarge(r.height()))

   569         return;

   570     QCOMPARE(QRectF(r).bottom(), qreal(bottom + 1));

   571 }

   572 

   573 /*

   574 Q_DECLARE_METATYPE(QCOORD)

   575 

   576 void tst_QRect::rLeft_data()

   577 {

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

   579     QTest::addColumn<QCOORD>("rLeft");

   580 

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

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

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

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

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

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

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

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

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

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

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

   592 }

   593 

   594 void tst_QRect::rLeft()

   595 {

   596     QFETCH( QRect, r );

   597     QFETCH( QCOORD, rLeft );

   598 

   599     QCOMPARE( r.rLeft(), rLeft );

   600 }

   601 

   602 void tst_QRect::rTop_data()

   603 {

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

   605     QTest::addColumn<QCOORD>("rTop");

   606 

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

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

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

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

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

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

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

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

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

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

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

   618 }

   619 

   620 void tst_QRect::rTop()

   621 {

   622     QFETCH( QRect, r );

   623     QFETCH( QCOORD, rTop );

   624 

   625     QCOMPARE( r.rTop(), rTop );

   626 }

   627 

   628 void tst_QRect::rRight_data()

   629 {

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

   631 

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

   633     QTest::addColumn<QCOORD>("rRight");

   634 

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

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

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

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

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

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

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

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

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

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

   645 }

   646 

   647 void tst_QRect::rRight()

   648 {

   649     QFETCH( QRect, r );

   650     QFETCH( QCOORD, rRight );

   651 

   652     QCOMPARE( r.rRight(), rRight );

   653 }

   654 

   655 void tst_QRect::rBottom_data()

   656 {

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

   658 

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

   660     QTest::addColumn<QCOORD>("rBottom");

   661 

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

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

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

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

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

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

   668     QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << 215;

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

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

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

   672 }

   673 

   674 void tst_QRect::rBottom()

   675 {

   676     QFETCH( QRect, r );

   677     QFETCH( QCOORD, rBottom );

   678 

   679     QCOMPARE( r.rBottom(), rBottom );

   680 }

   681 */

   682 

   683 void tst_QRect::x_data()

   684 {

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

   686     QTest::addColumn<int>("x");

   687 

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

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

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

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

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

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

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

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

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

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

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

   699 

   700 }

   701 

   702 void tst_QRect::x()

   703 {

   704     QFETCH( QRect, r );

   705     QFETCH( int, x );

   706 

   707     QCOMPARE( r.x(), x );

   708     QCOMPARE(QRectF(r).x(), qreal(x));

   709 }

   710 

   711 void tst_QRect::y_data()

   712 {

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

   714     QTest::addColumn<int>("y");

   715 

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

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

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

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

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

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

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

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

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

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

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

   727 }

   728 

   729 void tst_QRect::y()

   730 {

   731     QFETCH( QRect, r );

   732     QFETCH( int, y );

   733 

   734     QCOMPARE( r.y(), y );

   735     QCOMPARE(QRectF(r).y(), qreal(y));

   736 }

   737 

   738 void tst_QRect::setWidthHeight_data()

   739 {

   740     QTest::addColumn<int>("w");

   741     QTest::addColumn<int>("h");

   742 

   743     QTest::newRow("10x20") << 10 << 20;

   744     QTest::newRow("-1x-1") << -1 << -1;

   745     QTest::newRow("0x0") << 0 << 0;

   746     QTest::newRow("-10x-100") << -10 << -100;

   747 }

   748 

   749 void tst_QRect::setWidthHeight()

   750 {

   751     QFETCH(int, w);

   752     QFETCH(int, h);

   753 

   754     QRect r;

   755     r.setWidth(w);

   756     r.setHeight(h);

   757 

   758     QCOMPARE(r.width(), w);

   759     QCOMPARE(r.height(), h);

   760 

   761     QRectF rf;

   762     rf.setWidth(w);

   763     rf.setHeight(h);

   764     QCOMPARE(rf.width(), qreal(w));

   765     QCOMPARE(rf.height(), qreal(h));

   766 }

   767 

   768 

   769 void tst_QRect::setLeft_data()

   770 {

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

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

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

   774 

   775     {

   776 	QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )

   777 						<< QRect( QPoint(INT_MIN,0), QPoint(-1,-1) );

   778 	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )

   779 						       << QRect( QPoint(INT_MIN/2,0), QPoint(-1,-1) );

   780 	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )

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

   782 	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )

   783 						       << QRect( QPoint(INT_MAX/2,0), QPoint(-1,-1) );

   784 	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )

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

   786 	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )

   787 					       << QRect( QPoint(4953,0), QPoint(-1,-1) );

   788     }

   789 

   790     {

   791 	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )

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

   793 	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )

   794 						       << QRect( QPoint(INT_MIN/2,1), QPoint(1,1) );

   795 	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )

   796 					     << QRect( QPoint(0,1), QPoint(1,1) );

   797 	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )

   798 						       << QRect( QPoint(INT_MAX/2,1), QPoint(1,1) );

   799 	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )

   800 						<< QRect( QPoint(INT_MAX,1), QPoint(1,1) );

   801 	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )

   802 					       << QRect( QPoint(4953,1), QPoint(1,1) );

   803     }

   804 

   805     {

   806 	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )

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

   808 	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )

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

   810 	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )

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

   812 	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )

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

   814 	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )

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

   816 	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )

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

   818     }

   819 

   820     {

   821 	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )

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

   823 	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )

   824 						       << QRect( QPoint(INT_MIN/2, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );

   825 	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )

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

   827 	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )

   828 						       << QRect( QPoint(INT_MAX/2, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );

   829 	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )

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

   831 	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )

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

   833     }

   834 

   835     {

   836 	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )

   837 						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );

   838 	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )

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

   840 	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )

   841 					     << QRect( QPoint( 0, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );

   842 	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )

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

   844 	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )

   845 						<< QRect( QPoint( INT_MAX, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );

   846 	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )

   847 					       << QRect( QPoint( 4953, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );

   848     }

   849 

   850     {

   851 	QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )

   852 						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );

   853 	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )

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

   855 	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )

   856 					     << QRect( QPoint( 0, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );

   857 	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )

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

   859 	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )

   860 						<< QRect( QPoint( INT_MAX, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );

   861 	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )

   862 					       << QRect( QPoint( 4953, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );

   863     }

   864 

   865     {

   866 	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )

   867 						<< QRect( QPoint( INT_MIN, 200 ), QPoint( 110, 215 ) );

   868 	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )

   869 						       << QRect( QPoint( INT_MIN/2, 200 ), QPoint( 110, 215 ) );

   870 	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )

   871 					     << QRect( QPoint( 0, 200 ), QPoint( 110, 215 ) );

   872 	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )

   873 						       << QRect( QPoint( INT_MAX/2, 200 ), QPoint( 110, 215 ) );

   874 	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )

   875 						<< QRect( QPoint( INT_MAX, 200 ), QPoint( 110, 215 ) );

   876 	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )

   877 					       << QRect( QPoint( 4953, 200 ), QPoint( 110, 215 ) );

   878     }

   879 

   880     {

   881 	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )

   882 						<< QRect( QPoint( INT_MIN, 1 ), QPoint( -10, -10 ) );

   883 	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )

   884 						       << QRect( QPoint( INT_MIN/2, 1 ), QPoint( -10, -10 ) );

   885 	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )

   886 					     << QRect( QPoint( 0, 1 ), QPoint( -10, -10 ) );

   887 	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )

   888 						       << QRect( QPoint( INT_MAX/2, 1 ), QPoint( -10, -10 ) );

   889 	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )

   890 						<< QRect( QPoint( INT_MAX, 1 ), QPoint( -10, -10 ) );

   891 	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )

   892 					       << QRect( QPoint( 4953, 1 ), QPoint( -10, -10 ) );

   893     }

   894 

   895     {

   896 	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )

   897 						<< QRect( QPoint( INT_MIN, -10 ), QPoint( -6, -6 ) );

   898 	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )

   899 						       << QRect( QPoint( INT_MIN/2, -10 ), QPoint( -6, -6 ) );

   900 	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )

   901 					     << QRect( QPoint( 0, -10 ), QPoint( -6, -6 ) );

   902 	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )

   903 						       << QRect( QPoint( INT_MAX/2, -10 ), QPoint( -6, -6 ) );

   904 	QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )

   905 						<< QRect( QPoint( INT_MAX, -10 ), QPoint( -6, -6 ) );

   906 	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )

   907 					       << QRect( QPoint( 4953, -10 ), QPoint( -6, -6 ) );

   908     }

   909 

   910     {

   911 	QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )

   912 						<< QRect( QPoint( INT_MIN, 5 ), QPoint( 4, 4 ) );

   913 	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )

   914 						       << QRect( QPoint( INT_MIN/2, 5 ), QPoint( 4, 4 ) );

   915 	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )

   916 					     << QRect( QPoint( 0, 5 ), QPoint( 4, 4 ) );

   917 	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )

   918 						       << QRect( QPoint( INT_MAX/2, 5), QPoint( 4, 4 ) );

   919 	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )

   920 						<< QRect( QPoint( INT_MAX, 5 ), QPoint( 4, 4 ) );

   921 	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )

   922 					       << QRect( QPoint( 4953, 5 ), QPoint( 4, 4 ) );

   923     }

   924 

   925     {

   926 	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )

   927 						<< QRect( QPoint( INT_MIN, 2 ), QPoint( 1, 1 ) );

   928 	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )

   929 						       << QRect( QPoint( INT_MIN/2, 2 ), QPoint( 1, 1 ) );

   930 	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )

   931 					     << QRect( QPoint( 0, 2 ), QPoint( 1, 1 ) );

   932 	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )

   933 						       << QRect( QPoint( INT_MAX/2, 2 ), QPoint( 1, 1 ) );

   934 	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )

   935 						<< QRect( QPoint( INT_MAX, 2 ), QPoint( 1, 1 ) );

   936 	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )

   937 					       << QRect( QPoint( 4953, 2 ), QPoint( 1, 1 ) );

   938     }

   939 }

   940 

   941 void tst_QRect::setLeft()

   942 {

   943     QFETCH( QRect, r );

   944     QFETCH( int, left );

   945     QFETCH( QRect, nr );

   946 

   947     QRectF rf(r);

   948     QRectF nrf(nr);

   949 

   950     r.setLeft( left );

   951 

   952     QCOMPARE( r, nr );

   953 

   954     rf.setLeft(left);

   955 }

   956 

   957 void tst_QRect::setTop_data()

   958 {

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

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

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

   962 

   963     {

   964 	QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )

   965 						<< QRect( QPoint(0,INT_MIN), QPoint(-1,-1) );

   966 	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )

   967 						       << QRect( QPoint(0,INT_MIN/2), QPoint(-1,-1) );

   968 	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )

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

   970 	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )

   971 						       << QRect( QPoint(0,INT_MAX/2), QPoint(-1,-1) );

   972 	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )

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

   974 	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )

   975 					       << QRect( QPoint(0,4953), QPoint(-1,-1) );

   976     }

   977 

   978     {

   979 	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )

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

   981 	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )

   982 						       << QRect( QPoint(1,INT_MIN/2), QPoint(1,1) );

   983 	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )

   984 					     << QRect( QPoint(1,0), QPoint(1,1) );

   985 	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )

   986 						       << QRect( QPoint(1,INT_MAX/2), QPoint(1,1) );

   987 	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )

   988 						<< QRect( QPoint(1,INT_MAX), QPoint(1,1) );

   989 	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )

   990 					       << QRect( QPoint(1,4953), QPoint(1,1) );

   991     }

   992 

   993     {

   994 	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )

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

   996 	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )

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

   998 	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )

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

  1000 	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )

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

  1002 	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )

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

  1004 	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )

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

  1006     }

  1007 

  1008     {

  1009 	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )

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

  1011 	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )

  1012 						       << QRect( QPoint(0,INT_MIN/2), QPoint( INT_MAX - 1, INT_MAX - 1 ) );

  1013 	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )

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

  1015 	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )

  1016 						       << QRect( QPoint(0,INT_MAX/2), QPoint( INT_MAX - 1, INT_MAX - 1 ) );

  1017 	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )

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

  1019 	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )

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

  1021     }

  1022 

  1023     {

  1024 	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )

  1025 						<< QRect( QPoint(INT_MIN,INT_MIN), QPoint( INT_MIN, INT_MIN ) );

  1026 	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )

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

  1028 	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )

  1029 					     << QRect( QPoint(INT_MIN,0), QPoint( INT_MIN, INT_MIN ) );

  1030 	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )

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

  1032 	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )

  1033 						<< QRect( QPoint(INT_MIN,INT_MAX), QPoint( INT_MIN, INT_MIN ) );

  1034 	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )

  1035 					       << QRect( QPoint(INT_MIN,4953), QPoint( INT_MIN, INT_MIN ) );

  1036     }

  1037 

  1038     {

  1039 	QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )

  1040 						<< QRect( QPoint(INT_MIN,INT_MIN), QPoint( INT_MAX, INT_MAX ) );

  1041 	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )

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

  1043 	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )

  1044 					     << QRect( QPoint(INT_MIN,0), QPoint( INT_MAX, INT_MAX ) );

  1045 	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )

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

  1047 	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )

  1048 						<< QRect( QPoint(INT_MIN,INT_MAX), QPoint( INT_MAX, INT_MAX ) );

  1049 	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )

  1050 					       << QRect( QPoint(INT_MIN,4953), QPoint( INT_MAX, INT_MAX ) );

  1051     }

  1052 

  1053     {

  1054 	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )

  1055 						<< QRect( QPoint(100,INT_MIN), QPoint( 110, 215 ) );

  1056 	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )

  1057 						       << QRect( QPoint(100,INT_MIN/2), QPoint( 110, 215 ) );

  1058 	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )

  1059 					     << QRect( QPoint(100,0), QPoint( 110, 215 ) );

  1060 	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )

  1061 						       << QRect( QPoint(100,INT_MAX/2), QPoint( 110, 215 ) );

  1062 	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )

  1063 						<< QRect( QPoint(100,INT_MAX), QPoint( 110, 215 ) );

  1064 	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )

  1065 					       << QRect( QPoint(100,4953), QPoint( 110, 215 ) );

  1066     }

  1067 

  1068     {

  1069 	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )

  1070 						<< QRect( QPoint(1,INT_MIN), QPoint( -10, -10 ) );

  1071 	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )

  1072 						       << QRect( QPoint(1,INT_MIN/2), QPoint( -10, -10 ) );

  1073 	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )

  1074 					     << QRect( QPoint(1,0), QPoint( -10, -10 ) );

  1075 	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )

  1076 						       << QRect( QPoint(1,INT_MAX/2), QPoint( -10, -10 ) );

  1077 	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )

  1078 						<< QRect( QPoint(1,INT_MAX), QPoint( -10, -10 ) );

  1079 	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )

  1080 					       << QRect( QPoint(1,4953), QPoint( -10, -10 ) );

  1081     }

  1082 

  1083     {

  1084 	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )

  1085 						<< QRect( QPoint(-10,INT_MIN), QPoint( -6, -6 ) );

  1086 	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )

  1087 						       << QRect( QPoint(-10,INT_MIN/2), QPoint( -6, -6 ) );

  1088 	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )

  1089 					     << QRect( QPoint(-10,0), QPoint( -6, -6 ) );

  1090 	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )

  1091 						       << QRect( QPoint(-10,INT_MAX/2), QPoint( -6, -6 ) );

  1092 	QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )

  1093 						<< QRect( QPoint(-10,INT_MAX), QPoint( -6, -6 ) );

  1094 	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )

  1095 					       << QRect( QPoint(-10,4953), QPoint( -6, -6 ) );

  1096     }

  1097 

  1098     {

  1099 	QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )

  1100 						<< QRect( QPoint(5,INT_MIN), QPoint( 4, 4 ) );

  1101 	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )

  1102 						       << QRect( QPoint(5,INT_MIN/2), QPoint( 4, 4 ) );

  1103 	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )

  1104 					     << QRect( QPoint(5,0), QPoint( 4, 4 ) );

  1105 	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )

  1106 						       << QRect( QPoint(5,INT_MAX/2), QPoint( 4, 4 ) );

  1107 	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )

  1108 						<< QRect( QPoint(5,INT_MAX), QPoint( 4, 4 ) );

  1109 	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )

  1110 					       << QRect( QPoint(5,4953), QPoint( 4, 4 ) );

  1111     }

  1112 

  1113     {

  1114 	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )

  1115 						<< QRect( QPoint(2,INT_MIN), QPoint( 1, 1 ) );

  1116 	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )

  1117 						       << QRect( QPoint(2,INT_MIN/2), QPoint( 1, 1 ) );

  1118 	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )

  1119 					     << QRect( QPoint(2,0), QPoint( 1, 1 ) );

  1120 	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )

  1121 						       << QRect( QPoint(2,INT_MAX/2), QPoint( 1, 1 ) );

  1122 	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )

  1123 						<< QRect( QPoint(2,INT_MAX), QPoint( 1, 1 ) );

  1124 	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )

  1125 					       << QRect( QPoint(2,4953), QPoint( 1, 1 ) );

  1126     }

  1127 }

  1128 

  1129 void tst_QRect::setTop()

  1130 {

  1131     QFETCH( QRect, r );

  1132     QFETCH( int, top );

  1133     QFETCH( QRect, nr );

  1134