Cleanup corelib autotests

Remove literal tabs.

Change-Id: I210a0259773cceb20d35ebc80b889e3ebb88b540
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>

13 files changed, 3298 insertions, 3311 deletions

diff --git a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
index 1723c25d59..d0f983fb6c 100644
--- a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
+++ b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
@@ -544,7 +544,7 @@ ostream &operator<<(ostream &out, const StableSortTest& obj)  { out << obj.Major
 QVector<StableSortTest> createStableTestVector()
 {
     QVector<StableSortTest> stableTestVector;
-	for (int i=500; i>=0; --i) {
+    for (int i=500; i>=0; --i) {
         for (int j=0; j<10; ++j) {
             stableTestVector.append(StableSortTest(i, j));
         }
diff --git a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
index 81c6736abd..3ef92eff3c 100644
--- a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
+++ b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
@@ -138,11 +138,11 @@ void tst_QBitArray::size()
     a.fill(1);
     int len = a.size();
     for (int j=0; j<len; j++) {
-	bool b = a[j];
-	if (b)
-	    S+= "1";
-	else
-	    S+= "0";
+        bool b = a[j];
+        if (b)
+            S+= "1";
+        else
+            S+= "0";
     }
     QTEST(S,"res");
 }
diff --git a/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
index 90d24d487a..186c592fb7 100644
--- a/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
@@ -161,11 +161,11 @@ void tst_QByteArray::qCompress_data()
 
     int i;
     for ( i=0; i<size1; i++ )
-	ba1[i] = (char)( i / 1024 );
+        ba1[i] = (char)( i / 1024 );
     QTest::newRow( "01" ) << ba1;
 
     for ( i=0; i<size1; i++ )
-	ba1[i] = (char)( i % 256 );
+        ba1[i] = (char)( i % 256 );
     QTest::newRow( "02" ) << ba1;
 
     ba1.fill( 'A' );
@@ -403,8 +403,7 @@ void tst_QByteArray::split_data()
     QTest::addColumn<QByteArray>("sample");
     QTest::addColumn<int>("size");
 
-    QTest::newRow("1") << QByteArray("-rw-r--r--  1 0  0  519240 Jul  9  2002 bigfile")
-		    << 14;
+    QTest::newRow("1") << QByteArray("-rw-r--r--  1 0  0  519240 Jul  9  2002 bigfile") << 14;
     QTest::newRow("2") << QByteArray("abcde") << 1;
     QTest::newRow("one empty") << QByteArray("") << 1;
     QTest::newRow("two empty") << QByteArray(" ") << 2;
@@ -956,31 +955,31 @@ void tst_QByteArray::lastIndexOf()
     if (!hasNull)
         QCOMPARE( haystack.lastIndexOf(needle.data(), startpos), expected );
     if (needle.size() == 1)
-	QCOMPARE( haystack.lastIndexOf(needle.at(0), startpos), expected );
+        QCOMPARE( haystack.lastIndexOf(needle.at(0), startpos), expected );
 
     if (startpos == -1) {
-	QCOMPARE( haystack.lastIndexOf(needle), expected );
+        QCOMPARE( haystack.lastIndexOf(needle), expected );
         if (!hasNull)
             QCOMPARE( haystack.lastIndexOf(needle.data()), expected );
-	if (needle.size() == 1)
-	    QCOMPARE( haystack.lastIndexOf(needle.at(0)), expected );
+        if (needle.size() == 1)
+            QCOMPARE( haystack.lastIndexOf(needle.at(0)), expected );
     }
 }
 
 void tst_QByteArray::number()
 {
     QCOMPARE(QString(QByteArray::number((quint64) 0)),
-	    QString(QByteArray("0")));
+             QString(QByteArray("0")));
     QCOMPARE(QString(QByteArray::number(Q_UINT64_C(0xFFFFFFFFFFFFFFFF))),
-	    QString(QByteArray("18446744073709551615")));
+             QString(QByteArray("18446744073709551615")));
     QCOMPARE(QString(QByteArray::number(Q_INT64_C(0xFFFFFFFFFFFFFFFF))),
-	    QString(QByteArray("-1")));
+             QString(QByteArray("-1")));
     QCOMPARE(QString(QByteArray::number(qint64(0))),
-	    QString(QByteArray("0")));
+             QString(QByteArray("0")));
     QCOMPARE(QString(QByteArray::number(Q_INT64_C(0x7FFFFFFFFFFFFFFF))),
-	    QString(QByteArray("9223372036854775807")));
+             QString(QByteArray("9223372036854775807")));
     QCOMPARE(QString(QByteArray::number(Q_INT64_C(0x8000000000000000))),
-	    QString(QByteArray("-9223372036854775808")));
+             QString(QByteArray("-9223372036854775808")));
 }
 
 // defined later
diff --git a/tests/auto/corelib/tools/qhash/tst_qhash.cpp b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
index 843216faec..00439c585b 100644
--- a/tests/auto/corelib/tools/qhash/tst_qhash.cpp
+++ b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
@@ -97,20 +97,20 @@ public:
 //     qDebug("creating MyClass count=%d", count);
     }
     MyClass( const QString& c) {
-	count++; str = c;
-// 	qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
+        count++; str = c;
+//        qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
     }
     ~MyClass() {
-	count--;
-// 	qDebug("deleting MyClass '%s' count = %d", str.latin1(), count);
+        count--;
+//        qDebug("deleting MyClass '%s' count = %d", str.latin1(), count);
     }
     MyClass( const MyClass& c ) {
-	count++; str = c.str;
-// 	qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
+        count++; str = c.str;
+//        qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
     }
     MyClass &operator =(const MyClass &o) {
-// 	qDebug("copying MyClass '%s'", o.str.latin1());
-	str = o.str; return *this;
+//        qDebug("copying MyClass '%s'", o.str.latin1());
+        str = o.str; return *this;
     }
 
     QString str;
@@ -125,145 +125,145 @@ typedef QHash<QString, MyClass> MyMap;
 void tst_QHash::count()
 {
     {
-	MyMap map;
-	MyMap map2( map );
-	QCOMPARE( map.count(), 0 );
-	QCOMPARE( map2.count(), 0 );
-	QCOMPARE( MyClass::count, 0 );
-	// detach
-	map2["Hallo"] = MyClass( "Fritz" );
-	QCOMPARE( map.count(), 0 );
+        MyMap map;
+        MyMap map2( map );
+        QCOMPARE( map.count(), 0 );
+        QCOMPARE( map2.count(), 0 );
+        QCOMPARE( MyClass::count, 0 );
+        // detach
+        map2["Hallo"] = MyClass( "Fritz" );
+        QCOMPARE( map.count(), 0 );
         QCOMPARE( map2.count(), 1 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 1 );
+        QCOMPARE( MyClass::count, 1 );
 #endif
     }
     QCOMPARE( MyClass::count, 0 );
 
     {
-	typedef QHash<QString, MyClass> Map;
-	Map map;
-	QCOMPARE( map.count(), 0);
-	map.insert( "Torben", MyClass("Weis") );
-	QCOMPARE( map.count(), 1 );
-	map.insert( "Claudia", MyClass("Sorg") );
-	QCOMPARE( map.count(), 2 );
-	map.insert( "Lars", MyClass("Linzbach") );
-	map.insert( "Matthias", MyClass("Ettrich") );
-	map.insert( "Sue", MyClass("Paludo") );
-	map.insert( "Eirik", MyClass("Eng") );
-	map.insert( "Haavard", MyClass("Nord") );
-	map.insert( "Arnt", MyClass("Gulbrandsen") );
-	map.insert( "Paul", MyClass("Tvete") );
-	QCOMPARE( map.count(), 9 );
-	map.insert( "Paul", MyClass("Tvete 1") );
-	map.insert( "Paul", MyClass("Tvete 2") );
-	map.insert( "Paul", MyClass("Tvete 3") );
-	map.insert( "Paul", MyClass("Tvete 4") );
-	map.insert( "Paul", MyClass("Tvete 5") );
-	map.insert( "Paul", MyClass("Tvete 6") );
-
-	QCOMPARE( map.count(), 9 );
+        typedef QHash<QString, MyClass> Map;
+        Map map;
+        QCOMPARE( map.count(), 0);
+        map.insert( "Torben", MyClass("Weis") );
+        QCOMPARE( map.count(), 1 );
+        map.insert( "Claudia", MyClass("Sorg") );
+        QCOMPARE( map.count(), 2 );
+        map.insert( "Lars", MyClass("Linzbach") );
+        map.insert( "Matthias", MyClass("Ettrich") );
+        map.insert( "Sue", MyClass("Paludo") );
+        map.insert( "Eirik", MyClass("Eng") );
+        map.insert( "Haavard", MyClass("Nord") );
+        map.insert( "Arnt", MyClass("Gulbrandsen") );
+        map.insert( "Paul", MyClass("Tvete") );
+        QCOMPARE( map.count(), 9 );
+        map.insert( "Paul", MyClass("Tvete 1") );
+        map.insert( "Paul", MyClass("Tvete 2") );
+        map.insert( "Paul", MyClass("Tvete 3") );
+        map.insert( "Paul", MyClass("Tvete 4") );
+        map.insert( "Paul", MyClass("Tvete 5") );
+        map.insert( "Paul", MyClass("Tvete 6") );
+
+        QCOMPARE( map.count(), 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	Map map2( map );
-	QVERIFY( map2.count() == 9 );
+        Map map2( map );
+        QVERIFY( map2.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2.insert( "Kay", MyClass("Roemer") );
-	QVERIFY( map2.count() == 10 );
-	QVERIFY( map.count() == 9 );
+        map2.insert( "Kay", MyClass("Roemer") );
+        QVERIFY( map2.count() == 10 );
+        QVERIFY( map.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 19 );
+        QCOMPARE( MyClass::count, 19 );
 #endif
 
-	map2 = map;
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 9 );
+        map2 = map;
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2.insert( "Kay", MyClass("Roemer") );
-	QVERIFY( map2.count() == 10 );
+        map2.insert( "Kay", MyClass("Roemer") );
+        QVERIFY( map2.count() == 10 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 19 );
+        QCOMPARE( MyClass::count, 19 );
 #endif
 
-	map2.clear();
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 0 );
+        map2.clear();
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2 = map;
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 9 );
+        map2 = map;
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2.clear();
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 0 );
+        map2.clear();
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map.remove( "Lars" );
-	QVERIFY( map.count() == 8 );
-	QVERIFY( map2.count() == 0 );
+        map.remove( "Lars" );
+        QVERIFY( map.count() == 8 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 8 );
+        QCOMPARE( MyClass::count, 8 );
 #endif
 
-	map.remove( "Mist" );
-	QVERIFY( map.count() == 8 );
-	QVERIFY( map2.count() == 0 );
+        map.remove( "Mist" );
+        QVERIFY( map.count() == 8 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 8 );
+        QCOMPARE( MyClass::count, 8 );
 #endif
     }
     QVERIFY( MyClass::count == 0 );
 
     {
-	typedef QHash<QString,MyClass> Map;
-	Map map;
-	map["Torben"] = MyClass("Weis");
+         typedef QHash<QString,MyClass> Map;
+         Map map;
+         map["Torben"] = MyClass("Weis");
 #ifndef Q_CC_SUN
-	QVERIFY( MyClass::count == 1 );
+         QVERIFY( MyClass::count == 1 );
 #endif
-	QVERIFY( map.count() == 1 );
+         QVERIFY( map.count() == 1 );
 
-	(void)map["Torben"].str;
-	(void)map["Lars"].str;
+         (void)map["Torben"].str;
+         (void)map["Lars"].str;
 #ifndef Q_CC_SUN
-	QVERIFY( MyClass::count == 2 );
+         QVERIFY( MyClass::count == 2 );
 #endif
-	QVERIFY( map.count() == 2 );
+         QVERIFY( map.count() == 2 );
 
-	const Map& cmap = map;
-	(void)cmap["Depp"].str;
+         const Map& cmap = map;
+         (void)cmap["Depp"].str;
 #ifndef Q_CC_SUN
-	QVERIFY( MyClass::count == 2 );
+         QVERIFY( MyClass::count == 2 );
 #endif
-	QVERIFY( map.count() == 2 );
-	QVERIFY( cmap.count() == 2 );
+         QVERIFY( map.count() == 2 );
+         QVERIFY( cmap.count() == 2 );
     }
     QCOMPARE( MyClass::count, 0 );
     {
-	for ( int i = 0; i < 100; ++i )
-	{
-	    QHash<int, MyClass> map;
-	    for (int j = 0; j < i; ++j)
-		map.insert(j, MyClass(QString::number(j)));
-	}
-	QCOMPARE( MyClass::count, 0 );
+        for ( int i = 0; i < 100; ++i )
+        {
+            QHash<int, MyClass> map;
+            for (int j = 0; j < i; ++j)
+                map.insert(j, MyClass(QString::number(j)));
+        }
+        QCOMPARE( MyClass::count, 0 );
     }
     QCOMPARE( MyClass::count, 0 );
 }
@@ -334,9 +334,9 @@ void tst_QHash::insert1()
             QVERIFY(hash2[2] == world);
 
             hash[1] = hash[1];
-	    QVERIFY(hash[1] == hello);
-	}
-	        {
+            QVERIFY(hash[1] == hello);
+        }
+        {
             Hash hash2 = hash;
             hash2.detach();
             hash2.remove(1);
@@ -464,8 +464,8 @@ void tst_QHash::erase()
     it1 = h1.begin();
     int n = 0;
     while (it1 != h1.end()) {
-	it1 = h1.erase(it1);
-	++n;
+        it1 = h1.erase(it1);
+        ++n;
     }
     QVERIFY(n == 3);
     QHash<int, int> h2;
@@ -562,17 +562,17 @@ void tst_QHash::swap()
 void tst_QHash::clear()
 {
     {
-	MyMap map;
-	map.clear();
-	QVERIFY( map.isEmpty() );
-	map.insert( "key", MyClass( "value" ) );
-	map.clear();
-	QVERIFY( map.isEmpty() );
-	map.insert( "key0", MyClass( "value0" ) );
-	map.insert( "key0", MyClass( "value1" ) );
-	map.insert( "key1", MyClass( "value2" ) );
-	map.clear();
-	QVERIFY( map.isEmpty() );
+        MyMap map;
+        map.clear();
+        QVERIFY( map.isEmpty() );
+        map.insert( "key", MyClass( "value" ) );
+        map.clear();
+        QVERIFY( map.isEmpty() );
+        map.insert( "key0", MyClass( "value0" ) );
+        map.insert( "key0", MyClass( "value1" ) );
+        map.insert( "key1", MyClass( "value2" ) );
+        map.clear();
+        QVERIFY( map.isEmpty() );
     }
     QCOMPARE( MyClass::count, int(0) );
 }
diff --git a/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp b/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp
index 366ee25222..dfcce2683e 100644
--- a/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp
+++ b/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp
@@ -59,7 +59,7 @@
 #include <windows.h> // needed for GetUserDefaultLCID
 #define _control87 _controlfp
 extern "C" DWORD GetThreadLocale(void) {
-	return GetUserDefaultLCID();
+    return GetUserDefaultLCID();
 }
 
 #endif
@@ -162,16 +162,16 @@ void tst_QLocale::ctor()
             QLocale::countryToString(default_country).toLatin1().constData());
 
     {
-	QLocale l;
-	QVERIFY(l.language() == default_lang);
-	QVERIFY(l.country() == default_country);
+        QLocale l;
+        QVERIFY(l.language() == default_lang);
+        QVERIFY(l.country() == default_country);
     }
 
 #define TEST_CTOR(req_lang, req_country, exp_lang, exp_country) \
     { \
-    	QLocale l(QLocale::req_lang, QLocale::req_country); \
-	QCOMPARE(l.language(), exp_lang); \
-	QCOMPARE(l.country(), exp_country); \
+        QLocale l(QLocale::req_lang, QLocale::req_country); \
+        QCOMPARE(l.language(), exp_lang); \
+        QCOMPARE(l.country(), exp_country); \
     }
     {
         QLocale l(QLocale::C, QLocale::AnyCountry);
@@ -195,9 +195,9 @@ void tst_QLocale::ctor()
     QLocale::setDefault(QLocale(QLocale::English, QLocale::France));
 
     {
-	QLocale l;
-	QVERIFY(l.language() == QLocale::English);
-	QVERIFY(l.country() == QLocale::UnitedStates);
+        QLocale l;
+        QVERIFY(l.language() == QLocale::English);
+        QVERIFY(l.country() == QLocale::UnitedStates);
     }
 
     TEST_CTOR(French, France, QLocale::French, QLocale::France)
@@ -211,9 +211,9 @@ void tst_QLocale::ctor()
     QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedKingdom));
 
     {
-	QLocale l;
-	QVERIFY(l.language() == QLocale::English);
-	QVERIFY(l.country() == QLocale::UnitedKingdom);
+        QLocale l;
+        QVERIFY(l.language() == QLocale::English);
+        QVERIFY(l.country() == QLocale::UnitedKingdom);
     }
 
     TEST_CTOR(French, France, QLocale::French, QLocale::France)
@@ -225,9 +225,9 @@ void tst_QLocale::ctor()
     QLocale::setDefault(QLocale(QLocale::Aymara, QLocale::France));
 
     {
-	QLocale l;
-	QVERIFY(l.language() == QLocale::English);
-	QVERIFY(l.country() == QLocale::UnitedKingdom);
+        QLocale l;
+        QVERIFY(l.language() == QLocale::English);
+        QVERIFY(l.country() == QLocale::UnitedKingdom);
     }
 
     TEST_CTOR(Aymara, AnyCountry, QLocale::English, QLocale::UnitedKingdom)
@@ -245,12 +245,11 @@ void tst_QLocale::ctor()
     QLocale::setDefault(QLocale(QLocale::Aymara, QLocale::AnyCountry));
 
     {
-	QLocale l;
-	QVERIFY(l.language() == QLocale::English);
-	QVERIFY(l.country() == QLocale::UnitedKingdom);
+        QLocale l;
+        QVERIFY(l.language() == QLocale::English);
+        QVERIFY(l.country() == QLocale::UnitedKingdom);
     }
 
-
     TEST_CTOR(Aymara, AnyCountry, QLocale::English, QLocale::UnitedKingdom)
     TEST_CTOR(Aymara, France, QLocale::English, QLocale::UnitedKingdom)
 
@@ -280,12 +279,12 @@ void tst_QLocale::ctor()
 
 #define TEST_CTOR(req_lc, exp_lang, exp_country) \
     { \
-	QLocale l(req_lc); \
-	QVERIFY2(l.language() == QLocale::exp_lang \
-		&& l.country() == QLocale::exp_country, \
-		QString("requested: \"" + QString(req_lc) + "\", got: " \
-		+ QLocale::languageToString(l.language()) \
-		+ "/" + QLocale::countryToString(l.country())).toLatin1().constData()); \
+        QLocale l(req_lc); \
+        QVERIFY2(l.language() == QLocale::exp_lang \
+                && l.country() == QLocale::exp_country, \
+                QString("requested: \"" + QString(req_lc) + "\", got: " \
+                + QLocale::languageToString(l.language()) \
+                + "/" + QLocale::countryToString(l.country())).toLatin1().constData()); \
     }
 
     QLocale::setDefault(QLocale(QLocale::C));
@@ -442,8 +441,8 @@ void tst_QLocale::unixLocaleName()
 {
 #define TEST_NAME(req_lang, req_country, exp_name) \
     { \
-    	QLocale l(QLocale::req_lang, QLocale::req_country); \
-	QCOMPARE(l.name(), QString(exp_name)); \
+        QLocale l(QLocale::req_lang, QLocale::req_country); \
+        QCOMPARE(l.name(), QString(exp_name)); \
     }
 
     QLocale::setDefault(QLocale(QLocale::C));
@@ -463,112 +462,112 @@ void tst_QLocale::double_conversion_data()
     QTest::addColumn<bool>("good");
     QTest::addColumn<double>("num");
 
-    QTest::newRow("C 1")         << QString("C") << QString("1")          << true  << 1.0;
-    QTest::newRow("C 1.0")       << QString("C") << QString("1.0")        << true  << 1.0;
-    QTest::newRow("C 1.234")     << QString("C") << QString("1.234")      << true  << 1.234;
-    QTest::newRow("C 1.234e-10") << QString("C") << QString("1.234e-10")  << true  << 1.234e-10;
-    QTest::newRow("C 1.234E10")  << QString("C") << QString("1.234E10")   << true  << 1.234e10;
-    QTest::newRow("C 1e10")      << QString("C") << QString("1e10")       << true  << 1.0e10;
-    QTest::newRow("C  1")        << QString("C") << QString(" 1")         << true  << 1.0;
-    QTest::newRow("C   1")       << QString("C") << QString("  1")        << true  << 1.0;
-    QTest::newRow("C 1 ")        << QString("C") << QString("1 ")         << true  << 1.0;
-    QTest::newRow("C 1  ")       << QString("C") << QString("1  ")        << true  << 1.0;
-
-    QTest::newRow("C 1,")	        << QString("C") << QString("1,")	 << false << 0.0;
-    QTest::newRow("C 1,2")	        << QString("C") << QString("1,2")	 << false << 0.0;
-    QTest::newRow("C 1,23")        << QString("C") << QString("1,23")	 << false << 0.0;
-    QTest::newRow("C 1,234")       << QString("C") << QString("1,234")	 << true  << 1234.0;
-    QTest::newRow("C 1,234,")      << QString("C") << QString("1,234,")	 << false << 0.0;
-    QTest::newRow("C 1,234,5")     << QString("C") << QString("1,234,5")	 << false << 0.0;
-    QTest::newRow("C 1,234,56")    << QString("C") << QString("1,234,56")   << false << 0.0;
-    QTest::newRow("C 1,234,567")   << QString("C") << QString("1,234,567")  << true  << 1234567.0;
-    QTest::newRow("C 1,234,567.")  << QString("C") << QString("1,234,567.") << true  << 1234567.0;
-    QTest::newRow("C 1,234,567.8")	<< QString("C") << QString("1,234,567.8")<< true  << 1234567.8;
-    QTest::newRow("C 1,234567.8")  << QString("C") << QString("1,234567.8") << false << 0.0;
-    QTest::newRow("C 12,34567.8")  << QString("C") << QString("12,34567.8") << false << 0.0;
-    QTest::newRow("C 1234,567.8")  << QString("C") << QString("1234,567.8") << false << 0.0;
-    QTest::newRow("C 1234567.8")   << QString("C") << QString("1234567.8")  << true  << 1234567.8;
-    QTest::newRow("C ,")	    	<< QString("C") << QString(",")	         << false << 0.0;
-    QTest::newRow("C ,123")	<< QString("C") << QString(",123")       << false << 0.0;
-    QTest::newRow("C ,3")	    	<< QString("C") << QString(",3")         << false << 0.0;
-    QTest::newRow("C , 3")	    	<< QString("C") << QString(", 3")        << false << 0.0;
-    QTest::newRow("C ,  3")	<< QString("C") << QString(",  3")       << false << 0.0;
-    QTest::newRow("C ,  3.2")	<< QString("C") << QString(",  3.2")     << false << 0.0;
-    QTest::newRow("C ,  3.2e2")	<< QString("C") << QString(",  3.2e2")   << false << 0.0;
-    QTest::newRow("C ,  e2")	<< QString("C") << QString(",  e2")	 << false << 0.0;
-    QTest::newRow("C 1,,234")	<< QString("C") << QString("1,,234")	 << false << 0.0;
-
-    QTest::newRow("C empty")     << QString("C") << QString("")           << false << 0.0;
-    QTest::newRow("C null")      << QString("C") << QString()         << false << 0.0;
-    QTest::newRow("C .")         << QString("C") << QString(".")          << false << 0.0;
-    QTest::newRow("C 1e")        << QString("C") << QString("1e")         << false << 0.0;
-    QTest::newRow("C 1,0")       << QString("C") << QString("1,0")        << false << 0.0;
-    QTest::newRow("C 1,000")     << QString("C") << QString("1,000")      << true  << 1000.0;
-    QTest::newRow("C 1,000e-6")  << QString("C") << QString("1,000e-6")   << true  << 1000.0e-6;
-    QTest::newRow("C 1e1.0")     << QString("C") << QString("1e1.0")      << false << 0.0;
-    QTest::newRow("C 1e+")       << QString("C") << QString("1e+")        << false << 0.0;
-    QTest::newRow("C 1e-")       << QString("C") << QString("1e-")        << false << 0.0;
-
-    QTest::newRow("C .1")        << QString("C") << QString(".1")         << true  << 0.1;
-    QTest::newRow("C -.1")       << QString("C") << QString("-.1")        << true  << -0.1;
-    QTest::newRow("C 1.")        << QString("C") << QString("1.")         << true  << 1.0;
-    QTest::newRow("C 1.E10")     << QString("C") << QString("1.E10")      << true  << 1.0e10;
-    QTest::newRow("C 1e+10")     << QString("C") << QString("1e+10")      << true  << 1.0e+10;
-
-    QTest::newRow("de_DE 1.")	    << QString("de_DE") << QString("1.")	 << false << 0.0;
-    QTest::newRow("de_DE 1.2")	    << QString("de_DE") << QString("1.2")	 << false << 0.0;
-    QTest::newRow("de_DE 1.23")        << QString("de_DE") << QString("1.23")       << false << 0.0;
-    QTest::newRow("de_DE 1.234")       << QString("de_DE") << QString("1.234")	 << true  << 1234.0;
-    QTest::newRow("de_DE 1.234,")      << QString("de_DE") << QString("1.234.")	 << false << 0.0;
-    QTest::newRow("de_DE 1.234.5")     << QString("de_DE") << QString("1.234.5")	 << false << 0.0;
-    QTest::newRow("de_DE 1.234.56")    << QString("de_DE") << QString("1.234.56")   << false << 0.0;
-    QTest::newRow("de_DE 1.234.567")   << QString("de_DE") << QString("1.234.567")  << true  << 1234567.0;
-    QTest::newRow("de_DE 1.234.567,")  << QString("de_DE") << QString("1.234.567,") << true  << 1234567.0;
-    QTest::newRow("de_DE 1.234.567,8") << QString("de_DE") << QString("1.234.567,8")<< true  << 1234567.8;
-    QTest::newRow("de_DE 1.234567,8")  << QString("de_DE") << QString("1.234567,8") << false << 0.0;
-    QTest::newRow("de_DE 12.34567,8")  << QString("de_DE") << QString("12.34567,8") << false << 0.0;
-    QTest::newRow("de_DE 1234.567,8")  << QString("de_DE") << QString("1234.567,8") << false << 0.0;
-    QTest::newRow("de_DE 1234567,8")   << QString("de_DE") << QString("1234567,8")  << true  << 1234567.8;
-    QTest::newRow("de_DE .123")	    << QString("de_DE") << QString(".123")       << false << 0.0;
-    QTest::newRow("de_DE .3")	    << QString("de_DE") << QString(".3")         << false << 0.0;
-    QTest::newRow("de_DE . 3")	    << QString("de_DE") << QString(". 3")        << false << 0.0;
-    QTest::newRow("de_DE .  3")	    << QString("de_DE") << QString(".  3")       << false << 0.0;
-    QTest::newRow("de_DE .  3,2")	    << QString("de_DE") << QString(".  3,2")     << false << 0.0;
-    QTest::newRow("de_DE .  3,2e2")    << QString("de_DE") << QString(".  3,2e2")   << false << 0.0;
-    QTest::newRow("de_DE .  e2")	    << QString("de_DE") << QString(".  e2")	 << false << 0.0;
-    QTest::newRow("de_DE 1..234")	    << QString("de_DE") << QString("1..234")	 << false << 0.0;
-
-    QTest::newRow("de_DE 1")         << QString("de_DE") << QString("1")          << true  << 1.0;
-    QTest::newRow("de_DE 1.0")       << QString("de_DE") << QString("1.0")        << false << 0.0;
-    QTest::newRow("de_DE 1.234e-10") << QString("de_DE") << QString("1.234e-10")  << true  << 1234.0e-10;
-    QTest::newRow("de_DE 1.234E10")  << QString("de_DE") << QString("1.234E10")   << true  << 1234.0e10;
-    QTest::newRow("de_DE 1e10")      << QString("de_DE") << QString("1e10")       << true  << 1.0e10;
-    QTest::newRow("de_DE .1")        << QString("de_DE") << QString(".1")         << false << 0.0;
-    QTest::newRow("de_DE -.1")       << QString("de_DE") << QString("-.1")        << false << 0.0;
-    QTest::newRow("de_DE 1.E10")     << QString("de_DE") << QString("1.E10")      << false << 0.0;
-    QTest::newRow("de_DE 1e+10")     << QString("de_DE") << QString("1e+10")      << true  << 1.0e+10;
-
-    QTest::newRow("de_DE 1,0")       << QString("de_DE") << QString("1,0")        << true  << 1.0;
-    QTest::newRow("de_DE 1,234")     << QString("de_DE") << QString("1,234")      << true  << 1.234;
-    QTest::newRow("de_DE 1,234e-10") << QString("de_DE") << QString("1,234e-10")  << true  << 1.234e-10;
-    QTest::newRow("de_DE 1,234E10")  << QString("de_DE") << QString("1,234E10")   << true  << 1.234e10;
-    QTest::newRow("de_DE ,1")        << QString("de_DE") << QString(",1")         << true  << 0.1;
-    QTest::newRow("de_DE -,1")       << QString("de_DE") << QString("-,1")        << true  << -0.1;
-    QTest::newRow("de_DE 1,")        << QString("de_DE") << QString("1,")         << true  << 1.0;
-    QTest::newRow("de_DE 1,E10")     << QString("de_DE") << QString("1,E10")      << true  << 1.0e10;
-
-    QTest::newRow("de_DE empty")     << QString("de_DE") << QString("")           << false << 0.0;
-    QTest::newRow("de_DE null")      << QString("de_DE") << QString()         << false << 0.0;
-    QTest::newRow("de_DE .")         << QString("de_DE") << QString(".")          << false << 0.0;
-    QTest::newRow("de_DE 1e")        << QString("de_DE") << QString("1e")         << false << 0.0;
-    QTest::newRow("de_DE 1e1.0")     << QString("de_DE") << QString("1e1.0")      << false << 0.0;
-    QTest::newRow("de_DE 1e+")       << QString("de_DE") << QString("1e+")        << false << 0.0;
-    QTest::newRow("de_DE 1e-")       << QString("de_DE") << QString("1e-")        << false << 0.0;
-
-    QTest::newRow("C 9,876543")      << QString("C") << QString("9,876543")        << false << 0.0;
-    QTest::newRow("C 9,876543.2")    << QString("C") << QString("9,876543.2")      << false << 0.0;
-    QTest::newRow("C 9,876543e-2")   << QString("C") << QString("9,876543e-2")     << false << 0.0;
-    QTest::newRow("C 9,876543.0e-2") << QString("C") << QString("9,876543.0e-2")   << false << 0.0;
+    QTest::newRow("C 1")               << QString("C") << QString("1")               << true  << 1.0;
+    QTest::newRow("C 1.0")             << QString("C") << QString("1.0")             << true  << 1.0;
+    QTest::newRow("C 1.234")           << QString("C") << QString("1.234")           << true  << 1.234;
+    QTest::newRow("C 1.234e-10")       << QString("C") << QString("1.234e-10")       << true  << 1.234e-10;
+    QTest::newRow("C 1.234E10")        << QString("C") << QString("1.234E10")        << true  << 1.234e10;
+    QTest::newRow("C 1e10")            << QString("C") << QString("1e10")            << true  << 1.0e10;
+    QTest::newRow("C  1")              << QString("C") << QString(" 1")              << true  << 1.0;
+    QTest::newRow("C   1")             << QString("C") << QString("  1")             << true  << 1.0;
+    QTest::newRow("C 1 ")              << QString("C") << QString("1 ")              << true  << 1.0;
+    QTest::newRow("C 1  ")             << QString("C") << QString("1  ")             << true  << 1.0;
+
+    QTest::newRow("C 1,")              << QString("C") << QString("1,")              << false << 0.0;
+    QTest::newRow("C 1,2")             << QString("C") << QString("1,2")             << false << 0.0;
+    QTest::newRow("C 1,23")            << QString("C") << QString("1,23")            << false << 0.0;
+    QTest::newRow("C 1,234")           << QString("C") << QString("1,234")           << true  << 1234.0;
+    QTest::newRow("C 1,234,")          << QString("C") << QString("1,234,")          << false << 0.0;
+    QTest::newRow("C 1,234,5")         << QString("C") << QString("1,234,5")         << false << 0.0;
+    QTest::newRow("C 1,234,56")        << QString("C") << QString("1,234,56")        << false << 0.0;
+    QTest::newRow("C 1,234,567")       << QString("C") << QString("1,234,567")       << true  << 1234567.0;
+    QTest::newRow("C 1,234,567.")      << QString("C") << QString("1,234,567.")      << true  << 1234567.0;
+    QTest::newRow("C 1,234,567.8")     << QString("C") << QString("1,234,567.8")     << true  << 1234567.8;
+    QTest::newRow("C 1,234567.8")      << QString("C") << QString("1,234567.8")      << false << 0.0;
+    QTest::newRow("C 12,34567.8")      << QString("C") << QString("12,34567.8")      << false << 0.0;
+    QTest::newRow("C 1234,567.8")      << QString("C") << QString("1234,567.8")      << false << 0.0;
+    QTest::newRow("C 1234567.8")       << QString("C") << QString("1234567.8")       << true  << 1234567.8;
+    QTest::newRow("C ,")               << QString("C") << QString(",")               << false << 0.0;
+    QTest::newRow("C ,123")            << QString("C") << QString(",123")            << false << 0.0;
+    QTest::newRow("C ,3")              << QString("C") << QString(",3")              << false << 0.0;
+    QTest::newRow("C , 3")             << QString("C") << QString(", 3")             << false << 0.0;
+    QTest::newRow("C ,  3")            << QString("C") << QString(",  3")            << false << 0.0;
+    QTest::newRow("C ,  3.2")          << QString("C") << QString(",  3.2")          << false << 0.0;
+    QTest::newRow("C ,  3.2e2")        << QString("C") << QString(",  3.2e2")        << false << 0.0;
+    QTest::newRow("C ,  e2")           << QString("C") << QString(",  e2")           << false << 0.0;
+    QTest::newRow("C 1,,234")          << QString("C") << QString("1,,234")          << false << 0.0;
+
+    QTest::newRow("C empty")           << QString("C") << QString("")                << false << 0.0;
+    QTest::newRow("C null")            << QString("C") << QString()                  << false << 0.0;
+    QTest::newRow("C .")               << QString("C") << QString(".")               << false << 0.0;
+    QTest::newRow("C 1e")              << QString("C") << QString("1e")              << false << 0.0;
+    QTest::newRow("C 1,0")             << QString("C") << QString("1,0")             << false << 0.0;
+    QTest::newRow("C 1,000")           << QString("C") << QString("1,000")           << true  << 1000.0;
+    QTest::newRow("C 1,000e-6")        << QString("C") << QString("1,000e-6")        << true  << 1000.0e-6;
+    QTest::newRow("C 1e1.0")           << QString("C") << QString("1e1.0")           << false << 0.0;
+    QTest::newRow("C 1e+")             << QString("C") << QString("1e+")             << false << 0.0;
+    QTest::newRow("C 1e-")             << QString("C") << QString("1e-")             << false << 0.0;
+
+    QTest::newRow("C .1")              << QString("C") << QString(".1")              << true  << 0.1;
+    QTest::newRow("C -.1")             << QString("C") << QString("-.1")             << true  << -0.1;
+    QTest::newRow("C 1.")              << QString("C") << QString("1.")              << true  << 1.0;
+    QTest::newRow("C 1.E10")           << QString("C") << QString("1.E10")           << true  << 1.0e10;
+    QTest::newRow("C 1e+10")           << QString("C") << QString("1e+10")           << true  << 1.0e+10;
+
+    QTest::newRow("de_DE 1.")          << QString("de_DE") << QString("1.")          << false << 0.0;
+    QTest::newRow("de_DE 1.2")         << QString("de_DE") << QString("1.2")         << false << 0.0;
+    QTest::newRow("de_DE 1.23")        << QString("de_DE") << QString("1.23")        << false << 0.0;
+    QTest::newRow("de_DE 1.234")       << QString("de_DE") << QString("1.234")       << true  << 1234.0;
+    QTest::newRow("de_DE 1.234,")      << QString("de_DE") << QString("1.234.")      << false << 0.0;
+    QTest::newRow("de_DE 1.234.5")     << QString("de_DE") << QString("1.234.5")     << false << 0.0;
+    QTest::newRow("de_DE 1.234.56")    << QString("de_DE") << QString("1.234.56")    << false << 0.0;
+    QTest::newRow("de_DE 1.234.567")   << QString("de_DE") << QString("1.234.567")   << true  << 1234567.0;
+    QTest::newRow("de_DE 1.234.567,")  << QString("de_DE") << QString("1.234.567,")  << true  << 1234567.0;
+    QTest::newRow("de_DE 1.234.567,8") << QString("de_DE") << QString("1.234.567,8") << true  << 1234567.8;
+    QTest::newRow("de_DE 1.234567,8")  << QString("de_DE") << QString("1.234567,8")  << false << 0.0;
+    QTest::newRow("de_DE 12.34567,8")  << QString("de_DE") << QString("12.34567,8")  << false << 0.0;
+    QTest::newRow("de_DE 1234.567,8")  << QString("de_DE") << QString("1234.567,8")  << false << 0.0;
+    QTest::newRow("de_DE 1234567,8")   << QString("de_DE") << QString("1234567,8")   << true  << 1234567.8;
+    QTest::newRow("de_DE .123")        << QString("de_DE") << QString(".123")        << false << 0.0;
+    QTest::newRow("de_DE .3")          << QString("de_DE") << QString(".3")          << false << 0.0;
+    QTest::newRow("de_DE . 3")         << QString("de_DE") << QString(". 3")         << false << 0.0;
+    QTest::newRow("de_DE .  3")        << QString("de_DE") << QString(".  3")        << false << 0.0;
+    QTest::newRow("de_DE .  3,2")      << QString("de_DE") << QString(".  3,2")      << false << 0.0;
+    QTest::newRow("de_DE .  3,2e2")    << QString("de_DE") << QString(".  3,2e2")    << false << 0.0;
+    QTest::newRow("de_DE .  e2")       << QString("de_DE") << QString(".  e2")       << false << 0.0;
+    QTest::newRow("de_DE 1..234")      << QString("de_DE") << QString("1..234")      << false << 0.0;
+
+    QTest::newRow("de_DE 1")           << QString("de_DE") << QString("1")           << true  << 1.0;
+    QTest::newRow("de_DE 1.0")         << QString("de_DE") << QString("1.0")         << false << 0.0;
+    QTest::newRow("de_DE 1.234e-10")   << QString("de_DE") << QString("1.234e-10")   << true  << 1234.0e-10;
+    QTest::newRow("de_DE 1.234E10")    << QString("de_DE") << QString("1.234E10")    << true  << 1234.0e10;
+    QTest::newRow("de_DE 1e10")        << QString("de_DE") << QString("1e10")        << true  << 1.0e10;
+    QTest::newRow("de_DE .1")          << QString("de_DE") << QString(".1")          << false << 0.0;
+    QTest::newRow("de_DE -.1")         << QString("de_DE") << QString("-.1")         << false << 0.0;
+    QTest::newRow("de_DE 1.E10")       << QString("de_DE") << QString("1.E10")       << false << 0.0;
+    QTest::newRow("de_DE 1e+10")       << QString("de_DE") << QString("1e+10")       << true  << 1.0e+10;
+
+    QTest::newRow("de_DE 1,0")         << QString("de_DE") << QString("1,0")         << true  << 1.0;
+    QTest::newRow("de_DE 1,234")       << QString("de_DE") << QString("1,234")       << true  << 1.234;
+    QTest::newRow("de_DE 1,234e-10")   << QString("de_DE") << QString("1,234e-10")   << true  << 1.234e-10;
+    QTest::newRow("de_DE 1,234E10")    << QString("de_DE") << QString("1,234E10")    << true  << 1.234e10;
+    QTest::newRow("de_DE ,1")          << QString("de_DE") << QString(",1")          << true  << 0.1;
+    QTest::newRow("de_DE -,1")         << QString("de_DE") << QString("-,1")         << true  << -0.1;
+    QTest::newRow("de_DE 1,")          << QString("de_DE") << QString("1,")          << true  << 1.0;
+    QTest::newRow("de_DE 1,E10")       << QString("de_DE") << QString("1,E10")       << true  << 1.0e10;
+
+    QTest::newRow("de_DE empty")       << QString("de_DE") << QString("")            << false << 0.0;
+    QTest::newRow("de_DE null")        << QString("de_DE") << QString()              << false << 0.0;
+    QTest::newRow("de_DE .")           << QString("de_DE") << QString(".")           << false << 0.0;
+    QTest::newRow("de_DE 1e")          << QString("de_DE") << QString("1e")          << false << 0.0;
+    QTest::newRow("de_DE 1e1.0")       << QString("de_DE") << QString("1e1.0")       << false << 0.0;
+    QTest::newRow("de_DE 1e+")         << QString("de_DE") << QString("1e+")         << false << 0.0;
+    QTest::newRow("de_DE 1e-")         << QString("de_DE") << QString("1e-")         << false << 0.0;
+
+    QTest::newRow("C 9,876543")        << QString("C") << QString("9,876543")        << false << 0.0;
+    QTest::newRow("C 9,876543.2")      << QString("C") << QString("9,876543.2")      << false << 0.0;
+    QTest::newRow("C 9,876543e-2")     << QString("C") << QString("9,876543e-2")     << false << 0.0;
+    QTest::newRow("C 9,876543.0e-2")   << QString("C") << QString("9,876543.0e-2")   << false << 0.0;
 
     QTest::newRow("de_DE 9.876543")      << QString("de_DE") << QString("9876.543")        << false << 0.0;
     QTest::newRow("de_DE 9.876543,2")    << QString("de_DE") << QString("9.876543,2")      << false << 0.0;
@@ -595,10 +594,10 @@ void tst_QLocale::double_conversion()
     QCOMPARE(ok, good);
 
     if (ok) {
-    	double diff = d - num;
-	if (diff < 0)
-	    diff = -diff;
-	QVERIFY(diff <= MY_DOUBLE_EPSILON);
+        double diff = d - num;
+        if (diff < 0)
+            diff = -diff;
+        QVERIFY(diff <= MY_DOUBLE_EPSILON);
     }
 }
 
@@ -609,50 +608,50 @@ void tst_QLocale::long_long_conversion_data()
     QTest::addColumn<bool>("good");
     QTest::addColumn<qlonglong>("num");
 
-    QTest::newRow("C null")       << QString("C") << QString()	   << false  << (qlonglong) 0;
-    QTest::newRow("C empty")      << QString("C") << QString("")	   << false  << (qlonglong) 0;
-    QTest::newRow("C 1")          << QString("C") << "1"	   << true  << (qlonglong) 1;
-    QTest::newRow("C 1,")         << QString("C") << "1,"     << false << (qlonglong) 0;
-    QTest::newRow("C 1,2")        << QString("C") << "1,2"    << false << (qlonglong) 0;
-    QTest::newRow("C 1,23")       << QString("C") << "1,23"   << false << (qlonglong) 0;
-    QTest::newRow("C 1,234")      << QString("C") << "1,234"  << true  << (qlonglong) 1234;
-    QTest::newRow("C 1234567")    << QString("C") << "1234567"<< true  << (qlonglong) 1234567;
-    QTest::newRow("C 1,234567")    << QString("C") << "1,234567"<< false  << (qlonglong) 0;
-    QTest::newRow("C 12,34567")    << QString("C") << "12,34567"<< false  << (qlonglong) 0;
-    QTest::newRow("C 123,4567")    << QString("C") << "123,4567"<< false  << (qlonglong) 0;
-    QTest::newRow("C 1234,567")    << QString("C") << "1234,567"<< false  << (qlonglong) 0;
-    QTest::newRow("C 12345,67")    << QString("C") << "12345,67"<< false  << (qlonglong) 0;
-    QTest::newRow("C 123456,7")    << QString("C") << "123456,7"<< false  << (qlonglong) 0;
-    QTest::newRow("C 1,234,567")    << QString("C")<< "1,234,567"<< true  << (qlonglong) 1234567;
-
-    QTest::newRow("de_DE 1")      << QString("de_DE") << "1"      << true  << (qlonglong) 1;
-    QTest::newRow("de_DE 1.")     << QString("de_DE") << "1."     << false << (qlonglong) 0;
-    QTest::newRow("de_DE 1.2")    << QString("de_DE") << "1.2"    << false << (qlonglong) 0;
-    QTest::newRow("de_DE 1.23")   << QString("de_DE") << "1.23"   << false << (qlonglong) 0;
-    QTest::newRow("de_DE 1.234")  << QString("de_DE") << "1.234"  << true  << (qlonglong) 1234;
-    QTest::newRow("de_DE 1234567")     << QString("de_DE") << "1234567"<< true  << (qlonglong) 1234567;
-    QTest::newRow("de_DE 1.234567")    << QString("de_DE") << "1.234567"<< false  << (qlonglong) 0;
-    QTest::newRow("de_DE 12.34567")    << QString("de_DE") << "12.34567"<< false  << (qlonglong) 0;
-    QTest::newRow("de_DE 123.4567")    << QString("de_DE") << "123.4567"<< false  << (qlonglong) 0;
-    QTest::newRow("de_DE 1234.567")    << QString("de_DE") << "1234.567"<< false  << (qlonglong) 0;
-    QTest::newRow("de_DE 12345.67")    << QString("de_DE") << "12345.67"<< false  << (qlonglong) 0;
-    QTest::newRow("de_DE 123456.7")    << QString("de_DE") << "123456.7"<< false  << (qlonglong) 0;
-    QTest::newRow("de_DE 1.234.567")   << QString("de_DE")<< "1.234.567"<< true  << (qlonglong) 1234567;
-    QTest::newRow("de_DE 1.234.567 ldspcs")   << QString("de_DE")<< "  1.234.567" << true  << (qlonglong) 1234567;
-    QTest::newRow("de_DE 1.234.567 trspcs")   << QString("de_DE")<< "1.234.567  "<< true  << (qlonglong) 1234567;
-    QTest::newRow("de_DE 1.234.567 ldtrspcs")   << QString("de_DE")<< "  1.234.567  "<< true  << (qlonglong) 1234567;
+    QTest::newRow("C null")                   << QString("C")     << QString()       << false << (qlonglong) 0;
+    QTest::newRow("C empty")                  << QString("C")     << QString("")     << false << (qlonglong) 0;
+    QTest::newRow("C 1")                      << QString("C")     << "1"             << true  << (qlonglong) 1;
+    QTest::newRow("C 1,")                     << QString("C")     << "1,"            << false << (qlonglong) 0;
+    QTest::newRow("C 1,2")                    << QString("C")     << "1,2"           << false << (qlonglong) 0;
+    QTest::newRow("C 1,23")                   << QString("C")     << "1,23"          << false << (qlonglong) 0;
+    QTest::newRow("C 1,234")                  << QString("C")     << "1,234"         << true  << (qlonglong) 1234;
+    QTest::newRow("C 1234567")                << QString("C")     << "1234567"       << true  << (qlonglong) 1234567;
+    QTest::newRow("C 1,234567")               << QString("C")     << "1,234567"      << false << (qlonglong) 0;
+    QTest::newRow("C 12,34567")               << QString("C")     << "12,34567"      << false << (qlonglong) 0;
+    QTest::newRow("C 123,4567")               << QString("C")     << "123,4567"      << false << (qlonglong) 0;
+    QTest::newRow("C 1234,567")               << QString("C")     << "1234,567"      << false << (qlonglong) 0;
+    QTest::newRow("C 12345,67")               << QString("C")     << "12345,67"      << false << (qlonglong) 0;
+    QTest::newRow("C 123456,7")               << QString("C")     << "123456,7"      << false << (qlonglong) 0;
+    QTest::newRow("C 1,234,567")              << QString("C")     << "1,234,567"     << true  << (qlonglong) 1234567;
+
+    QTest::newRow("de_DE 1")                  << QString("de_DE") << "1"             << true  << (qlonglong) 1;
+    QTest::newRow("de_DE 1.")                 << QString("de_DE") << "1."            << false << (qlonglong) 0;
+    QTest::newRow("de_DE 1.2")                << QString("de_DE") << "1.2"           << false << (qlonglong) 0;
+    QTest::newRow("de_DE 1.23")               << QString("de_DE") << "1.23"          << false << (qlonglong) 0;
+    QTest::newRow("de_DE 1.234")              << QString("de_DE") << "1.234"         << true  << (qlonglong) 1234;
+    QTest::newRow("de_DE 1234567")            << QString("de_DE") << "1234567"       << true  << (qlonglong) 1234567;
+    QTest::newRow("de_DE 1.234567")           << QString("de_DE") << "1.234567"      << false << (qlonglong) 0;
+    QTest::newRow("de_DE 12.34567")           << QString("de_DE") << "12.34567"      << false << (qlonglong) 0;
+    QTest::newRow("de_DE 123.4567")           << QString("de_DE") << "123.4567"      << false << (qlonglong) 0;
+    QTest::newRow("de_DE 1234.567")           << QString("de_DE") << "1234.567"      << false << (qlonglong) 0;
+    QTest::newRow("de_DE 12345.67")           << QString("de_DE") << "12345.67"      << false << (qlonglong) 0;
+    QTest::newRow("de_DE 123456.7")           << QString("de_DE") << "123456.7"      << false << (qlonglong) 0;
+    QTest::newRow("de_DE 1.234.567")          << QString("de_DE") << "1.234.567"     << true  << (qlonglong) 1234567;
+    QTest::newRow("de_DE 1.234.567 ldspcs")   << QString("de_DE") << "  1.234.567"   << true  << (qlonglong) 1234567;
+    QTest::newRow("de_DE 1.234.567 trspcs")   << QString("de_DE") << "1.234.567  "   << true  << (qlonglong) 1234567;
+    QTest::newRow("de_DE 1.234.567 ldtrspcs") << QString("de_DE") << "  1.234.567  " << true  << (qlonglong) 1234567;
 
     // test that space is also accepted whenever QLocale::groupSeparator() == 0xa0 (which looks like space).
-    QTest::newRow("nb_NO 123 groupsep")   << QString("nb_NO")<< QString("1")+QChar(0xa0)+QString("234") << true  << (qlonglong) 1234;
-    QTest::newRow("nb_NO 123 groupsep_space")   << QString("nb_NO")<< QString("1")+QChar(0x20)+QString("234") << true  << (qlonglong) 1234;
+    QTest::newRow("nb_NO 123 groupsep")       << QString("nb_NO") << QString("1")+QChar(0xa0)+QString("234") << true  << (qlonglong) 1234;
+    QTest::newRow("nb_NO 123 groupsep_space") << QString("nb_NO") << QString("1")+QChar(0x20)+QString("234") << true  << (qlonglong) 1234;
 
-    QTest::newRow("nb_NO 123 ldspcs")   << QString("nb_NO")<< "  123" << true  << (qlonglong) 123;
-    QTest::newRow("nb_NO 123 trspcs")   << QString("nb_NO")<< "123  "<< true  << (qlonglong) 123;
-    QTest::newRow("nb_NO 123 ldtrspcs")   << QString("nb_NO")<< "  123  "<< true  << (qlonglong) 123;
+    QTest::newRow("nb_NO 123 ldspcs")         << QString("nb_NO") << "  123"         << true  << (qlonglong) 123;
+    QTest::newRow("nb_NO 123 trspcs")         << QString("nb_NO") << "123  "         << true  << (qlonglong) 123;
+    QTest::newRow("nb_NO 123 ldtrspcs")       << QString("nb_NO") << "  123  "       << true  << (qlonglong) 123;
 
-    QTest::newRow("C   1234")       << QString("C") << "  1234"   << true  << (qlonglong) 1234;
-    QTest::newRow("C 1234  ")       << QString("C") << "1234  "   << true  << (qlonglong) 1234;
-    QTest::newRow("C   1234  ")     << QString("C") << "  1234  " << true  << (qlonglong) 1234;
+    QTest::newRow("C   1234")                 << QString("C")     << "  1234"        << true  << (qlonglong) 1234;
+    QTest::newRow("C 1234  ")                 << QString("C")     << "1234  "        << true  << (qlonglong) 1234;
+    QTest::newRow("C   1234  ")               << QString("C")     << "  1234  "      << true  << (qlonglong) 1234;
 }
 
 void tst_QLocale::long_long_conversion()
@@ -670,7 +669,7 @@ void tst_QLocale::long_long_conversion()
     QCOMPARE(ok, good);
 
     if (ok) {
-	QCOMPARE(l, num);
+        QCOMPARE(l, num);
     }
 }
 
@@ -1105,13 +1104,13 @@ void tst_QLocale::macDefaultLocale()
 
     int diff = currentTime.hour() - utcTime.hour();
 
-     // Check if local time and utc time are on opposite sides of the 24-hour wrap-around.
-	if (diff < -12)
-	   diff += 24;
-	if (diff > 12)
-	   diff -= 24;
+    // Check if local time and utc time are on opposite sides of the 24-hour wrap-around.
+    if (diff < -12)
+        diff += 24;
+    if (diff > 12)
+        diff -= 24;
 
-	const QString timeString = locale.toString(QTime(1,2,3), QLocale::LongFormat);
+    const QString timeString = locale.toString(QTime(1,2,3), QLocale::LongFormat);
     QVERIFY(timeString.contains(QString("1:02:03")));
 
     QCOMPARE(locale.toCurrencyString(qulonglong(1234)), QString("$1,234.00"));
diff --git a/tests/auto/corelib/tools/qmap/tst_qmap.cpp b/tests/auto/corelib/tools/qmap/tst_qmap.cpp
index 04d6c6a14a..d63431f921 100644
--- a/tests/auto/corelib/tools/qmap/tst_qmap.cpp
+++ b/tests/auto/corelib/tools/qmap/tst_qmap.cpp
@@ -85,24 +85,24 @@ class MyClass
 {
 public:
     MyClass() {
-       ++count;
-//     qDebug("creating MyClass count=%d", count);
+        ++count;
+//        qDebug("creating MyClass count=%d", count);
     }
     MyClass( const QString& c) {
-	count++; str = c;
-// 	qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
+        count++; str = c;
+//        qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
     }
     ~MyClass() {
-	count--;
-// 	qDebug("deleting MyClass '%s' count = %d", str.latin1(), count);
+        count--;
+//        qDebug("deleting MyClass '%s' count = %d", str.latin1(), count);
     }
     MyClass( const MyClass& c ) {
-	count++; str = c.str;
-// 	qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
+        count++; str = c.str;
+//        qDebug("creating MyClass '%s' count = %d", str.latin1(), count);
     }
     MyClass &operator =(const MyClass &o) {
-// 	qDebug("copying MyClass '%s'", o.str.latin1());
-	str = o.str; return *this;
+//        qDebug("copying MyClass '%s'", o.str.latin1());
+        str = o.str; return *this;
     }
 
     QString str;
@@ -121,145 +121,145 @@ void tst_QMap::init()
 void tst_QMap::count()
 {
     {
-	MyMap map;
-	MyMap map2( map );
-	QCOMPARE( map.count(), 0 );
-	QCOMPARE( map2.count(), 0 );
-	QCOMPARE( MyClass::count, int(0) );
-	// detach
-	map2["Hallo"] = MyClass( "Fritz" );
-	QCOMPARE( map.count(), 0 );
+        MyMap map;
+        MyMap map2( map );
+        QCOMPARE( map.count(), 0 );
+        QCOMPARE( map2.count(), 0 );
+        QCOMPARE( MyClass::count, int(0) );
+        // detach
+        map2["Hallo"] = MyClass( "Fritz" );
+        QCOMPARE( map.count(), 0 );
         QCOMPARE( map2.count(), 1 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 1 );
+        QCOMPARE( MyClass::count, 1 );
 #endif
     }
     QCOMPARE( MyClass::count, int(0) );
 
     {
-	typedef QMap<QString, MyClass> Map;
-	Map map;
-	QCOMPARE( map.count(), 0);
-	map.insert( "Torben", MyClass("Weis") );
-	QCOMPARE( map.count(), 1 );
-	map.insert( "Claudia", MyClass("Sorg") );
-	QCOMPARE( map.count(), 2 );
-	map.insert( "Lars", MyClass("Linzbach") );
-	map.insert( "Matthias", MyClass("Ettrich") );
-	map.insert( "Sue", MyClass("Paludo") );
-	map.insert( "Eirik", MyClass("Eng") );
-	map.insert( "Haavard", MyClass("Nord") );
-	map.insert( "Arnt", MyClass("Gulbrandsen") );
-	map.insert( "Paul", MyClass("Tvete") );
-	QCOMPARE( map.count(), 9 );
-	map.insert( "Paul", MyClass("Tvete 1") );
-	map.insert( "Paul", MyClass("Tvete 2") );
-	map.insert( "Paul", MyClass("Tvete 3") );
-	map.insert( "Paul", MyClass("Tvete 4") );
-	map.insert( "Paul", MyClass("Tvete 5") );
-	map.insert( "Paul", MyClass("Tvete 6") );
-
-	QCOMPARE( map.count(), 9 );
+        typedef QMap<QString, MyClass> Map;
+        Map map;
+        QCOMPARE( map.count(), 0);
+        map.insert( "Torben", MyClass("Weis") );
+        QCOMPARE( map.count(), 1 );
+        map.insert( "Claudia", MyClass("Sorg") );
+        QCOMPARE( map.count(), 2 );
+        map.insert( "Lars", MyClass("Linzbach") );
+        map.insert( "Matthias", MyClass("Ettrich") );
+        map.insert( "Sue", MyClass("Paludo") );
+        map.insert( "Eirik", MyClass("Eng") );
+        map.insert( "Haavard", MyClass("Nord") );
+        map.insert( "Arnt", MyClass("Gulbrandsen") );
+        map.insert( "Paul", MyClass("Tvete") );
+        QCOMPARE( map.count(), 9 );
+        map.insert( "Paul", MyClass("Tvete 1") );
+        map.insert( "Paul", MyClass("Tvete 2") );
+        map.insert( "Paul", MyClass("Tvete 3") );
+        map.insert( "Paul", MyClass("Tvete 4") );
+        map.insert( "Paul", MyClass("Tvete 5") );
+        map.insert( "Paul", MyClass("Tvete 6") );
+
+        QCOMPARE( map.count(), 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	Map map2( map );
-	QVERIFY( map2.count() == 9 );
+        Map map2( map );
+        QVERIFY( map2.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2.insert( "Kay", MyClass("Roemer") );
-	QVERIFY( map2.count() == 10 );
-	QVERIFY( map.count() == 9 );
+        map2.insert( "Kay", MyClass("Roemer") );
+        QVERIFY( map2.count() == 10 );
+        QVERIFY( map.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 19 );
+        QCOMPARE( MyClass::count, 19 );
 #endif
 
-	map2 = map;
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 9 );
+        map2 = map;
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2.insert( "Kay", MyClass("Roemer") );
-	QVERIFY( map2.count() == 10 );
+        map2.insert( "Kay", MyClass("Roemer") );
+        QVERIFY( map2.count() == 10 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 19 );
+        QCOMPARE( MyClass::count, 19 );
 #endif
 
-	map2.clear();
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 0 );
+        map2.clear();
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2 = map;
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 9 );
+        map2 = map;
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 9 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map2.clear();
-	QVERIFY( map.count() == 9 );
-	QVERIFY( map2.count() == 0 );
+        map2.clear();
+        QVERIFY( map.count() == 9 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 9 );
+        QCOMPARE( MyClass::count, 9 );
 #endif
 
-	map.remove( "Lars" );
-	QVERIFY( map.count() == 8 );
-	QVERIFY( map2.count() == 0 );
+        map.remove( "Lars" );
+        QVERIFY( map.count() == 8 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 8 );
+        QCOMPARE( MyClass::count, 8 );
 #endif
 
-	map.remove( "Mist" );
-	QVERIFY( map.count() == 8 );
-	QVERIFY( map2.count() == 0 );
+        map.remove( "Mist" );
+        QVERIFY( map.count() == 8 );
+        QVERIFY( map2.count() == 0 );
 #ifndef Q_CC_SUN
-	QCOMPARE( MyClass::count, 8 );
+        QCOMPARE( MyClass::count, 8 );
 #endif
     }
     QVERIFY( MyClass::count == 0 );
 
     {
-	typedef QMap<QString,MyClass> Map;
-	Map map;
-	map["Torben"] = MyClass("Weis");
+        typedef QMap<QString,MyClass> Map;
+        Map map;
+        map["Torben"] = MyClass("Weis");
 #ifndef Q_CC_SUN
-	QVERIFY( MyClass::count == 1 );
+        QVERIFY( MyClass::count == 1 );
 #endif
-	QVERIFY( map.count() == 1 );
+        QVERIFY( map.count() == 1 );
 
-	(void)map["Torben"].str;
-	(void)map["Lars"].str;
+        (void)map["Torben"].str;
+        (void)map["Lars"].str;
 #ifndef Q_CC_SUN
-	QVERIFY( MyClass::count == 2 );
+        QVERIFY( MyClass::count == 2 );
 #endif
-	QVERIFY( map.count() == 2 );
+        QVERIFY( map.count() == 2 );
 
-	const Map& cmap = map;
-	(void)cmap["Depp"].str;
+        const Map& cmap = map;
+        (void)cmap["Depp"].str;
 #ifndef Q_CC_SUN
-	QVERIFY( MyClass::count == 2 );
+        QVERIFY( MyClass::count == 2 );
 #endif
-	QVERIFY( map.count() == 2 );
-	QVERIFY( cmap.count() == 2 );
+        QVERIFY( map.count() == 2 );
+        QVERIFY( cmap.count() == 2 );
     }
     QCOMPARE( MyClass::count, 0 );
     {
-	for ( int i = 0; i < 100; ++i )
-	{
-	    QMap<int, MyClass> map;
-	    for (int j = 0; j < i; ++j)
-		map.insert(j, MyClass(QString::number(j)));
-	}
-	QCOMPARE( MyClass::count, 0 );
+        for ( int i = 0; i < 100; ++i )
+        {
+            QMap<int, MyClass> map;
+            for (int j = 0; j < i; ++j)
+                map.insert(j, MyClass(QString::number(j)));
+        }
+        QCOMPARE( MyClass::count, 0 );
     }
     QCOMPARE( MyClass::count, 0 );
 }
@@ -267,17 +267,17 @@ void tst_QMap::count()
 void tst_QMap::clear()
 {
     {
-	MyMap map;
-	map.clear();
-	QVERIFY( map.isEmpty() );
-	map.insert( "key", MyClass( "value" ) );
-	map.clear();
-	QVERIFY( map.isEmpty() );
-	map.insert( "key0", MyClass( "value0" ) );
-	map.insert( "key0", MyClass( "value1" ) );
-	map.insert( "key1", MyClass( "value2" ) );
-	map.clear();
-	QVERIFY( map.isEmpty() );
+        MyMap map;
+        map.clear();
+        QVERIFY( map.isEmpty() );
+        map.insert( "key", MyClass( "value" ) );
+        map.clear();
+        QVERIFY( map.isEmpty() );
+        map.insert( "key0", MyClass( "value0" ) );
+        map.insert( "key0", MyClass( "value1" ) );
+        map.insert( "key1", MyClass( "value2" ) );
+        map.clear();
+        QVERIFY( map.isEmpty() );
     }
     QCOMPARE( MyClass::count, int(0) );
 }
@@ -302,8 +302,8 @@ void tst_QMap::beginEnd()
     // test iteration
     QString result;
     for ( StringMap::ConstIterator it = map.constBegin();
-	  it != map.constEnd(); ++it )
-	result += *it;
+          it != map.constEnd(); ++it )
+        result += *it;
     QCOMPARE( result, QString( "ab" ) );
 
     // maps should still be identical
diff --git a/tests/auto/corelib/tools/qrect/tst_qrect.cpp b/tests/auto/corelib/tools/qrect/tst_qrect.cpp
index 56db459c29..4e93251bdc 100644
--- a/tests/auto/corelib/tools/qrect/tst_qrect.cpp
+++ b/tests/auto/corelib/tools/qrect/tst_qrect.cpp
@@ -57,18 +57,18 @@ class tst_QRect : public QObject
     Q_OBJECT
 public:
     enum QRectCases {
-	InvalidQRect, SmallestQRect, MiddleQRect, LargestQRect, SmallestCoordQRect,
-	LargestCoordQRect, RandomQRect, NegativeSizeQRect, NegativePointQRect, NullQRect, EmptyQRect,
-	MiddleCoordQRect = MiddleQRect
+        InvalidQRect, SmallestQRect, MiddleQRect, LargestQRect, SmallestCoordQRect,
+        LargestCoordQRect, RandomQRect, NegativeSizeQRect, NegativePointQRect, NullQRect, EmptyQRect,
+        MiddleCoordQRect = MiddleQRect
     };
 
     enum IntCases {
-	MinimumInt, MiddleNegativeInt, ZeroInt, MiddlePositiveInt, MaximumInt, RandomInt
+                MinimumInt, MiddleNegativeInt, ZeroInt, MiddlePositiveInt, MaximumInt, RandomInt
     };
 
     enum QPointCases {
-	NullQPoint, SmallestCoordQPoint, MiddleNegCoordQPoint, MiddlePosCoordQPoint, LargestCoordQPoint, NegativeQPoint,
-	NegXQPoint, NegYQPoint, RandomQPoint
+        NullQPoint, SmallestCoordQPoint, MiddleNegCoordQPoint, MiddlePosCoordQPoint, LargestCoordQPoint, NegativeQPoint,
+        NegXQPoint, NegYQPoint, RandomQPoint
     };
 
     static QRect getQRectCase( QRectCases c );
@@ -214,29 +214,29 @@ QRect tst_QRect::getQRectCase( QRectCases c )
 
     switch ( c ) {
     case InvalidQRect:
-	return QRect();
+        return QRect();
     case SmallestQRect:
-	return QRect( 1, 1, 1, 1 );
+        return QRect( 1, 1, 1, 1 );
     case MiddleQRect:
-	return QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
+        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 ) );
+        return QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
     case SmallestCoordQRect:
-	return QRect( QPoint( INT_MIN, INT_MIN ), QSize( 1, 1 ) );
+        return QRect( QPoint( INT_MIN, INT_MIN ), QSize( 1, 1 ) );
     case LargestCoordQRect:
-	return QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        return QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
     case RandomQRect:
-	return QRect( 100, 200, 11, 16 );
+        return QRect( 100, 200, 11, 16 );
     case NegativeSizeQRect:
-	return QRect( 1, 1, -10, -10 );
+        return QRect( 1, 1, -10, -10 );
     case NegativePointQRect:
-	return QRect( -10, -10, 5, 5 );
+        return QRect( -10, -10, 5, 5 );
     case NullQRect:
-	return QRect( 5, 5, 0, 0 );
+        return QRect( 5, 5, 0, 0 );
     case EmptyQRect:
-	return QRect( QPoint( 2, 2 ), QPoint( 1, 1 ) );
+        return QRect( QPoint( 2, 2 ), QPoint( 1, 1 ) );
     default:
-	return QRect();
+        return QRect();
     }
 }
 
@@ -247,19 +247,19 @@ int tst_QRect::getIntCase( IntCases i )
 
     switch ( i ) {
     case MinimumInt:
-	return INT_MIN;
+        return INT_MIN;
     case MiddleNegativeInt:
-	return INT_MIN / 2;
+        return INT_MIN / 2;
     case ZeroInt:
-	return 0;
+        return 0;
     case MiddlePositiveInt:
-	return INT_MAX / 2;
+        return INT_MAX / 2;
     case MaximumInt:
-	return INT_MAX;
+        return INT_MAX;
     case RandomInt:
-	return 4953;
+        return 4953;
     default:
-	return 0;
+        return 0;
     }
 }
 
@@ -269,23 +269,23 @@ QPoint tst_QRect::getQPointCase( QPointCases p )
     // case is missing, please add it.
     switch ( p ) {
     case NullQPoint:
-	return QPoint();
+        return QPoint();
     case SmallestCoordQPoint:
-	return QPoint(INT_MIN,INT_MIN);
+        return QPoint(INT_MIN,INT_MIN);
     case MiddleNegCoordQPoint:
-	return QPoint(INT_MIN/2,INT_MIN/2);
+        return QPoint(INT_MIN/2,INT_MIN/2);
     case MiddlePosCoordQPoint:
-	return QPoint(INT_MAX/2,INT_MAX/2);
+        return QPoint(INT_MAX/2,INT_MAX/2);
     case LargestCoordQPoint:
-	return QPoint(INT_MAX,INT_MAX);
+        return QPoint(INT_MAX,INT_MAX);
     case NegXQPoint:
-	return QPoint(-12,7);
+        return QPoint(-12,7);
     case NegYQPoint:
-	return QPoint(12,-7);
+        return QPoint(12,-7);
     case RandomQPoint:
-	return QPoint(12,7);
+        return QPoint(12,7);
     default:
-	return QPoint();
+        return QPoint();
     }
 }
 
@@ -393,13 +393,13 @@ void tst_QRect::normalized_data()
     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 ) );
+                                << 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 ) );
+                                 << 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 ) );
+                                       << QRect( QPoint( INT_MIN, INT_MIN ), QSize( 1, 1 ) );
     QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect )
-				      << getQRectCase( LargestCoordQRect ); // overflow
+                                      << 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 );
@@ -746,168 +746,168 @@ void tst_QRect::setLeft_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953,0), QPoint(-1,-1) );
-    }
-
-    {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN,1), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2,1), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,1), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2,1), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX,1), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953,1), QPoint(1,1) );
-    }
-
-    {
-	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-    }
-
-    {
-	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-    }
-
-    {
-	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-    }
-
-    {
-	QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-    }
-
-    {
-	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, 200 ), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 200 ), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 200 ), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 200 ), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 200 ), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 200 ), QPoint( 110, 215 ) );
-    }
-
-    {
-	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, 1 ), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 1 ), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 1 ), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 1 ), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 1 ), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 1 ), QPoint( -10, -10 ) );
-    }
-
-    {
-	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, -10 ), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, -10 ), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, -10 ), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, -10 ), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, -10 ), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, -10 ), QPoint( -6, -6 ) );
-    }
-
-    {
-	QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, 5 ), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 5 ), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 5 ), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 5), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 5 ), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 5 ), QPoint( 4, 4 ) );
-    }
-
-    {
-	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, 2 ), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 2 ), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 2 ), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 2 ), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 2 ), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 2 ), QPoint( 1, 1 ) );
+        QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953,0), QPoint(-1,-1) );
+    }
+
+    {
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN,1), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2,1), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,1), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2,1), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX,1), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953,1), QPoint(1,1) );
+    }
+
+    {
+        QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953, INT_MIN / 2 ), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+    }
+
+    {
+        QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+    }
+
+    {
+        QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+    }
+
+    {
+        QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+    }
+
+    {
+        QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, 200 ), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 200 ), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 200 ), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 200 ), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 200 ), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 200 ), QPoint( 110, 215 ) );
+    }
+
+    {
+        QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, 1 ), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 1 ), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 1 ), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 1 ), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 1 ), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 1 ), QPoint( -10, -10 ) );
+    }
+
+    {
+        QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, -10 ), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, -10 ), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, -10 ), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, -10 ), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, -10 ), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, -10 ), QPoint( -6, -6 ) );
+    }
+
+    {
+        QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, 5 ), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 5 ), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 5 ), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 5), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 5 ), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 5 ), QPoint( 4, 4 ) );
+    }
+
+    {
+        QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, 2 ), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 2 ), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 2 ), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 2 ), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 2 ), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 2 ), QPoint( 1, 1 ) );
     }
 }
 
@@ -934,168 +934,168 @@ void tst_QRect::setTop_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(0,INT_MIN), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,INT_MIN/2), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,INT_MAX/2), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(0,INT_MAX), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,4953), QPoint(-1,-1) );
-    }
-
-    {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(1,INT_MIN), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,INT_MIN/2), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,0), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,INT_MAX/2), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,INT_MAX), QPoint(1,1) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,4953), QPoint(1,1) );
-    }
-
-    {
-	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN/2,INT_MIN), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2,INT_MIN/2), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN/2,0), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MIN/2,INT_MAX/2), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MIN/2,INT_MAX), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(INT_MIN/2,4953), QPoint( INT_MAX / 2, INT_MAX / 2 ));
-    }
-
-    {
-	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(0,INT_MIN), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,INT_MIN/2), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,INT_MAX/2), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(0,INT_MAX), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,4953), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
-    }
-
-    {
-	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN,INT_MIN), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN,0), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MIN,INT_MAX), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(INT_MIN,4953), QPoint( INT_MIN, INT_MIN ) );
-    }
-
-    {
-	QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN,INT_MIN), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN,0), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MIN,INT_MAX), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(INT_MIN,4953), QPoint( INT_MAX, INT_MAX ) );
-    }
-
-    {
-	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(100,INT_MIN), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(100,INT_MIN/2), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(100,0), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(100,INT_MAX/2), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(100,INT_MAX), QPoint( 110, 215 ) );
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(100,4953), QPoint( 110, 215 ) );
-    }
-
-    {
-	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(1,INT_MIN), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,INT_MIN/2), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,0), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,INT_MAX/2), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,INT_MAX), QPoint( -10, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,4953), QPoint( -10, -10 ) );
-    }
-
-    {
-	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(-10,INT_MIN), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(-10,INT_MIN/2), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(-10,0), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(-10,INT_MAX/2), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(-10,INT_MAX), QPoint( -6, -6 ) );
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(-10,4953), QPoint( -6, -6 ) );
-    }
-
-    {
-	QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(5,INT_MIN), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(5,INT_MIN/2), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(5,0), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(5,INT_MAX/2), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(5,INT_MAX), QPoint( 4, 4 ) );
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(5,4953), QPoint( 4, 4 ) );
-    }
-
-    {
-	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(2,INT_MIN), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(2,INT_MIN/2), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(2,0), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(2,INT_MAX/2), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(2,INT_MAX), QPoint( 1, 1 ) );
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(2,4953), QPoint( 1, 1 ) );
+        QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(0,INT_MIN), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,INT_MIN/2), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,INT_MAX/2), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(0,INT_MAX), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,4953), QPoint(-1,-1) );
+    }
+
+    {
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(1,INT_MIN), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,INT_MIN/2), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,0), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,INT_MAX/2), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,INT_MAX), QPoint(1,1) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,4953), QPoint(1,1) );
+    }
+
+    {
+        QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN/2,INT_MIN), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2,INT_MIN/2), QPoint( INT_MAX / 2, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN/2,0), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MIN/2,INT_MAX/2), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MIN/2,INT_MAX), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(INT_MIN/2,4953), QPoint( INT_MAX / 2, INT_MAX / 2 ));
+    }
+
+    {
+        QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(0,INT_MIN), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,INT_MIN/2), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0, 0), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,INT_MAX/2), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(0,INT_MAX), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,4953), QPoint( INT_MAX - 1, INT_MAX - 1 ) );
+    }
+
+    {
+        QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN,INT_MIN), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN,0), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MIN,INT_MAX), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(INT_MIN,4953), QPoint( INT_MIN, INT_MIN ) );
+    }
+
+    {
+        QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN,INT_MIN), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN,0), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MIN,INT_MAX), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(INT_MIN,4953), QPoint( INT_MAX, INT_MAX ) );
+    }
+
+    {
+        QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(100,INT_MIN), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(100,INT_MIN/2), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(100,0), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(100,INT_MAX/2), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(100,INT_MAX), QPoint( 110, 215 ) );
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(100,4953), QPoint( 110, 215 ) );
+    }
+
+    {
+        QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(1,INT_MIN), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,INT_MIN/2), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,0), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,INT_MAX/2), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,INT_MAX), QPoint( -10, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,4953), QPoint( -10, -10 ) );
+    }
+
+    {
+        QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(-10,INT_MIN), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(-10,INT_MIN/2), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(-10,0), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(-10,INT_MAX/2), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(-10,INT_MAX), QPoint( -6, -6 ) );
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(-10,4953), QPoint( -6, -6 ) );
+    }
+
+    {
+        QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(5,INT_MIN), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(5,INT_MIN/2), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(5,0), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(5,INT_MAX/2), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(5,INT_MAX), QPoint( 4, 4 ) );
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(5,4953), QPoint( 4, 4 ) );
+    }
+
+    {
+        QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(2,INT_MIN), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(2,INT_MIN/2), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(2,0), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(2,INT_MAX/2), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(2,INT_MAX), QPoint( 1, 1 ) );
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(2,4953), QPoint( 1, 1 ) );
     }
 }
 
@@ -1117,168 +1117,168 @@ void tst_QRect::setRight_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(0,0), QPoint(INT_MIN,-1) );
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,0), QPoint(INT_MIN/2,-1) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0), QPoint(0,-1) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,0), QPoint(INT_MAX/2,-1) );
-	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(0,0), QPoint(INT_MAX,-1) );
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,0), QPoint(4953,-1) );
-    }
-
-    {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(1,1), QPoint(INT_MIN,1) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,1), QPoint(INT_MIN/2,1) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,1), QPoint(0,1) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,1), QPoint(INT_MAX/2,1) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,1), QPoint(INT_MAX,1) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,1), QPoint(4953,1) );
-    }
-
-    {
-	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MIN, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MIN/2, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(0, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX/2, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX, INT_MAX / 2 ));
-	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(4953, INT_MAX / 2 ));
-    }
-
-    {
-	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 0, 0 ), QPoint( INT_MIN, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 0, 0 ), QPoint( INT_MIN/2, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 0 ), QPoint( 0, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX/2, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 0, 0 ), QPoint( INT_MAX, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 0, 0 ), QPoint( 4953, INT_MAX - 1 ) );
-    }
-
-    {
-	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN/2, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 0, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX/2, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 4953, INT_MIN ) );
-    }
-
-    {
-	QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN/2, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 0, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX/2, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 4953, INT_MAX ) );
-    }
-
-    {
-	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 100, 200 ), QPoint( INT_MIN, 215 ) );
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 100, 200 ), QPoint( INT_MIN/2, 215 ) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 100, 200 ), QPoint( 0, 215 ) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 100, 200 ), QPoint( INT_MAX/2, 215 ) );
-	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 100, 200 ), QPoint( INT_MAX, 215 ) );
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 100, 200 ), QPoint( 4953, 215 ) );
-    }
-
-    {
-	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 1, 1 ), QPoint( INT_MIN, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 1, 1 ), QPoint( INT_MIN/2, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 1, 1 ), QPoint( 0, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 1, 1 ), QPoint( INT_MAX/2, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 1, 1 ), QPoint( INT_MAX, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 1, 1 ), QPoint( 4953, -10 ) );
-    }
-
-    {
-	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( -10, -10 ), QPoint( INT_MIN, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( -10, -10 ), QPoint( INT_MIN/2, -6 ) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( -10, -10 ), QPoint( 0, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( -10, -10 ), QPoint( INT_MAX/2, -6 ) );
-	QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( -10, -10 ), QPoint( INT_MAX, -6 ) );
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( -10, -10 ), QPoint( 4953, -6 ) );
-    }
-
-    {
-	QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 5, 5 ), QPoint( INT_MIN, 4 ) );
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 5, 5 ), QPoint( INT_MIN/2, 4 ) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 5, 5 ), QPoint( 0, 4 ) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 5, 5 ), QPoint( INT_MAX/2, 4 ) );
-	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 5, 5 ), QPoint( INT_MAX, 4 ) );
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 5, 5 ), QPoint( 4953, 4 ) );
-    }
-
-    {
-	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 2, 2 ), QPoint( INT_MIN, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 2, 2 ), QPoint( INT_MIN/2, 1 ) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 2, 2 ), QPoint( 0, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 2, 2 ), QPoint( INT_MAX/2, 1 ) );
-	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 2, 2 ), QPoint( INT_MAX, 1 ) );
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 2, 2 ), QPoint( 4953, 1 ) );
+        QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(0,0), QPoint(INT_MIN,-1) );
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,0), QPoint(INT_MIN/2,-1) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0), QPoint(0,-1) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,0), QPoint(INT_MAX/2,-1) );
+        QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(0,0), QPoint(INT_MAX,-1) );
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,0), QPoint(4953,-1) );
+    }
+
+    {
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(1,1), QPoint(INT_MIN,1) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,1), QPoint(INT_MIN/2,1) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,1), QPoint(0,1) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,1), QPoint(INT_MAX/2,1) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,1), QPoint(INT_MAX,1) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,1), QPoint(4953,1) );
+    }
+
+    {
+        QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MIN, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MIN/2, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(0, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX/2, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX, INT_MAX / 2 ));
+        QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(4953, INT_MAX / 2 ));
+    }
+
+    {
+        QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 0, 0 ), QPoint( INT_MIN, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 0, 0 ), QPoint( INT_MIN/2, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 0 ), QPoint( 0, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX/2, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 0, 0 ), QPoint( INT_MAX, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 0, 0 ), QPoint( 4953, INT_MAX - 1 ) );
+    }
+
+    {
+        QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN/2, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 0, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX/2, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 4953, INT_MIN ) );
+    }
+
+    {
+        QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN/2, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 0, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX/2, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( 4953, INT_MAX ) );
+    }
+
+    {
+        QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 100, 200 ), QPoint( INT_MIN, 215 ) );
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 100, 200 ), QPoint( INT_MIN/2, 215 ) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 100, 200 ), QPoint( 0, 215 ) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 100, 200 ), QPoint( INT_MAX/2, 215 ) );
+        QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 100, 200 ), QPoint( INT_MAX, 215 ) );
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 100, 200 ), QPoint( 4953, 215 ) );
+    }
+
+    {
+        QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 1, 1 ), QPoint( INT_MIN, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 1, 1 ), QPoint( INT_MIN/2, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 1, 1 ), QPoint( 0, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 1, 1 ), QPoint( INT_MAX/2, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 1, 1 ), QPoint( INT_MAX, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 1, 1 ), QPoint( 4953, -10 ) );
+    }
+
+    {
+        QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( -10, -10 ), QPoint( INT_MIN, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( -10, -10 ), QPoint( INT_MIN/2, -6 ) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( -10, -10 ), QPoint( 0, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( -10, -10 ), QPoint( INT_MAX/2, -6 ) );
+        QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( -10, -10 ), QPoint( INT_MAX, -6 ) );
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( -10, -10 ), QPoint( 4953, -6 ) );
+    }
+
+    {
+        QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 5, 5 ), QPoint( INT_MIN, 4 ) );
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 5, 5 ), QPoint( INT_MIN/2, 4 ) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 5, 5 ), QPoint( 0, 4 ) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 5, 5 ), QPoint( INT_MAX/2, 4 ) );
+        QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 5, 5 ), QPoint( INT_MAX, 4 ) );
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 5, 5 ), QPoint( 4953, 4 ) );
+    }
+
+    {
+        QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 2, 2 ), QPoint( INT_MIN, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 2, 2 ), QPoint( INT_MIN/2, 1 ) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 2, 2 ), QPoint( 0, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 2, 2 ), QPoint( INT_MAX/2, 1 ) );
+        QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 2, 2 ), QPoint( INT_MAX, 1 ) );
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 2, 2 ), QPoint( 4953, 1 ) );
     }
 }
 
@@ -1300,168 +1300,168 @@ void tst_QRect::setBottom_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(0,0), QPoint(-1,INT_MIN) );
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,0), QPoint(-1,INT_MIN/2) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0), QPoint(-1,0) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,0), QPoint(-1,INT_MAX/2) );
-	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(0,0), QPoint(-1,INT_MAX) );
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,0), QPoint(-1,4953) );
-    }
-
-    {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(1,1), QPoint(1,INT_MIN) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,1), QPoint(1,INT_MIN/2) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,1), QPoint(1,0) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,1), QPoint(1,INT_MAX/2) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,1), QPoint(1,INT_MAX) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,1), QPoint(1,4953) );
-    }
-
-    {
-	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MIN ) );
-	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MIN / 2 ) );
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, 0) );
-	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MAX) );
-	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, 4953) );
-    }
-
-    {
-	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MIN) );
-	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MIN/2) );
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, 0 ) );
-	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX/2 ) );
-	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX ) );
-	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, 4953) );
-    }
-
-    {
-	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN/2 ) );
-	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, 0 ) );
-	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MAX/2 ) );
-	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MAX ) );
-	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, 4953 ) );
-    }
-
-    {
-	QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MIN ) );
-	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MIN/2 ) );
-	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, 0 ) );
-	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX/2 ) );
-	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, 4953 ) );
-    }
-
-    {
-	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 100, 200 ), QPoint( 110, INT_MIN ) );
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 100, 200 ), QPoint( 110, INT_MIN/2 ) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 100, 200 ), QPoint( 110, 0) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 100, 200 ), QPoint( 110, INT_MAX/2) );
-	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 100, 200 ), QPoint( 110, INT_MAX ) );
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 100, 200 ), QPoint( 110,4953 ) );
-    }
-
-    {
-	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 1, 1 ), QPoint( -10, INT_MIN ) );
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 1, 1 ), QPoint( -10, INT_MIN/2 ) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 1, 1 ), QPoint( -10, 0 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 1, 1 ), QPoint( -10, INT_MAX/2 ) );
-	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 1, 1 ), QPoint( -10, INT_MAX ) );
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 1, 1 ), QPoint( -10, 4953 ) );
-    }
-
-    {
-	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( -10, -10 ), QPoint( -6, INT_MIN ) );
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( -10, -10 ), QPoint( -6, INT_MIN/2 ) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( -10, -10 ), QPoint( -6, 0 ) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( -10, -10 ), QPoint( -6, INT_MAX/2 ) );
-	QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( -10, -10 ), QPoint( -6, INT_MAX ) );
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( -10, -10 ), QPoint( -6, 4953 ) );
-    }
-
-    {
-	QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 5, 5 ), QPoint( 4, INT_MIN ) );
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MIN/2 ) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 5, 5 ), QPoint( 4, 0 ) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MAX/2 ) );
-	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
-					     << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MAX ) );
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 5, 5 ), QPoint( 4, 4953 ) );
-    }
-
-    {
-	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( 2, 2 ), QPoint( 1, INT_MIN ) );
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( 2, 2 ), QPoint( 1, INT_MIN/2 ) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 2, 2 ), QPoint( 1, 0 ) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( 2, 2 ), QPoint( 1, INT_MAX/2 ) );
-	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( 2, 2 ), QPoint( 1, INT_MAX ) );
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 2, 2 ), QPoint( 1, 4953 ) );
+        QTest::newRow( "InvalidQRect_MinimumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(0,0), QPoint(-1,INT_MIN) );
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,0), QPoint(-1,INT_MIN/2) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0), QPoint(-1,0) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,0), QPoint(-1,INT_MAX/2) );
+        QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(0,0), QPoint(-1,INT_MAX) );
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,0), QPoint(-1,4953) );
+    }
+
+    {
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(1,1), QPoint(1,INT_MIN) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,1), QPoint(1,INT_MIN/2) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,1), QPoint(1,0) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,1), QPoint(1,INT_MAX/2) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,1), QPoint(1,INT_MAX) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,1), QPoint(1,4953) );
+    }
+
+    {
+        QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MIN ) );
+        QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MIN / 2 ) );
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, 0) );
+        QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, INT_MAX) );
+        QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( INT_MIN / 2, INT_MIN / 2 ), QPoint(INT_MAX / 2, 4953) );
+    }
+
+    {
+        QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MIN) );
+        QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MIN/2) );
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, 0 ) );
+        QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX/2 ) );
+        QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, INT_MAX ) );
+        QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 0, 0 ), QPoint( INT_MAX - 1, 4953) );
+    }
+
+    {
+        QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MIN/2 ) );
+        QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, 0 ) );
+        QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MAX/2 ) );
+        QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, INT_MAX ) );
+        QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MIN, 4953 ) );
+    }
+
+    {
+        QTest::newRow( "LargestCoordQRect_MinimumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MIN ) );
+        QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MIN/2 ) );
+        QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, 0 ) );
+        QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX/2 ) );
+        QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( INT_MIN, INT_MIN ), QPoint( INT_MAX, 4953 ) );
+    }
+
+    {
+        QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 100, 200 ), QPoint( 110, INT_MIN ) );
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 100, 200 ), QPoint( 110, INT_MIN/2 ) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 100, 200 ), QPoint( 110, 0) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 100, 200 ), QPoint( 110, INT_MAX/2) );
+        QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 100, 200 ), QPoint( 110, INT_MAX ) );
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 100, 200 ), QPoint( 110,4953 ) );
+    }
+
+    {
+        QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 1, 1 ), QPoint( -10, INT_MIN ) );
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 1, 1 ), QPoint( -10, INT_MIN/2 ) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 1, 1 ), QPoint( -10, 0 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 1, 1 ), QPoint( -10, INT_MAX/2 ) );
+        QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 1, 1 ), QPoint( -10, INT_MAX ) );
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 1, 1 ), QPoint( -10, 4953 ) );
+    }
+
+    {
+        QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( -10, -10 ), QPoint( -6, INT_MIN ) );
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( -10, -10 ), QPoint( -6, INT_MIN/2 ) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( -10, -10 ), QPoint( -6, 0 ) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( -10, -10 ), QPoint( -6, INT_MAX/2 ) );
+        QTest::newRow( "NegativePointQRect_MaximumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( -10, -10 ), QPoint( -6, INT_MAX ) );
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( -10, -10 ), QPoint( -6, 4953 ) );
+    }
+
+    {
+        QTest::newRow( "NullQRect_MinimumInt" ) << getQRectCase( NullQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MIN ) );
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MIN/2 ) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 5, 5 ), QPoint( 4, 0 ) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MAX/2 ) );
+        QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
+                                             << QRect( QPoint( 5, 5 ), QPoint( 4, INT_MAX ) );
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 5, 5 ), QPoint( 4, 4953 ) );
+    }
+
+    {
+        QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( 2, 2 ), QPoint( 1, INT_MIN ) );
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( 2, 2 ), QPoint( 1, INT_MIN/2 ) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 2, 2 ), QPoint( 1, 0 ) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( 2, 2 ), QPoint( 1, INT_MAX/2 ) );
+        QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( 2, 2 ), QPoint( 1, INT_MAX ) );
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 2, 2 ), QPoint( 1, 4953 ) );
     }
 }
 
@@ -1483,212 +1483,212 @@ void tst_QRect::newSetTopLeft_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(-1,-1));
-	QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(-1,-1));
-    }
-
-    {
-	QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(1,1));
-	QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(1,1));
-	QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(1,1));
-	QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(1,1));
-	QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(1,1));
-	QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(1,1));
-	QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(1,1));
-	QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(1,1));
-    }
-
-    {
-	QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(INT_MAX/2,INT_MAX/2));
-    }
-
-    {
-	QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(INT_MAX-1,INT_MAX-1));
-    }
-
-    {
-	QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(INT_MIN,INT_MIN));
-    }
-
-    {
-	QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(INT_MAX,INT_MAX));
-    }
-
-    {
-	QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(110,215));
-	QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(110,215));
-	QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(110,215));
-	QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(110,215));
-	QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(110,215));
-	QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(110,215));
-	QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(110,215));
-	QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(110,215));
-    }
-
-    {
-	QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(-10,-10));
-	QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(-10,-10));
-    }
-
-    {
-	QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(-6,-6));
-	QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(-6,-6));
-    }
-
-    {
-	QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(4,4));
-	QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(4,4));
-	QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(4,4));
-	QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(4,4));
-	QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(4,4));
-	QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(4,4));
-	QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(4,4));
-	QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(4,4));
-    }
-
-    {
-	QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(1,1));
-	QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(1,1));
-	QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(1,1));
-	QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(1,1));
-	QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(1,1));
-	QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(1,1));
-	QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(1,1));
-	QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(1,1));
+        QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(-1,-1));
+        QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(-1,-1));
+    }
+
+    {
+        QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(1,1));
+        QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(1,1));
+        QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(1,1));
+        QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(1,1));
+        QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(1,1));
+        QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(1,1));
+        QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(1,1));
+        QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(1,1));
+    }
+
+    {
+        QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(INT_MAX/2,INT_MAX/2));
+    }
+
+    {
+        QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(INT_MAX-1,INT_MAX-1));
+    }
+
+    {
+        QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(INT_MIN,INT_MIN));
+    }
+
+    {
+        QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(INT_MAX,INT_MAX));
+    }
+
+    {
+        QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(110,215));
+        QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(110,215));
+        QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(110,215));
+        QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(110,215));
+        QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(110,215));
+        QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(110,215));
+        QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(110,215));
+        QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(110,215));
+    }
+
+    {
+        QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(-10,-10));
+        QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(-10,-10));
+    }
+
+    {
+        QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(-6,-6));
+        QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(-6,-6));
+    }
+
+    {
+        QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(4,4));
+        QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(4,4));
+        QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(4,4));
+        QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(4,4));
+        QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(4,4));
+        QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(4,4));
+        QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(4,4));
+        QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(4,4));
+    }
+
+    {
+        QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(1,1));
+        QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(1,1));
+        QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(1,1));
+        QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(1,1));
+        QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(1,1));
+        QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(1,1));
+        QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(1,1));
+        QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(1,1));
     }
 }
 
@@ -1709,212 +1709,212 @@ void tst_QRect::newSetBottomRight_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(0,0));
-	QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(0,0), QPoint(-12,7));
-	QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(0,0), QPoint(12,-7));
-	QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(0,0), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(1,1), QPoint(0,0));
-	QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(1,1), QPoint(-12,7));
-	QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(1,1), QPoint(12,-7));
-	QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(1,1), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(QPoint(INT_MIN/2,INT_MIN/2)), QPoint(0,0));
-	QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-12,7));
-	QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(12,-7));
-	QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(0,0));
-	QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(0,0), QPoint(-12,7));
-	QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(0,0), QPoint(12,-7));
-	QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(0,0), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(0,0));
-	QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-12,7));
-	QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,-7));
-	QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(0,0));
-	QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-12,7));
-	QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,-7));
-	QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(100,200), QPoint(0,0));
-	QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(100,200), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(100,200), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(100,200), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(100,200), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(100,200), QPoint(-12,7));
-	QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(100,200), QPoint(12,-7));
-	QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(100,200), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(1,1), QPoint(0,0));
-	QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(1,1), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(1,1), QPoint(-12,7));
-	QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(1,1), QPoint(12,-7));
-	QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(1,1), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(0,0));
-	QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(-12,7));
-	QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(12,-7));
-	QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(-10,-10), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(5,5), QPoint(0,0));
-	QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(5,5), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(5,5), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(5,5), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(5,5), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(5,5), QPoint(-12,7));
-	QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(5,5), QPoint(12,-7));
-	QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(5,5), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(2,2), QPoint(0,0));
-	QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(2,2), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(2,2), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(2,2), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(2,2), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(2,2), QPoint(-12,7));
-	QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(2,2), QPoint(12,-7));
-	QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(2,2), QPoint(12,7));
+        QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(0,0));
+        QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(0,0), QPoint(-12,7));
+        QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(0,0), QPoint(12,-7));
+        QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(0,0), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(1,1), QPoint(0,0));
+        QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(1,1), QPoint(-12,7));
+        QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(1,1), QPoint(12,-7));
+        QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(1,1), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(QPoint(INT_MIN/2,INT_MIN/2)), QPoint(0,0));
+        QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-12,7));
+        QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(12,-7));
+        QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(0,0));
+        QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(0,0), QPoint(-12,7));
+        QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(0,0), QPoint(12,-7));
+        QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(0,0), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(0,0));
+        QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-12,7));
+        QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,-7));
+        QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(0,0));
+        QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(-12,7));
+        QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,-7));
+        QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(100,200), QPoint(0,0));
+        QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(100,200), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(100,200), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(100,200), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(100,200), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(100,200), QPoint(-12,7));
+        QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(100,200), QPoint(12,-7));
+        QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(100,200), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(1,1), QPoint(0,0));
+        QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(1,1), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(1,1), QPoint(-12,7));
+        QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(1,1), QPoint(12,-7));
+        QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(1,1), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(-10,-10), QPoint(0,0));
+        QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(-10,-10), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(-10,-10), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(-10,-10), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(-10,-10), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-10,-10), QPoint(-12,7));
+        QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(-10,-10), QPoint(12,-7));
+        QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(-10,-10), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(5,5), QPoint(0,0));
+        QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(5,5), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(5,5), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(5,5), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(5,5), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(5,5), QPoint(-12,7));
+        QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(5,5), QPoint(12,-7));
+        QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(5,5), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(2,2), QPoint(0,0));
+        QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(2,2), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(2,2), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(2,2), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(2,2), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(2,2), QPoint(-12,7));
+        QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(2,2), QPoint(12,-7));
+        QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(2,2), QPoint(12,7));
     }
 }
 
@@ -1936,212 +1936,212 @@ void tst_QRect::newSetTopRight_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(0,-1));
-	QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(0,INT_MIN), QPoint(INT_MIN,-1));
-	QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(0,INT_MIN/2), QPoint(INT_MIN/2,-1));
-	QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(0,INT_MAX/2), QPoint(INT_MAX/2,-1));
-	QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(0,INT_MAX), QPoint(INT_MAX,-1));
-	QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(0,7), QPoint(-12,-1));
-	QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(0,-7), QPoint(12,-1));
-	QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(0,7), QPoint(12,-1));
-    }
-
-    {
-	QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(1,0), QPoint(0,1));
-	QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(1,INT_MIN), QPoint(INT_MIN,1));
-	QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(1,INT_MIN/2), QPoint(INT_MIN/2,1));
-	QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(1,INT_MAX/2), QPoint(INT_MAX/2,1));
-	QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(1,INT_MAX), QPoint(INT_MAX,1));
-	QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(1,7), QPoint(-12,1));
-	QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(1,-7), QPoint(12,1));
-	QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(1,7), QPoint(12,1));
-    }
-
-    {
-	QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(INT_MIN/2,0),QPoint(0,INT_MAX/2));
-	QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN),QPoint(INT_MIN,INT_MAX/2));
-	QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2),QPoint(INT_MIN/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MAX/2),QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MAX),QPoint(INT_MAX,INT_MAX/2));
-	QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(INT_MIN/2,7),QPoint(-12,INT_MAX/2));
-	QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(INT_MIN/2,-7),QPoint(12,INT_MAX/2));
-	QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN/2,7),QPoint(12,INT_MAX/2));
-    }
-
-    {
-	QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0),QPoint(0,INT_MAX-1));
-	QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(0,INT_MIN),QPoint(INT_MIN,INT_MAX-1));
-	QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(0,INT_MIN/2),QPoint(INT_MIN/2,INT_MAX-1));
-	QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(0,INT_MAX/2),QPoint(INT_MAX/2,INT_MAX-1));
-	QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(0,INT_MAX),QPoint(INT_MAX,INT_MAX-1));
-	QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(0,7),QPoint(-12,INT_MAX-1));
-	QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(0,-7),QPoint(12,INT_MAX-1));
-	QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(0,7),QPoint(12,INT_MAX-1));
-    }
-
-    {
-	QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(INT_MIN,0),QPoint(0,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN/2),QPoint(INT_MIN/2,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MAX/2),QPoint(INT_MAX/2,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MAX),QPoint(INT_MAX,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(INT_MIN,7),QPoint(-12,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(INT_MIN,-7),QPoint(12,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN,7),QPoint(12,INT_MIN));
-    }
-
-    {
-	QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(INT_MIN,0),QPoint(0,INT_MAX));
-	QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MIN,INT_MAX));
-	QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN/2),QPoint(INT_MIN/2,INT_MAX));
-	QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MAX/2),QPoint(INT_MAX/2,INT_MAX));
-	QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MAX),QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(INT_MIN,7),QPoint(-12,INT_MAX));
-	QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(INT_MIN,-7),QPoint(12,INT_MAX));
-	QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN,7),QPoint(12,INT_MAX));
-    }
-
-    {
-	QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(100,0),QPoint(0,215));
-	QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(100,INT_MIN),QPoint(INT_MIN,215));
-	QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(100,INT_MIN/2),QPoint(INT_MIN/2,215));
-	QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(100,INT_MAX/2),QPoint(INT_MAX/2,215));
-	QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(100,INT_MAX),QPoint(INT_MAX,215));
-	QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(100,7),QPoint(-12,215));
-	QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(100,-7),QPoint(12,215));
-	QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(100,7),QPoint(12,215));
-    }
-
-    {
-	QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(1, 0),QPoint(0,-10));
-	QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(1, INT_MIN),QPoint(INT_MIN,-10));
-	QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(1, INT_MIN/2),QPoint(INT_MIN/2,-10));
-	QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(1, INT_MAX/2),QPoint(INT_MAX/2,-10));
-	QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(1, INT_MAX),QPoint(INT_MAX,-10));
-	QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(1, 7),QPoint(-12,-10));
-	QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(1, -7),QPoint(12,-10));
-	QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(1, 7),QPoint(12,-10));
-    }
-
-    {
-	QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(-10,0),QPoint(0,-6));
-	QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(-10,INT_MIN),QPoint(INT_MIN,-6));
-	QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(-10,INT_MIN/2),QPoint(INT_MIN/2,-6));
-	QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(-10,INT_MAX/2),QPoint(INT_MAX/2,-6));
-	QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(-10,INT_MAX),QPoint(INT_MAX,-6));
-	QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-10,7),QPoint(-12,-6));
-	QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(-10,-7),QPoint(12,-6));
-	QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(-10,7),QPoint(12,-6));
-    }
-
-    {
-	QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(5,0),QPoint(0,4));
-	QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(5,INT_MIN),QPoint(INT_MIN,4));
-	QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(5,INT_MIN/2),QPoint(INT_MIN/2,4));
-	QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(5,INT_MAX/2),QPoint(INT_MAX/2,4));
-	QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(5,INT_MAX),QPoint(INT_MAX,4));
-	QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(5,7),QPoint(-12,4));
-	QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(5,-7),QPoint(12,4));
-	QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(5,7),QPoint(12,4));
-    }
-
-    {
-	QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(2,0),QPoint(0,1));
-	QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(2,INT_MIN),QPoint(INT_MIN,1));
-	QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(2,INT_MIN/2),QPoint(INT_MIN/2,1));
-	QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(2,INT_MAX/2),QPoint(INT_MAX/2,1));
-	QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(2,INT_MAX),QPoint(INT_MAX,1));
-	QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(2,7),QPoint(-12,1));
-	QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(2,-7),QPoint(12,1));
-	QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(2,7),QPoint(12,1));
+        QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(0,-1));
+        QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(0,INT_MIN), QPoint(INT_MIN,-1));
+        QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(0,INT_MIN/2), QPoint(INT_MIN/2,-1));
+        QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(0,INT_MAX/2), QPoint(INT_MAX/2,-1));
+        QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(0,INT_MAX), QPoint(INT_MAX,-1));
+        QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(0,7), QPoint(-12,-1));
+        QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(0,-7), QPoint(12,-1));
+        QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(0,7), QPoint(12,-1));
+    }
+
+    {
+        QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(1,0), QPoint(0,1));
+        QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(1,INT_MIN), QPoint(INT_MIN,1));
+        QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(1,INT_MIN/2), QPoint(INT_MIN/2,1));
+        QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(1,INT_MAX/2), QPoint(INT_MAX/2,1));
+        QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(1,INT_MAX), QPoint(INT_MAX,1));
+        QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(1,7), QPoint(-12,1));
+        QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(1,-7), QPoint(12,1));
+        QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(1,7), QPoint(12,1));
+    }
+
+    {
+        QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(INT_MIN/2,0),QPoint(0,INT_MAX/2));
+        QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN),QPoint(INT_MIN,INT_MAX/2));
+        QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2),QPoint(INT_MIN/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MAX/2),QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MAX),QPoint(INT_MAX,INT_MAX/2));
+        QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(INT_MIN/2,7),QPoint(-12,INT_MAX/2));
+        QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(INT_MIN/2,-7),QPoint(12,INT_MAX/2));
+        QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN/2,7),QPoint(12,INT_MAX/2));
+    }
+
+    {
+        QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0),QPoint(0,INT_MAX-1));
+        QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(0,INT_MIN),QPoint(INT_MIN,INT_MAX-1));
+        QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(0,INT_MIN/2),QPoint(INT_MIN/2,INT_MAX-1));
+        QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(0,INT_MAX/2),QPoint(INT_MAX/2,INT_MAX-1));
+        QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(0,INT_MAX),QPoint(INT_MAX,INT_MAX-1));
+        QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(0,7),QPoint(-12,INT_MAX-1));
+        QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(0,-7),QPoint(12,INT_MAX-1));
+        QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(0,7),QPoint(12,INT_MAX-1));
+    }
+
+    {
+        QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(INT_MIN,0),QPoint(0,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN/2),QPoint(INT_MIN/2,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MAX/2),QPoint(INT_MAX/2,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MAX),QPoint(INT_MAX,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(INT_MIN,7),QPoint(-12,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(INT_MIN,-7),QPoint(12,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN,7),QPoint(12,INT_MIN));
+    }
+
+    {
+        QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(INT_MIN,0),QPoint(0,INT_MAX));
+        QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MIN,INT_MAX));
+        QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN/2),QPoint(INT_MIN/2,INT_MAX));
+        QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MAX/2),QPoint(INT_MAX/2,INT_MAX));
+        QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MAX),QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(INT_MIN,7),QPoint(-12,INT_MAX));
+        QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(INT_MIN,-7),QPoint(12,INT_MAX));
+        QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN,7),QPoint(12,INT_MAX));
+    }
+
+    {
+        QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(100,0),QPoint(0,215));
+        QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(100,INT_MIN),QPoint(INT_MIN,215));
+        QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(100,INT_MIN/2),QPoint(INT_MIN/2,215));
+        QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(100,INT_MAX/2),QPoint(INT_MAX/2,215));
+        QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(100,INT_MAX),QPoint(INT_MAX,215));
+        QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(100,7),QPoint(-12,215));
+        QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(100,-7),QPoint(12,215));
+        QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(100,7),QPoint(12,215));
+    }
+
+    {
+        QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(1, 0),QPoint(0,-10));
+        QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(1, INT_MIN),QPoint(INT_MIN,-10));
+        QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(1, INT_MIN/2),QPoint(INT_MIN/2,-10));
+        QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(1, INT_MAX/2),QPoint(INT_MAX/2,-10));
+        QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(1, INT_MAX),QPoint(INT_MAX,-10));
+        QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(1, 7),QPoint(-12,-10));
+        QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(1, -7),QPoint(12,-10));
+        QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(1, 7),QPoint(12,-10));
+    }
+
+    {
+        QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(-10,0),QPoint(0,-6));
+        QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(-10,INT_MIN),QPoint(INT_MIN,-6));
+        QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(-10,INT_MIN/2),QPoint(INT_MIN/2,-6));
+        QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(-10,INT_MAX/2),QPoint(INT_MAX/2,-6));
+        QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(-10,INT_MAX),QPoint(INT_MAX,-6));
+        QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-10,7),QPoint(-12,-6));
+        QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(-10,-7),QPoint(12,-6));
+        QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(-10,7),QPoint(12,-6));
+    }
+
+    {
+        QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(5,0),QPoint(0,4));
+        QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(5,INT_MIN),QPoint(INT_MIN,4));
+        QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(5,INT_MIN/2),QPoint(INT_MIN/2,4));
+        QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(5,INT_MAX/2),QPoint(INT_MAX/2,4));
+        QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(5,INT_MAX),QPoint(INT_MAX,4));
+        QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(5,7),QPoint(-12,4));
+        QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(5,-7),QPoint(12,4));
+        QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(5,7),QPoint(12,4));
+    }
+
+    {
+        QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(2,0),QPoint(0,1));
+        QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(2,INT_MIN),QPoint(INT_MIN,1));
+        QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(2,INT_MIN/2),QPoint(INT_MIN/2,1));
+        QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(2,INT_MAX/2),QPoint(INT_MAX/2,1));
+        QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(2,INT_MAX),QPoint(INT_MAX,1));
+        QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(2,7),QPoint(-12,1));
+        QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(2,-7),QPoint(12,1));
+        QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(2,7),QPoint(12,1));
     }
 }
 
@@ -2163,212 +2163,212 @@ void tst_QRect::newSetBottomLeft_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0),QPoint(-1,0));
-	QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,0),QPoint(-1,INT_MIN));
-	QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,0),QPoint(-1,INT_MIN/2));
-	QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,0),QPoint(-1,INT_MAX/2));
-	QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,0),QPoint(-1,INT_MAX));
-	QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,0),QPoint(-1,7));
-	QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,0),QPoint(-1,-7));
-	QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,0),QPoint(-1,7));
-    }
-
-    {
-	QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,1),QPoint(1,0));
-	QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,1),QPoint(1,INT_MIN));
-	QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,1),QPoint(1,INT_MIN/2));
-	QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,1), QPoint(1,INT_MAX/2));
-	QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,1), QPoint(1,INT_MAX));
-	QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,1),QPoint(1,7));
-	QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,1),QPoint(1,-7));
-	QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,1),QPoint(1,7));
-    }
-
-    {
-	QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,INT_MIN/2),QPoint(INT_MAX/2,0));
-	QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN/2),QPoint(INT_MAX/2,INT_MIN));
-	QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2),QPoint(INT_MAX/2,INT_MIN/2));
-	QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MIN/2),QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MIN/2),QPoint(INT_MAX/2,INT_MAX));
-	QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,INT_MIN/2),QPoint(INT_MAX/2,7));
-	QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,INT_MIN/2),QPoint(INT_MAX/2,-7));
-	QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,INT_MIN/2),QPoint(INT_MAX/2,7));
-    }
-
-    {
-	QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0),QPoint(INT_MAX-1,0));
-	QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,0),QPoint(INT_MAX-1,INT_MIN));
-	QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,0),QPoint(INT_MAX-1,INT_MIN/2));
-	QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,0),QPoint(INT_MAX-1,INT_MAX/2));
-	QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,0),QPoint(INT_MAX-1,INT_MAX));
-	QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,0),QPoint(INT_MAX-1,7));
-	QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,0),QPoint(INT_MAX-1,-7));
-	QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,0),QPoint(INT_MAX-1,7));
-    }
-
-    {
-	QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,INT_MIN),QPoint(INT_MIN,0));
-	QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN),QPoint(INT_MIN,INT_MIN/2));
-	QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MIN),QPoint(INT_MIN,INT_MAX/2));
-	QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MIN),QPoint(INT_MIN,INT_MAX));
-	QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,INT_MIN),QPoint(INT_MIN,7));
-	QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,INT_MIN),QPoint(INT_MIN,-7));
-	QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,INT_MIN),QPoint(INT_MIN,7));
-    }
-
-    {
-	QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,INT_MIN),QPoint(INT_MAX,0));
-	QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MAX,INT_MIN));
-	QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN),QPoint(INT_MAX,INT_MIN/2));
-	QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MIN),QPoint(INT_MAX,INT_MAX/2));
-	QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MIN),QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,INT_MIN),QPoint(INT_MAX,7));
-	QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,INT_MIN),QPoint(INT_MAX,-7));
-	QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,INT_MIN),QPoint(INT_MAX,7));
-    }
-
-    {
-	QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,200),QPoint(110,0));
-	QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,200),QPoint(110,INT_MIN));
-	QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,200),QPoint(110,INT_MIN/2));
-	QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,200),QPoint(110,INT_MAX/2));
-	QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,200),QPoint(110,INT_MAX));
-	QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,200),QPoint(110,7));
-	QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,200),QPoint(110,-7));
-	QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,200),QPoint(110,7));
-    }
-
-    {
-	QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0, 1),QPoint(-10,0));
-	QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN, 1),QPoint(-10,INT_MIN));
-	QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2, 1),QPoint(-10,INT_MIN/2));
-	QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2, 1),QPoint(-10,INT_MAX/2));
-	QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX, 1),QPoint(-10,INT_MAX));
-	QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12, 1),QPoint(-10,7));
-	QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12, 1),QPoint(-10,-7));
-	QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12, 1),QPoint(-10,7));
-    }
-
-    {
-	QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,-10),QPoint(-6,0));
-	QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,-10),QPoint(-6,INT_MIN));
-	QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,-10),QPoint(-6,INT_MIN/2));
-	QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,-10),QPoint(-6,INT_MAX/2));
-	QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,-10),QPoint(-6,INT_MAX));
-	QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,-10),QPoint(-6,7));
-	QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-10),QPoint(-6,-7));
-	QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,-10),QPoint(-6,7));
-    }
-
-    {
-	QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,5),QPoint(4,0));
-	QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,5),QPoint(4,INT_MIN));
-	QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,5),QPoint(4,INT_MIN/2));
-	QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,5),QPoint(4,INT_MAX/2));
-	QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,5),QPoint(4,INT_MAX));
-	QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,5),QPoint(4,7));
-	QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,5),QPoint(4,-7));
-	QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,5),QPoint(4,7));
-    }
-
-    {
-	QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,2),QPoint(1,0));
-	QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,2),QPoint(1,INT_MIN));
-	QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,2),QPoint(1,INT_MIN/2));
-	QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,2),QPoint(1,INT_MAX/2));
-	QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,2),QPoint(1,INT_MAX));
-	QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,2),QPoint(1,7));
-	QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,2),QPoint(1,-7));
-	QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,2),QPoint(1,7));
+        QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0),QPoint(-1,0));
+        QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,0),QPoint(-1,INT_MIN));
+        QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,0),QPoint(-1,INT_MIN/2));
+        QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,0),QPoint(-1,INT_MAX/2));
+        QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,0),QPoint(-1,INT_MAX));
+        QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,0),QPoint(-1,7));
+        QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,0),QPoint(-1,-7));
+        QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,0),QPoint(-1,7));
+    }
+
+    {
+        QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,1),QPoint(1,0));
+        QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,1),QPoint(1,INT_MIN));
+        QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,1),QPoint(1,INT_MIN/2));
+        QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,1), QPoint(1,INT_MAX/2));
+        QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,1), QPoint(1,INT_MAX));
+        QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,1),QPoint(1,7));
+        QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,1),QPoint(1,-7));
+        QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,1),QPoint(1,7));
+    }
+
+    {
+        QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,INT_MIN/2),QPoint(INT_MAX/2,0));
+        QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN/2),QPoint(INT_MAX/2,INT_MIN));
+        QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2),QPoint(INT_MAX/2,INT_MIN/2));
+        QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MIN/2),QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MIN/2),QPoint(INT_MAX/2,INT_MAX));
+        QTest::newRow("MiddleQRect_NegXQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,INT_MIN/2),QPoint(INT_MAX/2,7));
+        QTest::newRow("MiddleQRect_NegYQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,INT_MIN/2),QPoint(INT_MAX/2,-7));
+        QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,INT_MIN/2),QPoint(INT_MAX/2,7));
+    }
+
+    {
+        QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0),QPoint(INT_MAX-1,0));
+        QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,0),QPoint(INT_MAX-1,INT_MIN));
+        QTest::newRow("LargestQRect_MiddleNegCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,0),QPoint(INT_MAX-1,INT_MIN/2));
+        QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,0),QPoint(INT_MAX-1,INT_MAX/2));
+        QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,0),QPoint(INT_MAX-1,INT_MAX));
+        QTest::newRow("LargestQRect_NegXQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,0),QPoint(INT_MAX-1,7));
+        QTest::newRow("LargestQRect_NegYQPoint") << getQRectCase(LargestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,0),QPoint(INT_MAX-1,-7));
+        QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,0),QPoint(INT_MAX-1,7));
+    }
+
+    {
+        QTest::newRow("SmallestCoordQRect_NullQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,INT_MIN),QPoint(INT_MIN,0));
+        QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN),QPoint(INT_MIN,INT_MIN/2));
+        QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MIN),QPoint(INT_MIN,INT_MAX/2));
+        QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MIN),QPoint(INT_MIN,INT_MAX));
+        QTest::newRow("SmallestCoordQRect_NegXQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,INT_MIN),QPoint(INT_MIN,7));
+        QTest::newRow("SmallestCoordQRect_NegYQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,INT_MIN),QPoint(INT_MIN,-7));
+        QTest::newRow("SmallestCoordQRect_RandomQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,INT_MIN),QPoint(INT_MIN,7));
+    }
+
+    {
+        QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,INT_MIN),QPoint(INT_MAX,0));
+        QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN),QPoint(INT_MAX,INT_MIN));
+        QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN),QPoint(INT_MAX,INT_MIN/2));
+        QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MIN),QPoint(INT_MAX,INT_MAX/2));
+        QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MIN),QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("LargestCoordQRect_NegXQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,INT_MIN),QPoint(INT_MAX,7));
+        QTest::newRow("LargestCoordQRect_NegYQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,INT_MIN),QPoint(INT_MAX,-7));
+        QTest::newRow("LargestCoordQRect_RandomQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,INT_MIN),QPoint(INT_MAX,7));
+    }
+
+    {
+        QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,200),QPoint(110,0));
+        QTest::newRow("RandomQRect_SmallestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,200),QPoint(110,INT_MIN));
+        QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,200),QPoint(110,INT_MIN/2));
+        QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,200),QPoint(110,INT_MAX/2));
+        QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,200),QPoint(110,INT_MAX));
+        QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,200),QPoint(110,7));
+        QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,200),QPoint(110,-7));
+        QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,200),QPoint(110,7));
+    }
+
+    {
+        QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0, 1),QPoint(-10,0));
+        QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN, 1),QPoint(-10,INT_MIN));
+        QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2, 1),QPoint(-10,INT_MIN/2));
+        QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2, 1),QPoint(-10,INT_MAX/2));
+        QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX, 1),QPoint(-10,INT_MAX));
+        QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12, 1),QPoint(-10,7));
+        QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12, 1),QPoint(-10,-7));
+        QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12, 1),QPoint(-10,7));
+    }
+
+    {
+        QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,-10),QPoint(-6,0));
+        QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,-10),QPoint(-6,INT_MIN));
+        QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,-10),QPoint(-6,INT_MIN/2));
+        QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,-10),QPoint(-6,INT_MAX/2));
+        QTest::newRow("NegativePointQRect_LargestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,-10),QPoint(-6,INT_MAX));
+        QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,-10),QPoint(-6,7));
+        QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-10),QPoint(-6,-7));
+        QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,-10),QPoint(-6,7));
+    }
+
+    {
+        QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,5),QPoint(4,0));
+        QTest::newRow("NullQRect_SmallestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,5),QPoint(4,INT_MIN));
+        QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,5),QPoint(4,INT_MIN/2));
+        QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,5),QPoint(4,INT_MAX/2));
+        QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,5),QPoint(4,INT_MAX));
+        QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,5),QPoint(4,7));
+        QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,5),QPoint(4,-7));
+        QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,5),QPoint(4,7));
+    }
+
+    {
+        QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,2),QPoint(1,0));
+        QTest::newRow("EmptyQRect_SmallestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,2),QPoint(1,INT_MIN));
+        QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,2),QPoint(1,INT_MIN/2));
+        QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,2),QPoint(1,INT_MAX/2));
+        QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,2),QPoint(1,INT_MAX));
+        QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,2),QPoint(1,7));
+        QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,2),QPoint(1,-7));
+        QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,2),QPoint(1,7));
     }
 }
 
@@ -2587,154 +2587,154 @@ void tst_QRect::newMoveLeft_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	// QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2,0), QPoint(INT_MIN/2-1,-1) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2,0), QPoint(INT_MAX/2-1,-1) );
-	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX,0), QPoint(INT_MAX-1,-1) );
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953,0), QPoint(4952,-1) );
-    }
-
-    {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						 << QRect( QPoint(INT_MIN,1), QPoint(INT_MIN,1) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2,1), QPoint(INT_MIN/2,1) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,1), QPoint(0,1) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2,1), QPoint(INT_MAX/2,1) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX,1), QPoint(INT_MAX,1) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953,1), QPoint(4953,1) );
-    }
-
-    {
-	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN, INT_MIN / 2 ), QPoint( (INT_MAX/2)+(INT_MIN-INT_MIN/2), INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2, INT_MIN / 2 ), QPoint((INT_MAX/2)+(INT_MIN/2-INT_MIN/2), INT_MAX / 2 ) );
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0, INT_MIN / 2 ), QPoint((INT_MAX/2)+(0-INT_MIN/2),INT_MAX/2));
-	// QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "MiddleQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "MiddleQRect_RandomInt" ) -- Not tested as it would cause an overflow
-    }
-
-    {
-	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN, 0), QPoint((INT_MAX-1)+INT_MIN, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2, 0), QPoint((INT_MAX-1)+(INT_MIN/2), INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0, 0), QPoint(INT_MAX-1,INT_MAX - 1 ) );
-	// QTest::newRow( "LargestQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "LargestQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "LargestQRect_RandomInt" ) -- Not tested as it would cause an overflow
-    }
-
-    {
-	// QTest::newRow( "SmallestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint(INT_MIN/2, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, INT_MIN ), QPoint(0, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint(INT_MAX/2, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, INT_MIN ), QPoint(INT_MAX, INT_MIN ) );
-	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, INT_MIN ), QPoint(4953, INT_MIN ) );
-    }
-
-    {
-	// QTest::newRow( "LargestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint(INT_MIN/2-1, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, INT_MIN ), QPoint(-1, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint(INT_MAX/2-1, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, INT_MIN ), QPoint(INT_MAX-1, INT_MAX ) );
-	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, INT_MIN ), QPoint(4952, INT_MAX ) );
-    }
-
-    {
-	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, 200 ), QPoint(10+INT_MIN, 215 ) );
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 200 ), QPoint(10+INT_MIN/2, 215 ) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 200 ), QPoint(10, 215 ) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 200 ), QPoint(10+INT_MAX/2, 215 ) );
-	// QTest::newRow( "RandomQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 200 ), QPoint(4963, 215 ) );
-    }
-
-    {
-	// QTest::newRow( "NegativeSizeQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 1 ), QPoint(INT_MIN/2-11, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 1 ), QPoint(-11, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 1 ), QPoint(INT_MAX/2-11, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 1 ), QPoint(INT_MAX-11, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 1 ), QPoint(4942, -10 ) );
-    }
-
-    {
-	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint( INT_MIN, -10 ), QPoint(4+INT_MIN, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, -10 ), QPoint(4+INT_MIN/2, -6 ) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, -10 ), QPoint(4, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, -10 ), QPoint(4+INT_MAX/2, -6 ) );
-	// QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, -10 ), QPoint(4957, -6 ) );
-    }
-
-    {
-	// QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 5 ), QPoint(INT_MIN/2-1, 4 ) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 5 ), QPoint(-1, 4 ) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 5), QPoint(INT_MAX/2-1, 4 ) );
-	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 5 ), QPoint(INT_MAX-1, 4 ) );
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 5 ), QPoint(4952, 4 ) );
-    }
-
-    {
-	// QTest::newRow( "EmptyQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint( INT_MIN/2, 2 ), QPoint(INT_MIN/2-1, 1 ) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint( 0, 2 ), QPoint(-1, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint( INT_MAX/2, 2 ), QPoint(INT_MAX/2-1, 1 ) );
-	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint( INT_MAX, 2 ), QPoint(INT_MAX-1, 1 ) );
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4953, 2 ), QPoint(4952, 1 ) );
+        // QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2,0), QPoint(INT_MIN/2-1,-1) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2,0), QPoint(INT_MAX/2-1,-1) );
+        QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX,0), QPoint(INT_MAX-1,-1) );
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953,0), QPoint(4952,-1) );
+    }
+
+    {
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                 << QRect( QPoint(INT_MIN,1), QPoint(INT_MIN,1) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2,1), QPoint(INT_MIN/2,1) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,1), QPoint(0,1) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2,1), QPoint(INT_MAX/2,1) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX,1), QPoint(INT_MAX,1) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953,1), QPoint(4953,1) );
+    }
+
+    {
+        QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN, INT_MIN / 2 ), QPoint( (INT_MAX/2)+(INT_MIN-INT_MIN/2), INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2, INT_MIN / 2 ), QPoint((INT_MAX/2)+(INT_MIN/2-INT_MIN/2), INT_MAX / 2 ) );
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0, INT_MIN / 2 ), QPoint((INT_MAX/2)+(0-INT_MIN/2),INT_MAX/2));
+        // QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "MiddleQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "MiddleQRect_RandomInt" ) -- Not tested as it would cause an overflow
+    }
+
+    {
+        QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN, 0), QPoint((INT_MAX-1)+INT_MIN, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2, 0), QPoint((INT_MAX-1)+(INT_MIN/2), INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0, 0), QPoint(INT_MAX-1,INT_MAX - 1 ) );
+        // QTest::newRow( "LargestQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "LargestQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "LargestQRect_RandomInt" ) -- Not tested as it would cause an overflow
+    }
+
+    {
+        // QTest::newRow( "SmallestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint(INT_MIN/2, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, INT_MIN ), QPoint(0, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint(INT_MAX/2, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, INT_MIN ), QPoint(INT_MAX, INT_MIN ) );
+        QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, INT_MIN ), QPoint(4953, INT_MIN ) );
+    }
+
+    {
+        // QTest::newRow( "LargestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, INT_MIN ), QPoint(INT_MIN/2-1, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, INT_MIN ), QPoint(-1, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, INT_MIN ), QPoint(INT_MAX/2-1, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, INT_MIN ), QPoint(INT_MAX-1, INT_MAX ) );
+        QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, INT_MIN ), QPoint(4952, INT_MAX ) );
+    }
+
+    {
+        QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, 200 ), QPoint(10+INT_MIN, 215 ) );
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 200 ), QPoint(10+INT_MIN/2, 215 ) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 200 ), QPoint(10, 215 ) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 200 ), QPoint(10+INT_MAX/2, 215 ) );
+        // QTest::newRow( "RandomQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 200 ), QPoint(4963, 215 ) );
+    }
+
+    {
+        // QTest::newRow( "NegativeSizeQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 1 ), QPoint(INT_MIN/2-11, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 1 ), QPoint(-11, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 1 ), QPoint(INT_MAX/2-11, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 1 ), QPoint(INT_MAX-11, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 1 ), QPoint(4942, -10 ) );
+    }
+
+    {
+        QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint( INT_MIN, -10 ), QPoint(4+INT_MIN, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, -10 ), QPoint(4+INT_MIN/2, -6 ) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, -10 ), QPoint(4, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, -10 ), QPoint(4+INT_MAX/2, -6 ) );
+        // QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, -10 ), QPoint(4957, -6 ) );
+    }
+
+    {
+        // QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 5 ), QPoint(INT_MIN/2-1, 4 ) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 5 ), QPoint(-1, 4 ) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 5), QPoint(INT_MAX/2-1, 4 ) );
+        QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 5 ), QPoint(INT_MAX-1, 4 ) );
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 5 ), QPoint(4952, 4 ) );
+    }
+
+    {
+        // QTest::newRow( "EmptyQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint( INT_MIN/2, 2 ), QPoint(INT_MIN/2-1, 1 ) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint( 0, 2 ), QPoint(-1, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint( INT_MAX/2, 2 ), QPoint(INT_MAX/2-1, 1 ) );
+        QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint( INT_MAX, 2 ), QPoint(INT_MAX-1, 1 ) );
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4953, 2 ), QPoint(4952, 1 ) );
     }
 }
 
@@ -2756,154 +2756,154 @@ void tst_QRect::newMoveTop_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	// QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,INT_MIN/2), QPoint(-1,INT_MIN/2-1) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0), QPoint(-1,-1) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,INT_MAX/2), QPoint(-1,INT_MAX/2-1) );
-	QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(0,INT_MAX), QPoint(-1,INT_MAX-1) );
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,4953), QPoint(-1,4952) );
-    }
-
-    {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						 << QRect( QPoint(1,INT_MIN), QPoint(1,INT_MIN) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,INT_MIN/2), QPoint(1,INT_MIN/2) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,0), QPoint(1,0) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,INT_MAX/2), QPoint(1,INT_MAX/2) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,INT_MAX), QPoint(1,INT_MAX) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,4953), QPoint(1,4953) );
-    }
-
-    {
-	QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(INT_MIN / 2,INT_MIN ), QPoint(INT_MAX / 2,(INT_MAX/2)+(INT_MIN-INT_MIN/2)) );
-	QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN / 2,INT_MIN / 2), QPoint(INT_MAX / 2,(INT_MAX/2)+(INT_MIN/2-INT_MIN/2)) );
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN / 2,0 ), QPoint(INT_MAX/2,(INT_MAX/2)+(0-INT_MIN/2)));
-	// QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "MiddleQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "MiddleQRect_RandomInt" ) -- Not tested as it would cause an overflow
-    }
-
-    {
-	QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(0,INT_MIN), QPoint(INT_MAX - 1,(INT_MAX-1)+INT_MIN) );
-	QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,INT_MIN/2), QPoint(INT_MAX - 1,(INT_MAX-1)+(INT_MIN/2)) );
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0, 0), QPoint(INT_MAX-1,INT_MAX - 1) );
-	// QTest::newRow( "LargestQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "LargestQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "LargestQRect_RandomInt" ) -- Not tested as it would cause an overflow
-    }
-
-    {
-	// QTest::newRow( "SmallestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint(INT_MIN,INT_MIN/2) );
-	QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN,0), QPoint(INT_MIN,0) );
-	QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint(INT_MIN,INT_MAX/2) );
-	QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MIN,INT_MAX), QPoint(INT_MIN,INT_MAX) );
-	QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(INT_MIN,4953), QPoint(INT_MIN,4953) );
-    }
-
-    {
-	// QTest::newRow( "LargestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint(INT_MAX,INT_MIN/2-1) );
-	QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN,0), QPoint(INT_MAX,-1) );
-	QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint(INT_MAX,INT_MAX/2-1) );
-	QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MIN,INT_MAX), QPoint(INT_MAX,INT_MAX-1) );
-	QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(INT_MIN,4953), QPoint(INT_MAX,4952) );
-    }
-
-    {
-	QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(100,INT_MIN), QPoint(110,15+INT_MIN) );
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(100,INT_MIN/2), QPoint(110,15+INT_MIN/2) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(100, 0), QPoint(110,15) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(100,INT_MAX/2), QPoint(110,15+INT_MAX/2) );
-	// QTest::newRow( "RandomQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(100,4953), QPoint(110,4968) );
-    }
-
-    {
-	// QTest::newRow( "NegativeSizeQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,INT_MIN/2), QPoint(-10,INT_MIN/2-11) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,0), QPoint(-10,-11) );
-	QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,INT_MAX/2), QPoint(-10,INT_MAX/2-11) );
-	QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,INT_MAX), QPoint(-10,INT_MAX-11) );
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,4953), QPoint(-10,4942) );
-    }
-
-    {
-	QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
-						<< QRect( QPoint(-10,INT_MIN), QPoint(-6,4+INT_MIN) );
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(-10,INT_MIN/2), QPoint(-6,4+INT_MIN/2) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(-10,0), QPoint(-6,4) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(-10,INT_MAX/2), QPoint(-6,4+INT_MAX/2) );
-	// QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(-10,4953), QPoint(-6,4957) );
-    }
-
-    {
-	// QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(5,INT_MIN/2), QPoint(4,INT_MIN/2-1) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(5,0), QPoint(4,-1) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(5,INT_MAX/2), QPoint(4,INT_MAX/2-1) );
-	QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(5,INT_MAX), QPoint(4,INT_MAX-1) );
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(5,4953), QPoint(4,4952) );
-    }
-
-    {
-	// QTest::newRow( "EmptyQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(2,INT_MIN/2), QPoint(1,INT_MIN/2-1) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(2,0), QPoint(1,-1) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(2,INT_MAX/2), QPoint(1,INT_MAX/2-1) );
-	QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(2,INT_MAX), QPoint(1,INT_MAX-1) );
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(2,4953), QPoint(1,4952) );
+        // QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,INT_MIN/2), QPoint(-1,INT_MIN/2-1) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0), QPoint(-1,-1) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,INT_MAX/2), QPoint(-1,INT_MAX/2-1) );
+        QTest::newRow( "InvalidQRect_MaximumInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(0,INT_MAX), QPoint(-1,INT_MAX-1) );
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,4953), QPoint(-1,4952) );
+    }
+
+    {
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                 << QRect( QPoint(1,INT_MIN), QPoint(1,INT_MIN) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,INT_MIN/2), QPoint(1,INT_MIN/2) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,0), QPoint(1,0) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,INT_MAX/2), QPoint(1,INT_MAX/2) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,INT_MAX), QPoint(1,INT_MAX) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,4953), QPoint(1,4953) );
+    }
+
+    {
+        QTest::newRow( "MiddleQRect_MinimumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(INT_MIN / 2,INT_MIN ), QPoint(INT_MAX / 2,(INT_MAX/2)+(INT_MIN-INT_MIN/2)) );
+        QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN / 2,INT_MIN / 2), QPoint(INT_MAX / 2,(INT_MAX/2)+(INT_MIN/2-INT_MIN/2)) );
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN / 2,0 ), QPoint(INT_MAX/2,(INT_MAX/2)+(0-INT_MIN/2)));
+        // QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "MiddleQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "MiddleQRect_RandomInt" ) -- Not tested as it would cause an overflow
+    }
+
+    {
+        QTest::newRow( "LargestQRect_MinimumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(0,INT_MIN), QPoint(INT_MAX - 1,(INT_MAX-1)+INT_MIN) );
+        QTest::newRow( "LargestQRect_MiddleNegativeInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,INT_MIN/2), QPoint(INT_MAX - 1,(INT_MAX-1)+(INT_MIN/2)) );
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0, 0), QPoint(INT_MAX-1,INT_MAX - 1) );
+        // QTest::newRow( "LargestQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "LargestQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "LargestQRect_RandomInt" ) -- Not tested as it would cause an overflow
+    }
+
+    {
+        // QTest::newRow( "SmallestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint(INT_MIN,INT_MIN/2) );
+        QTest::newRow( "SmallestCoordQRect_ZeroInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN,0), QPoint(INT_MIN,0) );
+        QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint(INT_MIN,INT_MAX/2) );
+        QTest::newRow( "SmallestCoordQRect_MaximumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MIN,INT_MAX), QPoint(INT_MIN,INT_MAX) );
+        QTest::newRow( "SmallestCoordQRect_RandomInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(INT_MIN,4953), QPoint(INT_MIN,4953) );
+    }
+
+    {
+        // QTest::newRow( "LargestCoordQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "LargestCoordQRect_MiddleNegativeInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MIN/2), QPoint(INT_MAX,INT_MIN/2-1) );
+        QTest::newRow( "LargestCoordQRect_ZeroInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN,0), QPoint(INT_MAX,-1) );
+        QTest::newRow( "LargestCoordQRect_MiddlePositiveInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MIN,INT_MAX/2), QPoint(INT_MAX,INT_MAX/2-1) );
+        QTest::newRow( "LargestCoordQRect_MaximumInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MIN,INT_MAX), QPoint(INT_MAX,INT_MAX-1) );
+        QTest::newRow( "LargestCoordQRect_RandomInt" ) << getQRectCase( LargestCoordQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(INT_MIN,4953), QPoint(INT_MAX,4952) );
+    }
+
+    {
+        QTest::newRow( "RandomQRect_MinimumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(100,INT_MIN), QPoint(110,15+INT_MIN) );
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(100,INT_MIN/2), QPoint(110,15+INT_MIN/2) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(100, 0), QPoint(110,15) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(100,INT_MAX/2), QPoint(110,15+INT_MAX/2) );
+        // QTest::newRow( "RandomQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(100,4953), QPoint(110,4968) );
+    }
+
+    {
+        // QTest::newRow( "NegativeSizeQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,INT_MIN/2), QPoint(-10,INT_MIN/2-11) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,0), QPoint(-10,-11) );
+        QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,INT_MAX/2), QPoint(-10,INT_MAX/2-11) );
+        QTest::newRow( "NegativeSizeQRect_MaximumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,INT_MAX), QPoint(-10,INT_MAX-11) );
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,4953), QPoint(-10,4942) );
+    }
+
+    {
+        QTest::newRow( "NegativePointQRect_MinimumInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MinimumInt )
+                                                << QRect( QPoint(-10,INT_MIN), QPoint(-6,4+INT_MIN) );
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(-10,INT_MIN/2), QPoint(-6,4+INT_MIN/2) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(-10,0), QPoint(-6,4) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(-10,INT_MAX/2), QPoint(-6,4+INT_MAX/2) );
+        // QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(-10,4953), QPoint(-6,4957) );
+    }
+
+    {
+        // QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(5,INT_MIN/2), QPoint(4,INT_MIN/2-1) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(5,0), QPoint(4,-1) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(5,INT_MAX/2), QPoint(4,INT_MAX/2-1) );
+        QTest::newRow( "NullQRect_MaximumInt" ) << getQRectCase( NullQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(5,INT_MAX), QPoint(4,INT_MAX-1) );
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(5,4953), QPoint(4,4952) );
+    }
+
+    {
+        // QTest::newRow( "EmptyQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(2,INT_MIN/2), QPoint(1,INT_MIN/2-1) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(2,0), QPoint(1,-1) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(2,INT_MAX/2), QPoint(1,INT_MAX/2-1) );
+        QTest::newRow( "EmptyQRect_MaximumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(2,INT_MAX), QPoint(1,INT_MAX-1) );
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(2,4953), QPoint(1,4952) );
     }
 }
 
@@ -2925,139 +2925,139 @@ void tst_QRect::newMoveRight_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	// QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2+1,0), QPoint(INT_MIN/2,-1) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,0), QPoint(0,-1) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2+1,0), QPoint(INT_MAX/2,-1) );
-	// QTest::newRow( "InvalidQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4954,0), QPoint(4953,-1) );
+        // QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2+1,0), QPoint(INT_MIN/2,-1) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,0), QPoint(0,-1) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2+1,0), QPoint(INT_MAX/2,-1) );
+        // QTest::newRow( "InvalidQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4954,0), QPoint(4953,-1) );
     }
 
     {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						 << QRect( QPoint(INT_MIN,1), QPoint(INT_MIN,1) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2,1), QPoint(INT_MIN/2,1) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,1), QPoint(0,1) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2,1), QPoint(INT_MAX/2,1) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(INT_MAX,1), QPoint(INT_MAX,1) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953,1), QPoint(4953,1) );
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                 << QRect( QPoint(INT_MIN,1), QPoint(INT_MIN,1) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2,1), QPoint(INT_MIN/2,1) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,1), QPoint(0,1) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2,1), QPoint(INT_MAX/2,1) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(INT_MAX,1), QPoint(INT_MAX,1) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953,1), QPoint(4953,1) );
     }
 
     {
-	// QTest::newRow( "MiddleQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN/2+(0-INT_MAX/2),INT_MIN/2), QPoint(0,INT_MAX/2));
-	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
-						      << QRect(QPoint(INT_MIN/2+(INT_MAX/2-INT_MAX/2),INT_MIN/2),QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
-	       				       << QRect(QPoint(INT_MIN/2+(INT_MAX-INT_MAX/2),INT_MIN/2),QPoint(INT_MAX,INT_MAX/2));
-	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
-					      << QRect(QPoint(INT_MIN/2+(4953-INT_MAX/2),INT_MIN/2),QPoint(4953,INT_MAX/2));
-    }
-
-    {
-	// QTest::newRow( "LargestQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "LargestQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0-(INT_MAX-1), 0), QPoint(0, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2-(INT_MAX-1), 0), QPoint(INT_MAX/2, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
-			       		        << QRect( QPoint(INT_MAX-(INT_MAX-1), 0), QPoint(INT_MAX, INT_MAX - 1 ) );
-	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4953-(INT_MAX-1), 0), QPoint(4953, INT_MAX - 1 ) );
-    }
-
-    {
-	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
-						       << QRect(QPoint(INT_MIN+(INT_MIN-INT_MIN),INT_MIN), QPoint(INT_MIN,INT_MIN) );
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect(QPoint(INT_MIN+(INT_MIN/2-INT_MIN),INT_MIN), QPoint(INT_MIN/2, INT_MIN ) );
-	// QTest::newRow( "SmallestCoordQRect_ZeroInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "SmallestCoordQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "SmallestCoordQRect_RandomInt" ) -- Not tested as it would cause an overflow
-    }
-
-    {
-	 // LargestQRect cases -- Not tested as it would cause an overflow
-    }
-
-    {
-	// QTest::newRow( "RandomQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(100+(INT_MIN/2-110), 200 ), QPoint(INT_MIN/2, 215 ) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(-10, 200 ), QPoint(0, 215 ) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(100+(INT_MAX/2-110), 200 ), QPoint(INT_MAX/2, 215 ) );
-	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
-						       << QRect( QPoint(100+(INT_MAX-110), 200 ), QPoint(INT_MAX, 215 ) );
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4943, 200 ), QPoint(4953, 215 ) );
-    }
-
-    {
-	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
-						       << QRect( QPoint(1+(INT_MIN-(-10)), 1 ), QPoint(INT_MIN, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1+(INT_MIN/2-(-10)), 1 ), QPoint(INT_MIN/2, -10 ) );
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(11, 1 ), QPoint(0, -10 ) );
-	// QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) -- Not tested as this would cause an overflow
-	// QTest::newRow( "NegativeSizeQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4964, 1 ), QPoint(4953, -10 ) );
-    }
-
-    {
-	// QTest::newRow( "NegativePointQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint((-10)+(INT_MIN/2-(-6)), -10 ), QPoint(INT_MIN/2, -6 ) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(-4, -10 ), QPoint(0, -6 ) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint((-10)+(INT_MAX/2-(-6)), -10 ), QPoint(INT_MAX/2, -6 ) );
-	// QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4949, -10 ), QPoint(4953, -6 ) );
-    }
+        // QTest::newRow( "MiddleQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN/2+(0-INT_MAX/2),INT_MIN/2), QPoint(0,INT_MAX/2));
+        QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
+                                                      << QRect(QPoint(INT_MIN/2+(INT_MAX/2-INT_MAX/2),INT_MIN/2),QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
+                                                      << QRect(QPoint(INT_MIN/2+(INT_MAX-INT_MAX/2),INT_MIN/2),QPoint(INT_MAX,INT_MAX/2));
+        QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
+                                              << QRect(QPoint(INT_MIN/2+(4953-INT_MAX/2),INT_MIN/2),QPoint(4953,INT_MAX/2));
+    }
+
+    {
+        // QTest::newRow( "LargestQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "LargestQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0-(INT_MAX-1), 0), QPoint(0, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2-(INT_MAX-1), 0), QPoint(INT_MAX/2, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
+                                                       << QRect( QPoint(INT_MAX-(INT_MAX-1), 0), QPoint(INT_MAX, INT_MAX - 1 ) );
+        QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4953-(INT_MAX-1), 0), QPoint(4953, INT_MAX - 1 ) );
+    }
+
+    {
+        QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
+                                                       << QRect(QPoint(INT_MIN+(INT_MIN-INT_MIN),INT_MIN), QPoint(INT_MIN,INT_MIN) );
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect(QPoint(INT_MIN+(INT_MIN/2-INT_MIN),INT_MIN), QPoint(INT_MIN/2, INT_MIN ) );
+        // QTest::newRow( "SmallestCoordQRect_ZeroInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "SmallestCoordQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "SmallestCoordQRect_RandomInt" ) -- Not tested as it would cause an overflow
+    }
+
+    {
+         // LargestQRect cases -- Not tested as it would cause an overflow
+    }
+
+    {
+        // QTest::newRow( "RandomQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(100+(INT_MIN/2-110), 200 ), QPoint(INT_MIN/2, 215 ) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(-10, 200 ), QPoint(0, 215 ) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(100+(INT_MAX/2-110), 200 ), QPoint(INT_MAX/2, 215 ) );
+        QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
+                                                       << QRect( QPoint(100+(INT_MAX-110), 200 ), QPoint(INT_MAX, 215 ) );
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4943, 200 ), QPoint(4953, 215 ) );
+    }
+
+    {
+        QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
+                                                       << QRect( QPoint(1+(INT_MIN-(-10)), 1 ), QPoint(INT_MIN, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1+(INT_MIN/2-(-10)), 1 ), QPoint(INT_MIN/2, -10 ) );
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(11, 1 ), QPoint(0, -10 ) );
+        // QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) -- Not tested as this would cause an overflow
+        // QTest::newRow( "NegativeSizeQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4964, 1 ), QPoint(4953, -10 ) );
+    }
+
+    {
+        // QTest::newRow( "NegativePointQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint((-10)+(INT_MIN/2-(-6)), -10 ), QPoint(INT_MIN/2, -6 ) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(-4, -10 ), QPoint(0, -6 ) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint((-10)+(INT_MAX/2-(-6)), -10 ), QPoint(INT_MAX/2, -6 ) );
+        // QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4949, -10 ), QPoint(4953, -6 ) );
+    }
 
     {
-	// QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(5+(INT_MIN/2-4), 5 ), QPoint(INT_MIN/2, 4 ) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1, 5 ), QPoint(0, 4 ) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(5+(INT_MAX/2-4), 5 ), QPoint(INT_MAX/2, 4 ) );
-	// QTest::newRow( "NullQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(4954, 5 ), QPoint(4953, 4 ) );
+        // QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(5+(INT_MIN/2-4), 5 ), QPoint(INT_MIN/2, 4 ) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1, 5 ), QPoint(0, 4 ) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(5+(INT_MAX/2-4), 5 ), QPoint(INT_MAX/2, 4 ) );
+        // QTest::newRow( "NullQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(4954, 5 ), QPoint(4953, 4 ) );
     }
 
     {
-	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
-						       << QRect( QPoint(INT_MIN+1,2 ), QPoint(INT_MIN, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(INT_MIN/2+1, 2 ), QPoint(INT_MIN/2, 1 ) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,2 ), QPoint(0, 1 ) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(INT_MAX/2+1,2 ), QPoint(INT_MAX/2, 1 ) );
-	// QTest::newRow( "EmptyQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint( 4954, 2 ), QPoint(4953, 1 ) );
+        QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
+                                                       << QRect( QPoint(INT_MIN+1,2 ), QPoint(INT_MIN, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(INT_MIN/2+1, 2 ), QPoint(INT_MIN/2, 1 ) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,2 ), QPoint(0, 1 ) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(INT_MAX/2+1,2 ), QPoint(INT_MAX/2, 1 ) );
+        // QTest::newRow( "EmptyQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint( 4954, 2 ), QPoint(4953, 1 ) );
     }
 }
 
@@ -3079,139 +3079,139 @@ void tst_QRect::newMoveBottom_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	// QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(0,INT_MIN/2+1), QPoint(-1,INT_MIN/2) );
-	QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,1), QPoint(-1,0) );
-	QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,INT_MAX/2+1), QPoint(-1,INT_MAX/2) );
-	// QTest::newRow( "InvalidQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,4954), QPoint(-1,4953) );
+        // QTest::newRow( "InvalidQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "InvalidQRect_MiddleNegativeInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(0,INT_MIN/2+1), QPoint(-1,INT_MIN/2) );
+        QTest::newRow( "InvalidQRect_ZeroInt" ) << getQRectCase( InvalidQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,1), QPoint(-1,0) );
+        QTest::newRow( "InvalidQRect_MiddlePositiveInt" ) << getQRectCase( InvalidQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,INT_MAX/2+1), QPoint(-1,INT_MAX/2) );
+        // QTest::newRow( "InvalidQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "InvalidQRect_RandomInt" ) << getQRectCase( InvalidQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,4954), QPoint(-1,4953) );
     }
 
     {
-	QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
-						 << QRect( QPoint(1,INT_MIN), QPoint(1,INT_MIN) );
-	QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,INT_MIN/2), QPoint(1,INT_MIN/2) );
-	QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,0), QPoint(1,0) );
-	QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(1,INT_MAX/2), QPoint(1,INT_MAX/2) );
-	QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
-						<< QRect( QPoint(1,INT_MAX), QPoint(1,INT_MAX) );
-	QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,4953), QPoint(1,4953) );
+        QTest::newRow( "SmallestQRect_MinimumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MinimumInt )
+                                                 << QRect( QPoint(1,INT_MIN), QPoint(1,INT_MIN) );
+        QTest::newRow( "SmallestQRect_MiddleNegativeInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,INT_MIN/2), QPoint(1,INT_MIN/2) );
+        QTest::newRow( "SmallestQRect_ZeroInt" ) << getQRectCase( SmallestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,0), QPoint(1,0) );
+        QTest::newRow( "SmallestQRect_MiddlePositiveInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(1,INT_MAX/2), QPoint(1,INT_MAX/2) );
+        QTest::newRow( "SmallestQRect_MaximumInt" ) << getQRectCase( SmallestQRect ) << getIntCase( MaximumInt )
+                                                << QRect( QPoint(1,INT_MAX), QPoint(1,INT_MAX) );
+        QTest::newRow( "SmallestQRect_RandomInt" ) << getQRectCase( SmallestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,4953), QPoint(1,4953) );
     }
 
     {
-	// QTest::newRow( "MiddleQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(INT_MIN/2,INT_MIN/2+(0-INT_MAX/2)), QPoint(INT_MAX/2,0));
-	QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
-						      << QRect(QPoint(INT_MIN/2,INT_MIN/2+(INT_MAX/2-INT_MAX/2)),QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
-	       				       << QRect(QPoint(INT_MIN/2,INT_MIN/2+(INT_MAX-INT_MAX/2)),QPoint(INT_MAX/2,INT_MAX));
-	QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
-					      << QRect(QPoint(INT_MIN/2,INT_MIN/2+(4953-INT_MAX/2)),QPoint(INT_MAX/2,4953));
-    }
-
-    {
-	// QTest::newRow( "LargestQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "LargestQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(0,0-(INT_MAX-1)), QPoint(INT_MAX - 1,0 ) );
-	QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(0,INT_MAX/2-(INT_MAX-1)), QPoint(INT_MAX - 1,INT_MAX/2 ) );
-	QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
-			       		        << QRect( QPoint(0,INT_MAX-(INT_MAX-1)), QPoint(INT_MAX - 1,INT_MAX) );
-	QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(0,4953-(INT_MAX-1)), QPoint(INT_MAX - 1,4953) );
-    }
-
-    {
-	QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
-						       << QRect(QPoint(INT_MIN,INT_MIN+(INT_MIN-INT_MIN)), QPoint(INT_MIN,INT_MIN) );
-	QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect(QPoint(INT_MIN,INT_MIN+(INT_MIN/2-INT_MIN)), QPoint(INT_MIN,INT_MIN/2) );
-	// QTest::newRow( "SmallestCoordQRect_ZeroInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "SmallestCoordQRect_MaximumInt" ) -- Not tested as it would cause an overflow
-	// QTest::newRow( "SmallestCoordQRect_RandomInt" ) -- Not tested as it would cause an overflow
-    }
-
-    {
-	 // LargestQRect cases -- Not tested as it would cause an overflow
-    }
-
-    {
-	// QTest::newRow( "RandomQRect_MinimumInt" ) -- Not tested as it would cause an overflow
-	QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(100,200+(INT_MIN/2-215)), QPoint(110,INT_MIN/2) );
-	QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(100,-15), QPoint(110,0) );
-	QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(100,200+(INT_MAX/2-215)), QPoint(110,INT_MAX/2) );
-	QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
-						       << QRect( QPoint(100,200+(INT_MAX-215)), QPoint(110,INT_MAX) );
-	QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(100,4938), QPoint(110,4953) );
-    }
-
-    {
-	QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
-						       << QRect( QPoint(1,1+(INT_MIN-(-10))), QPoint(-10,INT_MIN));
-	QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(1,1+(INT_MIN/2-(-10))), QPoint(-10,INT_MIN/2));
-	QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(1,11), QPoint(-10,0) );
-	// QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) -- Not tested as this would cause an overflow
-	// QTest::newRow( "NegativeSizeQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(1,4964), QPoint(-10,4953) );
-    }
-
-    {
-	// QTest::newRow( "NegativePointQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(-10,(-10)+(INT_MIN/2-(-6))), QPoint(-6,INT_MIN/2) );
-	QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(-10,-4), QPoint(-6,0) );
-	QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(-10,(-10)+(INT_MAX/2-(-6))), QPoint(-6,INT_MAX/2) );
-	// QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(-10,4949), QPoint(-6,4953) );
-    }
+        // QTest::newRow( "MiddleQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "MiddleQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "MiddleQRect_ZeroInt" ) << getQRectCase( MiddleQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(INT_MIN/2,INT_MIN/2+(0-INT_MAX/2)), QPoint(INT_MAX/2,0));
+        QTest::newRow( "MiddleQRect_MiddlePositiveInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MiddlePositiveInt )
+                                                      << QRect(QPoint(INT_MIN/2,INT_MIN/2+(INT_MAX/2-INT_MAX/2)),QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow( "MiddleQRect_MaximumInt" ) << getQRectCase( MiddleQRect ) << getIntCase( MaximumInt )
+                                                      << QRect(QPoint(INT_MIN/2,INT_MIN/2+(INT_MAX-INT_MAX/2)),QPoint(INT_MAX/2,INT_MAX));
+        QTest::newRow( "MiddleQRect_RandomInt" ) << getQRectCase( MiddleQRect ) << getIntCase( RandomInt )
+                                              << QRect(QPoint(INT_MIN/2,INT_MIN/2+(4953-INT_MAX/2)),QPoint(INT_MAX/2,4953));
+    }
+
+    {
+        // QTest::newRow( "LargestQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "LargestQRect_MiddleNegativeInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "LargestQRect_ZeroInt" ) << getQRectCase( LargestQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(0,0-(INT_MAX-1)), QPoint(INT_MAX - 1,0 ) );
+        QTest::newRow( "LargestQRect_MiddlePositiveInt" ) << getQRectCase( LargestQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(0,INT_MAX/2-(INT_MAX-1)), QPoint(INT_MAX - 1,INT_MAX/2 ) );
+        QTest::newRow( "LargestQRect_MaximumInt" ) << getQRectCase( LargestQRect ) << getIntCase( MaximumInt )
+                                                       << QRect( QPoint(0,INT_MAX-(INT_MAX-1)), QPoint(INT_MAX - 1,INT_MAX) );
+        QTest::newRow( "LargestQRect_RandomInt" ) << getQRectCase( LargestQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(0,4953-(INT_MAX-1)), QPoint(INT_MAX - 1,4953) );
+    }
+
+    {
+        QTest::newRow( "SmallestCoordQRect_MinimumInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MinimumInt )
+                                                       << QRect(QPoint(INT_MIN,INT_MIN+(INT_MIN-INT_MIN)), QPoint(INT_MIN,INT_MIN) );
+        QTest::newRow( "SmallestCoordQRect_MiddleNegativeInt" ) << getQRectCase( SmallestCoordQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect(QPoint(INT_MIN,INT_MIN+(INT_MIN/2-INT_MIN)), QPoint(INT_MIN,INT_MIN/2) );
+        // QTest::newRow( "SmallestCoordQRect_ZeroInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "SmallestCoordQRect_MiddlePositiveInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "SmallestCoordQRect_MaximumInt" ) -- Not tested as it would cause an overflow
+        // QTest::newRow( "SmallestCoordQRect_RandomInt" ) -- Not tested as it would cause an overflow
+    }
+
+    {
+         // LargestQRect cases -- Not tested as it would cause an overflow
+    }
+
+    {
+        // QTest::newRow( "RandomQRect_MinimumInt" ) -- Not tested as it would cause an overflow
+        QTest::newRow( "RandomQRect_MiddleNegativeInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(100,200+(INT_MIN/2-215)), QPoint(110,INT_MIN/2) );
+        QTest::newRow( "RandomQRect_ZeroInt" ) << getQRectCase( RandomQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(100,-15), QPoint(110,0) );
+        QTest::newRow( "RandomQRect_MiddlePositiveInt" ) << getQRectCase( RandomQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(100,200+(INT_MAX/2-215)), QPoint(110,INT_MAX/2) );
+        QTest::newRow( "RandomQRect_MaximumInt" ) << getQRectCase( RandomQRect ) << getIntCase( MaximumInt )
+                                                       << QRect( QPoint(100,200+(INT_MAX-215)), QPoint(110,INT_MAX) );
+        QTest::newRow( "RandomQRect_RandomInt" ) << getQRectCase( RandomQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(100,4938), QPoint(110,4953) );
+    }
+
+    {
+        QTest::newRow( "NegativeSizeQRect_MinimumInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MinimumInt )
+                                                       << QRect( QPoint(1,1+(INT_MIN-(-10))), QPoint(-10,INT_MIN));
+        QTest::newRow( "NegativeSizeQRect_MiddleNegativeInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(1,1+(INT_MIN/2-(-10))), QPoint(-10,INT_MIN/2));
+        QTest::newRow( "NegativeSizeQRect_ZeroInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(1,11), QPoint(-10,0) );
+        // QTest::newRow( "NegativeSizeQRect_MiddlePositiveInt" ) -- Not tested as this would cause an overflow
+        // QTest::newRow( "NegativeSizeQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativeSizeQRect_RandomInt" ) << getQRectCase( NegativeSizeQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(1,4964), QPoint(-10,4953) );
+    }
+
+    {
+        // QTest::newRow( "NegativePointQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativePointQRect_MiddleNegativeInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(-10,(-10)+(INT_MIN/2-(-6))), QPoint(-6,INT_MIN/2) );
+        QTest::newRow( "NegativePointQRect_ZeroInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(-10,-4), QPoint(-6,0) );
+        QTest::newRow( "NegativePointQRect_MiddlePositiveInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(-10,(-10)+(INT_MAX/2-(-6))), QPoint(-6,INT_MAX/2) );
+        // QTest::newRow( "NegativePointQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NegativePointQRect_RandomInt" ) << getQRectCase( NegativePointQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(-10,4949), QPoint(-6,4953) );
+    }
 
     {
-	// QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(5,5+(INT_MIN/2-4)), QPoint(4,INT_MIN/2) );
-	QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(5,1), QPoint(4,0) );
-	QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(5,5+(INT_MAX/2-4)), QPoint(4,INT_MAX/2) );
-	// QTest::newRow( "NullQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(5,4954), QPoint(4,4953) );
+        // QTest::newRow( "NullQRect_MinimumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NullQRect_MiddleNegativeInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(5,5+(INT_MIN/2-4)), QPoint(4,INT_MIN/2) );
+        QTest::newRow( "NullQRect_ZeroInt" ) << getQRectCase( NullQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(5,1), QPoint(4,0) );
+        QTest::newRow( "NullQRect_MiddlePositiveInt" ) << getQRectCase( NullQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(5,5+(INT_MAX/2-4)), QPoint(4,INT_MAX/2) );
+        // QTest::newRow( "NullQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "NullQRect_RandomInt" ) << getQRectCase( NullQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(5,4954), QPoint(4,4953) );
     }
 
     {
-	QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
-						       << QRect( QPoint(2,INT_MIN+1), QPoint(1,INT_MIN) );
-	QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
-						       << QRect( QPoint(2,INT_MIN/2+1), QPoint(1,INT_MIN/2) );
-	QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
-					     << QRect( QPoint(2,1), QPoint(1,0) );
-	QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
-						       << QRect( QPoint(2,INT_MAX/2+1), QPoint(1,INT_MAX/2) );
-	// QTest::newRow( "EmptyQRect_MaximumInt" ) -- Not tested as this would cause an overflow
-	QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
-					       << QRect( QPoint(2,4954), QPoint(1,4953) );
+        QTest::newRow( "EmptyQRect_MinimumInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MinimumInt )
+                                                       << QRect( QPoint(2,INT_MIN+1), QPoint(1,INT_MIN) );
+        QTest::newRow( "EmptyQRect_MiddleNegativeInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddleNegativeInt )
+                                                       << QRect( QPoint(2,INT_MIN/2+1), QPoint(1,INT_MIN/2) );
+        QTest::newRow( "EmptyQRect_ZeroInt" ) << getQRectCase( EmptyQRect ) << getIntCase( ZeroInt )
+                                             << QRect( QPoint(2,1), QPoint(1,0) );
+        QTest::newRow( "EmptyQRect_MiddlePositiveInt" ) << getQRectCase( EmptyQRect ) << getIntCase( MiddlePositiveInt )
+                                                       << QRect( QPoint(2,INT_MAX/2+1), QPoint(1,INT_MAX/2) );
+        // QTest::newRow( "EmptyQRect_MaximumInt" ) -- Not tested as this would cause an overflow
+        QTest::newRow( "EmptyQRect_RandomInt" ) << getQRectCase( EmptyQRect ) << getIntCase( RandomInt )
+                                               << QRect( QPoint(2,4954), QPoint(1,4953) );
     }
 }
 
@@ -3233,181 +3233,181 @@ void tst_QRect::newMoveTopLeft_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-1,-1));
-	// QTest::newRow("InvalidQRect_SmallestCoordQPoint") -- Not tested as this would cause an overflow
-	QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-1+(INT_MIN/2-0),-1+(INT_MIN/2-0)));
-	QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-1+(INT_MAX/2-0),-1+(INT_MAX/2-0)));
-	QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-1+(INT_MAX-0),-1+(INT_MAX-0)));
-	QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-13,6));
-	QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(11,-8));
-	QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(11,6));
-    }
-
-    {
-	QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(0,0));
-	QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-12,7));
-	QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(12,-7));
-	QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX/2+(0-INT_MIN/2),INT_MAX/2+(0-INT_MIN/2)));
-	QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2+(INT_MIN-INT_MIN/2),INT_MAX/2+(INT_MIN-INT_MIN/2)));
-	QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX/2,INT_MAX/2));
-	// QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("MiddleQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("MiddleQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("MiddleQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("MiddleQRect_RandomQPoint") -- Not tested as it would cause an overflow
-    }
-
-    {
-	QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX-1+INT_MIN,INT_MAX-1+INT_MIN));
-	// QTest::newRow("LargestQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_RandomQPoint") -- Not tested as it would cause an overflow
-    }
-
-    {
-	// QTest::newRow("SmallestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN+(INT_MIN/2-INT_MIN),INT_MIN+(INT_MIN/2-INT_MIN)));
-	// QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
-    }
-
-    {
-	QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(INT_MAX+(0-INT_MIN),INT_MAX+(0-INT_MIN)));
-	QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
-	// QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
-    }
-
-    {
-	QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(10,15));
-	// QTest::newRow("RandomQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(110+(INT_MIN/2-100),215+(INT_MIN/2-200)));
-	QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(110+(INT_MAX/2-100),215+(INT_MAX/2-200)));
-	// QTest::newRow("RandomQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-2,22));
-	QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(22,8));
-	QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(22,22));
-    }
-
-    {
-	QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-11,-11));
-	// QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-10+((INT_MIN/2)-1),-10+((INT_MIN/2)-1)));
-	QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-10+((INT_MAX/2)-1),-10+((INT_MAX/2)-1)));
-	// QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-23,-4));
-	QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(1,-18));
-	QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(1,-4));
-    }
-
-    {
-	QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(4,4));
-	QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN+4,INT_MIN+4));
-	QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint((INT_MIN/2)+4,(INT_MIN/2)+4));
-	QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint((INT_MAX/2)+4,(INT_MAX/2)+4));
-	// QTest::newRow("NegativePointQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-8,11));
-	QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(16,-3));
-	QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(16,11));
-    }
-
-    {
-	QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-1,-1));
-	// QTest::newRow("NullQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint((INT_MIN/2)-1,(INT_MIN/2)-1));
-	QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint((INT_MAX/2)-1,(INT_MAX/2)-1));
-	QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-13,6));
-	QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(11,-8));
-	QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(11,6));
-    }
-
-    {
-	QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0,0), QPoint(-1,-1));
-	// QTest::newRow("EmptyQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint((INT_MIN/2)-1,(INT_MIN/2)-1));
-	QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint((INT_MAX/2)-1,(INT_MAX/2)-1));
-	QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX-1,INT_MAX-1));
-	QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(-12,7), QPoint(-13,6));
-	QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(12,-7), QPoint(11,-8));
-	QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(12,7), QPoint(11,6));
+        QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-1,-1));
+        // QTest::newRow("InvalidQRect_SmallestCoordQPoint") -- Not tested as this would cause an overflow
+        QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-1+(INT_MIN/2-0),-1+(INT_MIN/2-0)));
+        QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-1+(INT_MAX/2-0),-1+(INT_MAX/2-0)));
+        QTest::newRow("InvalidQRect_LargestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(-1+(INT_MAX-0),-1+(INT_MAX-0)));
+        QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-13,6));
+        QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(11,-8));
+        QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(11,6));
+    }
+
+    {
+        QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(0,0));
+        QTest::newRow("SmallestQRect_SmallestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-12,7));
+        QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(12,-7));
+        QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX/2+(0-INT_MIN/2),INT_MAX/2+(0-INT_MIN/2)));
+        QTest::newRow("MiddleQRect_SmallestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX/2+(INT_MIN-INT_MIN/2),INT_MAX/2+(INT_MIN-INT_MIN/2)));
+        QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MAX/2,INT_MAX/2));
+        // QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("MiddleQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("MiddleQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("MiddleQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("MiddleQRect_RandomQPoint") -- Not tested as it would cause an overflow
+    }
+
+    {
+        QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("LargestQRect_SmallestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX-1+INT_MIN,INT_MAX-1+INT_MIN));
+        // QTest::newRow("LargestQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_RandomQPoint") -- Not tested as it would cause an overflow
+    }
+
+    {
+        // QTest::newRow("SmallestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(INT_MIN+(INT_MIN/2-INT_MIN),INT_MIN+(INT_MIN/2-INT_MIN)));
+        // QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
+    }
+
+    {
+        QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(INT_MAX+(0-INT_MIN),INT_MAX+(0-INT_MIN)));
+        QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
+        // QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
+    }
+
+    {
+        QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(10,15));
+        // QTest::newRow("RandomQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(110+(INT_MIN/2-100),215+(INT_MIN/2-200)));
+        QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(110+(INT_MAX/2-100),215+(INT_MAX/2-200)));
+        // QTest::newRow("RandomQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-2,22));
+        QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(22,8));
+        QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(22,22));
+    }
+
+    {
+        QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-11,-11));
+        // QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint(-10+((INT_MIN/2)-1),-10+((INT_MIN/2)-1)));
+        QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint(-10+((INT_MAX/2)-1),-10+((INT_MAX/2)-1)));
+        // QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-23,-4));
+        QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(1,-18));
+        QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(1,-4));
+    }
+
+    {
+        QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(4,4));
+        QTest::newRow("NegativePointQRect_SmallestCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MIN+4,INT_MIN+4));
+        QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint((INT_MIN/2)+4,(INT_MIN/2)+4));
+        QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint((INT_MAX/2)+4,(INT_MAX/2)+4));
+        // QTest::newRow("NegativePointQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-8,11));
+        QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(16,-3));
+        QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(16,11));
+    }
+
+    {
+        QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-1,-1));
+        // QTest::newRow("NullQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint((INT_MIN/2)-1,(INT_MIN/2)-1));
+        QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint((INT_MAX/2)-1,(INT_MAX/2)-1));
+        QTest::newRow("NullQRect_LargestCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-13,6));
+        QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(11,-8));
+        QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(11,6));
+    }
+
+    {
+        QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0,0), QPoint(-1,-1));
+        // QTest::newRow("EmptyQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN/2,INT_MIN/2), QPoint((INT_MIN/2)-1,(INT_MIN/2)-1));
+        QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MAX/2,INT_MAX/2), QPoint((INT_MAX/2)-1,(INT_MAX/2)-1));
+        QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MAX,INT_MAX), QPoint(INT_MAX-1,INT_MAX-1));
+        QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(-12,7), QPoint(-13,6));
+        QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(12,-7), QPoint(11,-8));
+        QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(12,7), QPoint(11,6));
     }
 }
 
@@ -3429,181 +3429,181 @@ void tst_QRect::newMoveBottomRight_data()
     QTest::addColumn<QRect>("nr");
 
     {
-	QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0+(0-(-1)),0+(0-(-1))), QPoint(0,0));
-	QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(0+(INT_MIN-(-1)),0+(INT_MIN-(-1))), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(0+((INT_MIN/2)-(-1)),0+((INT_MIN/2)-(-1))), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(0+((INT_MAX/2)-(-1)),0+((INT_MAX/2)-(-1))), QPoint(INT_MAX/2,INT_MAX/2));
-	// QTest::newRow("InvalidQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(0+(-12-(-1)),0+(7-(-1))), QPoint(-12,7));
-	QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(0+(12-(-1)),0+(-7-(-1))), QPoint(12,-7));
-	QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(0+(12-(-1)),0+(7-(-1))), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(1+(0-1),1+(0-1)), QPoint(0,0));
-	// QTest::newRow("SmallestQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(1+((INT_MIN/2)-1),1+((INT_MIN/2)-1)), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(1+((INT_MAX/2)-1),1+((INT_MAX/2)-1)), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(1+(INT_MAX-1),1+(INT_MAX-1)), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(1+(-12-1),1+(7-1)), QPoint(-12,7));
-	QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(1+(12-1),1+(-7-1)), QPoint(12,-7));
-	QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(1+(12-1),1+(7-1)), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(INT_MIN/2+(0-(INT_MAX/2)),INT_MIN/2+(0-(INT_MAX/2))), QPoint(0,0));
-	// QTest::newRow("MiddleQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2+((INT_MAX/2)-(INT_MAX/2)),INT_MIN/2+((INT_MAX/2)-(INT_MAX/2))), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN/2+(INT_MAX-(INT_MAX/2)),INT_MIN/2+(INT_MAX-(INT_MAX/2))), QPoint(INT_MAX,INT_MAX));
-	// QTest::newRow("MiddleQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("MiddleQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(INT_MIN/2+(12-(INT_MAX/2)),INT_MIN/2+(7-(INT_MAX/2))), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(0+(0-(INT_MAX-1)),0+(0-(INT_MAX-1))), QPoint(0,0));
-	// QTest::newRow("LargestQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(0+((INT_MAX/2)-(INT_MAX-1)),0+((INT_MAX/2)-(INT_MAX-1))), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(0+(INT_MAX-(INT_MAX-1)),0+(INT_MAX-(INT_MAX-1))), QPoint(INT_MAX,INT_MAX));
-	// QTest::newRow("LargestQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(0+(12-(INT_MAX-1)),0+(7-(INT_MAX-1))), QPoint(12,7));
-    }
-
-    {
-	// QTest::newRow("SmallestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(INT_MIN+(INT_MIN-INT_MIN),INT_MIN+(INT_MIN-INT_MIN)), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(INT_MIN+((INT_MIN/2)-INT_MIN),INT_MIN+((INT_MIN/2)-INT_MIN)), QPoint(INT_MIN/2,INT_MIN/2));
-	// QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("SmallestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
-    }
-
-    {
-	// QTest::newRow("LargestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(INT_MIN+(INT_MAX-INT_MAX),INT_MIN+(INT_MAX-INT_MAX)), QPoint(INT_MAX,INT_MAX));
-	// QTest::newRow("LargestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
-	// QTest::newRow("LargestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
-    }
-
-    {
-	QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(100+(0-110),200+(0-215)), QPoint(0,0));
-	// QTest::newRow("RandomQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(100+((INT_MIN/2)-110),200+((INT_MIN/2)-215)), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(100+((INT_MAX/2)-110),200+((INT_MAX/2)-215)), QPoint(INT_MAX/2,INT_MAX/2));
-	QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
-	    << QRect(QPoint(100+(INT_MAX-110),200+(INT_MAX-215)), QPoint(INT_MAX,INT_MAX));
-	QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(100+(-12-110),200+(7-215)), QPoint(-12,7));
-	QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(100+(12-110),200+(-7-215)), QPoint(12,-7));
-	QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(100+(12-110),200+(7-215)), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(1+(0-(-10)),1+(0-(-10))), QPoint(0,0));
-	QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
-	    << QRect(QPoint(1+(INT_MIN-(-10)),1+(INT_MIN-(-10))), QPoint(INT_MIN,INT_MIN));
-	QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(1+((INT_MIN/2)-(-10)),1+((INT_MIN/2)-(-10))), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(1+((INT_MAX/2)-(-10)),1+((INT_MAX/2)-(-10))), QPoint(INT_MAX/2,INT_MAX/2));
-	// QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(1+(-12-(-10)),1+(7-(-10))), QPoint(-12,7));
-	QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(1+(12-(-10)),1+(-7-(-10))), QPoint(12,-7));
-	QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(1+(12-(-10)),1+(7-(-10))), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint((-10)+(0-(-6)),(-10)+(0-(-6))), QPoint(0,0));
-	//  QTest::newRow("NegativePointQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint((-10)+((INT_MIN/2)-(-6)),(-10)+((INT_MIN/2)-(-6))), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint((-10)+((INT_MAX/2)-(-6)),(-10)+((INT_MAX/2)-(-6))), QPoint(INT_MAX/2,INT_MAX/2));
-	// QTest::newRow("NegativePointQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint((-10)+(-12-(-6)),(-10)+(7-(-6))), QPoint(-12,7));
-	QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint((-10)+(12-(-6)),(-10)+(-7-(-6))), QPoint(12,-7));
-	QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint((-10)+(12-(-6)),(-10)+(7-(-6))), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(5+(0-4),5+(0-4)), QPoint(0,0));
-	// QTest::newRow("NullQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(5+((INT_MIN/2)-4),5+((INT_MIN/2)-4)), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(5+((INT_MAX/2)-4),5+((INT_MAX/2)-4)), QPoint(INT_MAX/2,INT_MAX/2));
-	// QTest::newRow("NullQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(5+(-12-4),5+(7-4)), QPoint(-12,7));
-	QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(5+(12-4),5+(-7-4)), QPoint(12,-7));
-	QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(5+(12-4),5+(7-4)), QPoint(12,7));
-    }
-
-    {
-	QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
-	    << QRect(QPoint(2+(0-1),2+(0-1)), QPoint(0,0));
-	// QTest::newRow("EmptyQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
-	QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
-	    << QRect(QPoint(2+((INT_MIN/2)-1),2+((INT_MIN/2)-1)), QPoint(INT_MIN/2,INT_MIN/2));
-	QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
-	    << QRect(QPoint(2+((INT_MAX/2)-1),2+((INT_MAX/2)-1)), QPoint(INT_MAX/2,INT_MAX/2));
-	// QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) -- Not tested as it would cause an overflow
-	QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
-	    << QRect(QPoint(2+(-12-1),2+(7-1)), QPoint(-12,7));
-	QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
-	    << QRect(QPoint(2+(12-1),2+(-7-1)), QPoint(12,-7));
-	QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
-	    << QRect(QPoint(2+(12-1),2+(7-1)), QPoint(12,7));
+        QTest::newRow("InvalidQRect_NullQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0+(0-(-1)),0+(0-(-1))), QPoint(0,0));
+        QTest::newRow("InvalidQRect_SmallestCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(0+(INT_MIN-(-1)),0+(INT_MIN-(-1))), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("InvalidQRect_MiddleNegCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(0+((INT_MIN/2)-(-1)),0+((INT_MIN/2)-(-1))), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("InvalidQRect_MiddlePosCoordQPoint") << getQRectCase(InvalidQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(0+((INT_MAX/2)-(-1)),0+((INT_MAX/2)-(-1))), QPoint(INT_MAX/2,INT_MAX/2));
+        // QTest::newRow("InvalidQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("InvalidQRect_NegXQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(0+(-12-(-1)),0+(7-(-1))), QPoint(-12,7));
+        QTest::newRow("InvalidQRect_NegYQPoint") << getQRectCase(InvalidQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(0+(12-(-1)),0+(-7-(-1))), QPoint(12,-7));
+        QTest::newRow("InvalidQRect_RandomQPoint") << getQRectCase(InvalidQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(0+(12-(-1)),0+(7-(-1))), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("SmallestQRect_NullQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(1+(0-1),1+(0-1)), QPoint(0,0));
+        // QTest::newRow("SmallestQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("SmallestQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(1+((INT_MIN/2)-1),1+((INT_MIN/2)-1)), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("SmallestQRect_MiddlePosCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(1+((INT_MAX/2)-1),1+((INT_MAX/2)-1)), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("SmallestQRect_LargestCoordQPoint") << getQRectCase(SmallestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(1+(INT_MAX-1),1+(INT_MAX-1)), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("SmallestQRect_NegXQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(1+(-12-1),1+(7-1)), QPoint(-12,7));
+        QTest::newRow("SmallestQRect_NegYQPoint") << getQRectCase(SmallestQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(1+(12-1),1+(-7-1)), QPoint(12,-7));
+        QTest::newRow("SmallestQRect_RandomQPoint") << getQRectCase(SmallestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(1+(12-1),1+(7-1)), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("MiddleQRect_NullQPoint") << getQRectCase(MiddleQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(INT_MIN/2+(0-(INT_MAX/2)),INT_MIN/2+(0-(INT_MAX/2))), QPoint(0,0));
+        // QTest::newRow("MiddleQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("MiddleQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("MiddleQRect_MiddlePosCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(INT_MIN/2+((INT_MAX/2)-(INT_MAX/2)),INT_MIN/2+((INT_MAX/2)-(INT_MAX/2))), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("MiddleQRect_LargestCoordQPoint") << getQRectCase(MiddleQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN/2+(INT_MAX-(INT_MAX/2)),INT_MIN/2+(INT_MAX-(INT_MAX/2))), QPoint(INT_MAX,INT_MAX));
+        // QTest::newRow("MiddleQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("MiddleQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("MiddleQRect_RandomQPoint") << getQRectCase(MiddleQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(INT_MIN/2+(12-(INT_MAX/2)),INT_MIN/2+(7-(INT_MAX/2))), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("LargestQRect_NullQPoint") << getQRectCase(LargestQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(0+(0-(INT_MAX-1)),0+(0-(INT_MAX-1))), QPoint(0,0));
+        // QTest::newRow("LargestQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("LargestQRect_MiddlePosCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(0+((INT_MAX/2)-(INT_MAX-1)),0+((INT_MAX/2)-(INT_MAX-1))), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("LargestQRect_LargestCoordQPoint") << getQRectCase(LargestQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(0+(INT_MAX-(INT_MAX-1)),0+(INT_MAX-(INT_MAX-1))), QPoint(INT_MAX,INT_MAX));
+        // QTest::newRow("LargestQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("LargestQRect_RandomQPoint") << getQRectCase(LargestQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(0+(12-(INT_MAX-1)),0+(7-(INT_MAX-1))), QPoint(12,7));
+    }
+
+    {
+        // QTest::newRow("SmallestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("SmallestCoordQRect_SmallestCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(INT_MIN+(INT_MIN-INT_MIN),INT_MIN+(INT_MIN-INT_MIN)), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("SmallestCoordQRect_MiddleNegCoordQPoint") << getQRectCase(SmallestCoordQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(INT_MIN+((INT_MIN/2)-INT_MIN),INT_MIN+((INT_MIN/2)-INT_MIN)), QPoint(INT_MIN/2,INT_MIN/2));
+        // QTest::newRow("SmallestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("SmallestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
+    }
+
+    {
+        // QTest::newRow("LargestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_MiddlePosCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("LargestCoordQRect_LargestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(INT_MIN+(INT_MAX-INT_MAX),INT_MIN+(INT_MAX-INT_MAX)), QPoint(INT_MAX,INT_MAX));
+        // QTest::newRow("LargestCoordQRect_NegXQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_NegYQPoint") -- Not tested as it would cause an overflow
+        // QTest::newRow("LargestCoordQRect_RandomQPoint") -- Not tested as it would cause an overflow
+    }
+
+    {
+        QTest::newRow("RandomQRect_NullQPoint") << getQRectCase(RandomQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(100+(0-110),200+(0-215)), QPoint(0,0));
+        // QTest::newRow("RandomQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("RandomQRect_MiddleNegCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(100+((INT_MIN/2)-110),200+((INT_MIN/2)-215)), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("RandomQRect_MiddlePosCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(100+((INT_MAX/2)-110),200+((INT_MAX/2)-215)), QPoint(INT_MAX/2,INT_MAX/2));
+        QTest::newRow("RandomQRect_LargestCoordQPoint") << getQRectCase(RandomQRect) << getQPointCase(LargestCoordQPoint)
+            << QRect(QPoint(100+(INT_MAX-110),200+(INT_MAX-215)), QPoint(INT_MAX,INT_MAX));
+        QTest::newRow("RandomQRect_NegXQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(100+(-12-110),200+(7-215)), QPoint(-12,7));
+        QTest::newRow("RandomQRect_NegYQPoint") << getQRectCase(RandomQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(100+(12-110),200+(-7-215)), QPoint(12,-7));
+        QTest::newRow("RandomQRect_RandomQPoint") << getQRectCase(RandomQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(100+(12-110),200+(7-215)), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("NegativeSizeQRect_NullQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(1+(0-(-10)),1+(0-(-10))), QPoint(0,0));
+        QTest::newRow("NegativeSizeQRect_SmallestCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(SmallestCoordQPoint)
+            << QRect(QPoint(1+(INT_MIN-(-10)),1+(INT_MIN-(-10))), QPoint(INT_MIN,INT_MIN));
+        QTest::newRow("NegativeSizeQRect_MiddleNegCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(1+((INT_MIN/2)-(-10)),1+((INT_MIN/2)-(-10))), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("NegativeSizeQRect_MiddlePosCoordQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(1+((INT_MAX/2)-(-10)),1+((INT_MAX/2)-(-10))), QPoint(INT_MAX/2,INT_MAX/2));
+        // QTest::newRow("NegativeSizeQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NegativeSizeQRect_NegXQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(1+(-12-(-10)),1+(7-(-10))), QPoint(-12,7));
+        QTest::newRow("NegativeSizeQRect_NegYQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(1+(12-(-10)),1+(-7-(-10))), QPoint(12,-7));
+        QTest::newRow("NegativeSizeQRect_RandomQPoint") << getQRectCase(NegativeSizeQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(1+(12-(-10)),1+(7-(-10))), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("NegativePointQRect_NullQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint((-10)+(0-(-6)),(-10)+(0-(-6))), QPoint(0,0));
+        //  QTest::newRow("NegativePointQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NegativePointQRect_MiddleNegCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint((-10)+((INT_MIN/2)-(-6)),(-10)+((INT_MIN/2)-(-6))), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("NegativePointQRect_MiddlePosCoordQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint((-10)+((INT_MAX/2)-(-6)),(-10)+((INT_MAX/2)-(-6))), QPoint(INT_MAX/2,INT_MAX/2));
+        // QTest::newRow("NegativePointQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NegativePointQRect_NegXQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint((-10)+(-12-(-6)),(-10)+(7-(-6))), QPoint(-12,7));
+        QTest::newRow("NegativePointQRect_NegYQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint((-10)+(12-(-6)),(-10)+(-7-(-6))), QPoint(12,-7));
+        QTest::newRow("NegativePointQRect_RandomQPoint") << getQRectCase(NegativePointQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint((-10)+(12-(-6)),(-10)+(7-(-6))), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("NullQRect_NullQPoint") << getQRectCase(NullQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(5+(0-4),5+(0-4)), QPoint(0,0));
+        // QTest::newRow("NullQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NullQRect_MiddleNegCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(5+((INT_MIN/2)-4),5+((INT_MIN/2)-4)), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("NullQRect_MiddlePosCoordQPoint") << getQRectCase(NullQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(5+((INT_MAX/2)-4),5+((INT_MAX/2)-4)), QPoint(INT_MAX/2,INT_MAX/2));
+        // QTest::newRow("NullQRect_LargestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("NullQRect_NegXQPoint") << getQRectCase(NullQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(5+(-12-4),5+(7-4)), QPoint(-12,7));
+        QTest::newRow("NullQRect_NegYQPoint") << getQRectCase(NullQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(5+(12-4),5+(-7-4)), QPoint(12,-7));
+        QTest::newRow("NullQRect_RandomQPoint") << getQRectCase(NullQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(5+(12-4),5+(7-4)), QPoint(12,7));
+    }
+
+    {
+        QTest::newRow("EmptyQRect_NullQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NullQPoint)
+            << QRect(QPoint(2+(0-1),2+(0-1)), QPoint(0,0));
+        // QTest::newRow("EmptyQRect_SmallestCoordQPoint") -- Not tested as it would cause an overflow
+        QTest::newRow("EmptyQRect_MiddleNegCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddleNegCoordQPoint)
+            << QRect(QPoint(2+((INT_MIN/2)-1),2+((INT_MIN/2)-1)), QPoint(INT_MIN/2,INT_MIN/2));
+        QTest::newRow("EmptyQRect_MiddlePosCoordQPoint") << getQRectCase(EmptyQRect) << getQPointCase(MiddlePosCoordQPoint)
+            << QRect(QPoint(2+((INT_MAX/2)-1),2+((INT_MAX/2)-1)), QPoint(INT_MAX/2,INT_MAX/2));
+        // QTest::newRow("EmptyQRect_LargestCoordQPoint") << getQRectCase(EmptyQRect) -- Not tested as it would cause an overflow
+        QTest::newRow("EmptyQRect_NegXQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegXQPoint)
+            << QRect(QPoint(2+(-12-1),2+(7-1)), QPoint(-12,7));
+        QTest::newRow("EmptyQRect_NegYQPoint") << getQRectCase(EmptyQRect) << getQPointCase(NegYQPoint)
+            << QRect(QPoint(2+(12-1),2+(-7-1)), QPoint(12,-7));
+        QTest::newRow("EmptyQRect_RandomQPoint") << getQRectCase(EmptyQRect) << getQPointCase(RandomQPoint)
+            << QRect(QPoint(2+(12-1),2+(7-1)), QPoint(12,7));
     }
 }
 
diff --git a/tests/auto/corelib/tools/qregexp/tst_qregexp.cpp b/tests/auto/corelib/tools/qregexp/tst_qregexp.cpp
index 244d637fa4..5a51ae32ae 100644
--- a/tests/auto/corelib/tools/qregexp/tst_qregexp.cpp
+++ b/tests/auto/corelib/tools/qregexp/tst_qregexp.cpp
@@ -137,79 +137,79 @@ void tst_QRegExp::indexIn_data()
         QTest::newRow( stri + "anc00" ) << QString("a(?=)z") << QString("az") << 0 << 2 << QStringList();
         QTest::newRow( stri + "anc01" ) << QString("a(?!)z") << QString("az") << -1 << -1 << QStringList();
         QTest::newRow( stri + "anc02" ) << QString("a(?:(?=)|(?=))z") << QString("az") << 0 << 2
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc03" ) << QString("a(?:(?=)|(?!))z") << QString("az") << 0 << 2
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc04" ) << QString("a(?:(?!)|(?=))z") << QString("az") << 0 << 2
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc05" ) << QString("a(?:(?!)|(?!))z") << QString("az") << -1 << -1
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc06" ) << QString("a(?:(?=)|b)z") << QString("az") << 0 << 2
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc07" ) << QString("a(?:(?=)|b)z") << QString("abz") << 0 << 3
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc08" ) << QString("a(?:(?!)|b)z") << QString("az") << -1 << -1
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc09" ) << QString("a(?:(?!)|b)z") << QString("abz") << 0 << 3
-			       << QStringList();
+                               << QStringList();
 #if 0
         QTest::newRow( stri + "anc10" ) << QString("a?(?=^b$)") << QString("ab") << 0 << 1
-			       << QStringList();
+                               << QStringList();
         QTest::newRow( stri + "anc11" ) << QString("a?(?=^b$)") << QString("b") << 0 << 0
-			       << QStringList();
+                               << QStringList();
 #endif
 
         // back-references
         QTest::newRow( stri + "bref00" ) << QString("(a*)(\\1)") << QString("aaaaa") << 0 << 4
-			        << QStringList( QStringList() << "aa" << "aa" );
+                               << QStringList( QStringList() << "aa" << "aa" );
         QTest::newRow( stri + "bref01" ) << QString("<(\\w*)>.+</\\1>") << QString("<b>blabla</b>bla</>")
-			        << 0 << 13 << QStringList( QStringList() << "b" );
+                               << 0 << 13 << QStringList( QStringList() << "b" );
         QTest::newRow( stri + "bref02" ) << QString("<(\\w*)>.+</\\1>") << QString("<>blabla</b>bla</>")
-			        << 0 << 18 << QStringList( QStringList() << "" );
+                               << 0 << 18 << QStringList( QStringList() << "" );
         QTest::newRow( stri + "bref03" ) << QString("((a*\\2)\\2)") << QString("aaaa") << 0 << 4
-			        << QStringList( QStringList() << QString("aaaa") << "aa" );
+                               << QStringList( QStringList() << QString("aaaa") << "aa" );
         QTest::newRow( stri + "bref04" ) << QString("^(aa+)\\1+$") << QString("aaaaaa") << 0 << 6
-			        << QStringList( QStringList() << QString("aa") );
+                               << QStringList( QStringList() << QString("aa") );
         QTest::newRow( stri + "bref05" ) << QString("^(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)(12)(13)(14)"
                                           "\\14\\13\\12\\11\\10\\9\\8\\7\\6\\5\\4\\3\\2\\1")
                                << QString("12345678910111213141413121110987654321") << 0 << 38
-			       << QStringList( QStringList() << "1" << "2" << "3" << "4" << "5" << "6"
+                               << QStringList( QStringList() << "1" << "2" << "3" << "4" << "5" << "6"
                                                              << "7" << "8" << "9" << "10" << "11"
                                                              << "12" << "13" << "14");
 
         // captures
         QTest::newRow( stri + "cap00" ) << QString("(a*)") << QString("") << 0 << 0
-			       << QStringList( QStringList() << QString("") );
+                               << QStringList( QStringList() << QString("") );
         QTest::newRow( stri + "cap01" ) << QString("(a*)") << QString("aaa") << 0 << 3
-			       << QStringList( QStringList() << "aaa" );
+                               << QStringList( QStringList() << "aaa" );
         QTest::newRow( stri + "cap02" ) << QString("(a*)") << QString("baaa") << 0 << 0
-			       << QStringList( QStringList() << QString("") );
+                               << QStringList( QStringList() << QString("") );
         QTest::newRow( stri + "cap03" ) << QString("(a*)(a*)") << QString("aaa") << 0 << 3
-			       << QStringList( QStringList() << QString("aaa") << QString("") );
+                               << QStringList( QStringList() << QString("aaa") << QString("") );
         QTest::newRow( stri + "cap04" ) << QString("(a*)(b*)") << QString("aaabbb") << 0 << 6
-			       << QStringList( QStringList() << QString("aaa") << QString("bbb") );
+                               << QStringList( QStringList() << QString("aaa") << QString("bbb") );
         QTest::newRow( stri + "cap06" ) << QString("(a*)a*") << QString("aaa") << 0 << 3
-			       << QStringList( QStringList() << QString("aaa") );
+                               << QStringList( QStringList() << QString("aaa") );
         QTest::newRow( stri + "cap07" ) << QString("((a*a*)*)") << QString("aaa") << 0 << 3
-			       << QStringList( QStringList() << "aaa" << QString("aaa") );
+                               << QStringList( QStringList() << "aaa" << QString("aaa") );
         QTest::newRow( stri + "cap08" ) << QString("(((a)*(b)*)*)") << QString("ababa") << 0 << 5
-			       << QStringList( QStringList() << QString("ababa") << QString("a") << QString("a")
-					          << "" );
+                               << QStringList( QStringList() << QString("ababa") << QString("a") << QString("a")
+                               << "" );
         QTest::newRow( stri + "cap09" ) << QString("(((a)*(b)*)c)*") << QString("") << 0 << 0
-			       << QStringList( QStringList() << QString("") << QString("") << QString("") << QString("") );
+                               << QStringList( QStringList() << QString("") << QString("") << QString("") << QString("") );
         QTest::newRow( stri + "cap10" ) << QString("(((a)*(b)*)c)*") << QString("abc") << 0 << 3
-			       << QStringList( QStringList() << "abc" << "ab" << "a"
-					          << "b" );
+                               << QStringList( QStringList() << "abc" << "ab" << "a"
+                               << "b" );
         QTest::newRow( stri + "cap11" ) << QString("(((a)*(b)*)c)*") << QString("abcc") << 0 << 4
-			       << QStringList( QStringList() << "c" << "" << "" << "" );
+                               << QStringList( QStringList() << "c" << "" << "" << "" );
         QTest::newRow( stri + "cap12" ) << QString("(((a)*(b)*)c)*") << QString("abcac") << 0 << 5
-			       << QStringList( QStringList() << "ac" << "a" << "a" << "" );
+                               << QStringList( QStringList() << "ac" << "a" << "a" << "" );
         QTest::newRow( stri + "cap13" ) << QString("(to|top)?(o|polo)?(gical|o?logical)")
-			       << QString("topological") << 0 << 11
-			       << QStringList( QStringList() << "top" << "o"
-					          << "logical" );
+                               << QString("topological") << 0 << 11
+                               << QStringList( QStringList() << "top" << "o"
+                                                  << "logical" );
         QTest::newRow( stri + "cap14" ) << QString("(a)+") << QString("aaaa") << 0 << 4
-			       << QStringList( QStringList() << "a" );
+                               << QStringList( QStringList() << "a" );
 
         // concatenation
         QTest::newRow( stri + "cat00" ) << QString("") << QString("") << 0 << 0 << QStringList();
@@ -220,165 +220,156 @@ void tst_QRegExp::indexIn_data()
         QTest::newRow( stri + "cat05" ) << QString("b") << QString("a") << -1 << -1 << QStringList();
         QTest::newRow( stri + "cat06" ) << QString("ab") << QString("ab") << 0 << 2 << QStringList();
         QTest::newRow( stri + "cat07" ) << QString("ab") << QString("ba") << -1 << -1 << QStringList();
-        QTest::newRow( stri + "cat08" ) << QString("abab") << QString("abbaababab") << 4 << 4
-			       << QStringList();
+        QTest::newRow( stri + "cat08" ) << QString("abab") << QString("abbaababab") << 4 << 4 << QStringList();
 
-	indexIn_addMoreRows(stri);
+        indexIn_addMoreRows(stri);
     }
 }
 
-
-
 void tst_QRegExp::indexIn_addMoreRows(const QByteArray &stri)
 {
-
         // from Perl Cookbook
-        QTest::newRow( stri + "cook00" ) << QString("^(m*)(d?c{0,3}|c[dm])(1?x{0,3}|x[lc])(v?i{0"
-			           ",3}|i[vx])$")
-			        << QString("mmxl") << 0 << 4
-			        << QStringList( QStringList() << "mm" << "" << "xl"
-					           << "" );
+        QTest::newRow( stri + "cook00" ) << QString("^(m*)(d?c{0,3}|c[dm])(1?x{0,3}|x[lc])(v?i{0,3}|i[vx])$")
+                                << QString("mmxl") << 0 << 4
+                                << QStringList( QStringList() << "mm" << "" << "xl"
+                                << "" );
         QTest::newRow( stri + "cook01" ) << QString("(\\S+)(\\s+)(\\S+)") << QString(" a   b") << 1 << 5
-			        << QStringList( QStringList() << "a" << "   " << "b" );
+                                << QStringList( QStringList() << "a" << "   " << "b" );
         QTest::newRow( stri + "cook02" ) << QString("(\\w+)\\s*=\\s*(.*)\\s*$") << QString(" PATH=. ") << 1
-			        << 7 << QStringList( QStringList() << "PATH" << ". " );
+                                << 7 << QStringList( QStringList() << "PATH" << ". " );
         QTest::newRow( stri + "cook03" ) << QString(".{80,}")
-			        << QString("0000000011111111222222223333333344444444555"
-			           "5555566666666777777778888888899999999000000"
-			           "00aaaaaaaa")
-			        << 0 << 96 << QStringList();
+                                << QString("0000000011111111222222223333333344444444555"
+                                   "5555566666666777777778888888899999999000000"
+                                   "00aaaaaaaa")
+                                << 0 << 96 << QStringList();
         QTest::newRow( stri + "cook04" ) << QString("(\\d+)/(\\d+)/(\\d+) (\\d+):(\\d+):(\\d+)")
-			        << QString("1978/05/24 07:30:00") << 0 << 19
-			        << QStringList( QStringList() << "1978" << "05" << "24"
-					           << "07" << "30" << "00" );
+                                << QString("1978/05/24 07:30:00") << 0 << 19
+                                << QStringList( QStringList() << "1978" << "05" << "24"
+                                << "07" << "30" << "00" );
         QTest::newRow( stri + "cook05" ) << QString("/usr/bin") << QString("/usr/local/bin:/usr/bin")
-			        << 15 << 8 << QStringList();
+                                << 15 << 8 << QStringList();
         QTest::newRow( stri + "cook06" ) << QString("%([0-9A-Fa-f]{2})") << QString("http://%7f") << 7 << 3
-			        << QStringList( QStringList() << "7f" );
+                                << QStringList( QStringList() << "7f" );
         QTest::newRow( stri + "cook07" ) << QString("/\\*.*\\*/") << QString("i++; /* increment i */") << 5
-			        << 17 << QStringList();
+                                << 17 << QStringList();
         QTest::newRow( stri + "cook08" ) << QString("^\\s+") << QString("   aaa   ") <<  0 << 3
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "cook09" ) << QString("\\s+$") << QString("   aaa   ") <<  6 << 3
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "cook10" ) << QString("^.*::") << QString("Box::cat") << 0 << 5
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "cook11" ) << QString("^([01]?\\d\\d|2[0-4]\\d|25[0-5])\\.([01]?\\"
-			           "d\\d|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d|2[0-"
-			           "4]\\d|25[0-5])\\.([01]?\\d\\d|2[0-4]\\d|25["
-			           "0-5])$")
-			        << QString("255.00.40.30") << 0 << 12
-			        << QStringList( QStringList() << "255" << "00" << "40"
-					           << "30" );
+                                   "d\\d|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d|2[0-"
+                                   "4]\\d|25[0-5])\\.([01]?\\d\\d|2[0-4]\\d|25["
+                                   "0-5])$")
+                                << QString("255.00.40.30") << 0 << 12
+                                << QStringList( QStringList() << "255" << "00" << "40"
+                                << "30" );
         QTest::newRow( stri + "cook12" ) << QString("^.*/") << QString(" /usr/local/bin/moc") << 0 << 16
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "cook13" ) << QString(":co#(\\d+):") << QString("bla:co#55:") << 3 << 7
-			        << QStringList( QStringList() << "55" );
+                                << QStringList( QStringList() << "55" );
         QTest::newRow( stri + "cook14" ) << QString("linux") << QString("alphalinuxinunix") << 5 << 5
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "cook15" ) << QString("(\\d+\\.?\\d*|\\.\\d+)") << QString("0.0.5") << 0 << 3
-			        << QStringList( QStringList() << "0.0" );
+                                << QStringList( QStringList() << "0.0" );
 
         // mathematical trivia
         QTest::newRow( stri + "math00" ) << QString("^(a\\1*)$") << QString("a") << 0 << 1
-			        << QStringList( QStringList() << "a" );
+                                << QStringList( QStringList() << "a" );
         QTest::newRow( stri + "math01" ) << QString("^(a\\1*)$") << QString("aa") << 0 << 2
-			        << QStringList( QStringList() << "aa" );
+                                << QStringList( QStringList() << "aa" );
         QTest::newRow( stri + "math02" ) << QString("^(a\\1*)$") << QString("aaa") << -1 << -1
-			        << QStringList( QStringList() << QString() );
+                                << QStringList( QStringList() << QString() );
         QTest::newRow( stri + "math03" ) << QString("^(a\\1*)$") << QString("aaaa") << 0 << 4
-			        << QStringList( QStringList() << "aaaa" );
+                                << QStringList( QStringList() << "aaaa" );
         QTest::newRow( stri + "math04" ) << QString("^(a\\1*)$") << QString("aaaaa") << -1 << -1
-			        << QStringList( QStringList() << QString() );
+                                << QStringList( QStringList() << QString() );
         QTest::newRow( stri + "math05" ) << QString("^(a\\1*)$") << QString("aaaaaa") << -1 << -1
-			        << QStringList( QStringList() << QString() );
+                                << QStringList( QStringList() << QString() );
         QTest::newRow( stri + "math06" ) << QString("^(a\\1*)$") << QString("aaaaaaa") << -1 << -1
-			        << QStringList( QStringList() << QString() );
+                                << QStringList( QStringList() << QString() );
         QTest::newRow( stri + "math07" ) << QString("^(a\\1*)$") << QString("aaaaaaaa") << 0 << 8
-			        << QStringList( QStringList() << "aaaaaaaa" );
+                                << QStringList( QStringList() << "aaaaaaaa" );
         QTest::newRow( stri + "math08" ) << QString("^(a\\1*)$") << QString("aaaaaaaaa") << -1 << -1
-			        << QStringList( QStringList() << QString() );
+                                << QStringList( QStringList() << QString() );
         QTest::newRow( stri + "math09" ) << QString("^a(?:a(\\1a))*$") << QString("a") << 0 << 1
-			        << QStringList( QStringList() << "" );
+                                << QStringList( QStringList() << "" );
         QTest::newRow( stri + "math10" ) << QString("^a(?:a(\\1a))*$") << QString("aaa") << 0 << 3
-			        << QStringList( QStringList() << "a" );
+                                << QStringList( QStringList() << "a" );
 
         QTest::newRow( stri + "math13" ) << QString("^(?:((?:^a)?\\2\\3)(\\3\\1|(?=a$))(\\1\\2|("
-			           "?=a$)))*a$")
-			        << QString("aaa") << 0 << 3
-			        << QStringList( QStringList() << "a" << "a" << "" );
+                                   "?=a$)))*a$")
+                                << QString("aaa") << 0 << 3
+                                << QStringList( QStringList() << "a" << "a" << "" );
         QTest::newRow( stri + "math14" ) << QString("^(?:((?:^a)?\\2\\3)(\\3\\1|(?=a$))(\\1\\2|("
-			           "?=a$)))*a$")
-			        << QString("aaaaa") << 0 << 5
-			        << QStringList( QStringList() << "a" << "a" << "aa" );
+                                   "?=a$)))*a$")
+                                << QString("aaaaa") << 0 << 5
+                                << QStringList( QStringList() << "a" << "a" << "aa" );
         QTest::newRow( stri + "math17" ) << QString("^(?:(a(?:(\\1\\3)(\\1\\2))*(?:\\1\\3)?)|((?"
-			           ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
-			        << QString("aaa") << 0 << 3
-			        << QStringList( QStringList() << "" << "" << "" << "aaa"
-					           << "a" << "aa" );
+                                   ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
+                                << QString("aaa") << 0 << 3
+                                << QStringList( QStringList() << "" << "" << "" << "aaa" << "a" << "aa" );
         QTest::newRow( stri + "math18" ) << QString("^(?:(a(?:(\\1\\3)(\\1\\2))*(?:\\1\\3)?)|((?"
-			           ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
-			        << QString("aaaaa") << 0 << 5
-			        << QStringList( QStringList() << "aaaaa" << "a" << "aaa"
-					           << "" << "" << "" );
+                                   ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
+                                << QString("aaaaa") << 0 << 5
+                                << QStringList( QStringList() << "aaaaa" << "a" << "aaa" << "" << "" << "" );
         QTest::newRow( stri + "math19" ) << QString("^(?:(a(?:(\\1\\3)(\\1\\2))*(?:\\1\\3)?)|((?"
-			           ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
-			        << QString("aaaaaaaa") << 0 << 8
-			        << QStringList( QStringList() << "" << "" << ""
-					           << "aaaaaaaa" << "a"
-					           << "aa" );
+                                   ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
+                                << QString("aaaaaaaa") << 0 << 8
+                                << QStringList( QStringList() << "" << "" << "" << "aaaaaaaa" << "a" << "aa" );
         QTest::newRow( stri + "math20" ) << QString("^(?:(a(?:(\\1\\3)(\\1\\2))*(?:\\1\\3)?)|((?"
-			           ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
-			        << QString("aaaaaaaaa") << -1 << -1
-			        << QStringList( QStringList() << QString()
-					           << QString()
-					           << QString()
-					           << QString()
-					           << QString()
-					           << QString() );
+                                   ":(\\4(?:^a)?\\6)(\\4\\5))*(?:\\4\\6)?))$")
+                                << QString("aaaaaaaaa") << -1 << -1
+                                << QStringList( QStringList() << QString()
+                                   << QString()
+                                   << QString()
+                                   << QString()
+                                   << QString()
+                                   << QString() );
         QTest::newRow( stri + "math21" ) << QString("^(aa+)\\1+$") << QString("aaaaaaaaaaaa") << 0 << 12
-			        << QStringList( QStringList() << "aa" );
+                                << QStringList( QStringList() << "aa" );
 
         static const char * const squareRegExp[] = {
-	    "^a(?:(\\1aa)a)*$",
-	    "^(\\2(\\1a))+$",
-	    "^((\\2a)*)\\1\\2a$",
-	    0
-        };
+            "^a(?:(\\1aa)a)*$",
+            "^(\\2(\\1a))+$",
+            "^((\\2a)*)\\1\\2a$",
+            0
+                };
 
         int ii = 0;
 
         while ( squareRegExp[ii] != 0 ) {
-	    for ( int j = 0; j < 100; j++ ) {
-	        QString name;
-	        name.sprintf( "square%.1d%.2d", ii, j );
-
-	        QString target = "";
-	        target.fill( 'a', j );
-
-	        int pos = -1;
-	        int len = -1;
-
-	        for ( int k = 1; k * k <= j; k++ ) {
-		    if ( k * k == j ) {
-		        pos = 0;
-		        len = j;
-		        break;
-		    }
-	        }
-
-	        QTest::newRow( name.toLatin1() ) << QString( squareRegExp[ii] ) << target
-				    << pos << len << QStringList( "IGNORE ME" );
-	    }
-	    ii++;
+            for ( int j = 0; j < 100; j++ ) {
+                QString name;
+                name.sprintf( "square%.1d%.2d", ii, j );
+
+                QString target = "";
+                target.fill( 'a', j );
+
+                int pos = -1;
+                int len = -1;
+
+                for ( int k = 1; k * k <= j; k++ ) {
+                    if ( k * k == j ) {
+                        pos = 0;
+                        len = j;
+                        break;
+                    }
+                }
+
+                QTest::newRow( name.toLatin1() ) << QString( squareRegExp[ii] ) << target
+                                << pos << len << QStringList( "IGNORE ME" );
+            }
+            ii++;
         }
 
         // miscellaneous
         QTest::newRow( stri + "misc00" ) << QString(email)
-			        << QString("troll1@trolltech.com") << 0 << 20
-			        << QStringList();
+                                << QString("troll1@trolltech.com") << 0 << 20
+                                << QStringList();
         QTest::newRow( stri + "misc01" ) << QString("[0-9]*\\.[0-9]+") << QString("pi = 3.14") << 5 << 4
-			        << QStringList();
+                                << QStringList();
 
         // or operator
         QTest::newRow( stri + "or00" ) << QString("(?:|b)") << QString("xxx") << 0 << 0 << QStringList();
@@ -392,82 +383,82 @@ void tst_QRegExp::indexIn_addMoreRows(const QByteArray &stri)
         QTest::newRow( stri + "or08" ) << QString("(?:a|b)") << QString("abc") << 0 << 1 << QStringList();
         QTest::newRow( stri + "or09" ) << QString("(?:a|b)") << QString("cba") << 1 << 1 << QStringList();
         QTest::newRow( stri + "or10" ) << QString("(?:ab|ba)") << QString("aba") << 0 << 2
-			      << QStringList();
+                              << QStringList();
         QTest::newRow( stri + "or11" ) << QString("(?:ab|ba)") << QString("bab") << 0 << 2
-			      << QStringList();
+                              << QStringList();
         QTest::newRow( stri + "or12" ) << QString("(?:ab|ba)") << QString("caba") << 1 << 2
-			      << QStringList();
+                              << QStringList();
         QTest::newRow( stri + "or13" ) << QString("(?:ab|ba)") << QString("cbab") << 1 << 2
-			      << QStringList();
+                              << QStringList();
 
         // quantifiers
         QTest::newRow( stri + "qua00" ) << QString("((([a-j])){0,0})") << QString("") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua01" ) << QString("((([a-j])){0,0})") << QString("a") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua02" ) << QString("((([a-j])){0,0})") << QString("xyz") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua03" ) << QString("((([a-j]))?)") << QString("") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua04" ) << QString("((([a-j]))?)") << QString("a") << 0 << 1
-			       << QStringList( QStringList() << "a" << "a" << "a" );
+                               << QStringList( QStringList() << "a" << "a" << "a" );
         QTest::newRow( stri + "qua05" ) << QString("((([a-j]))?)") << QString("x") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua06" ) << QString("((([a-j]))?)") << QString("ab") << 0 << 1
-			       << QStringList( QStringList() << "a" << "a" << "a" );
+                               << QStringList( QStringList() << "a" << "a" << "a" );
         QTest::newRow( stri + "qua07" ) << QString("((([a-j]))?)") << QString("xa") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua08" ) << QString("((([a-j])){0,3})") << QString("") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua09" ) << QString("((([a-j])){0,3})") << QString("a") << 0 << 1
-			       << QStringList( QStringList() << "a" << "a" << "a" );
+                               << QStringList( QStringList() << "a" << "a" << "a" );
         QTest::newRow( stri + "qua10" ) << QString("((([a-j])){0,3})") << QString("abcd") << 0 << 3
-			       << QStringList( QStringList() << "abc" << "c" << "c" );
+                               << QStringList( QStringList() << "abc" << "c" << "c" );
         QTest::newRow( stri + "qua11" ) << QString("((([a-j])){0,3})") << QString("abcde") << 0 << 3
-			       << QStringList( QStringList() << "abc" << "c" << "c" );
+                               << QStringList( QStringList() << "abc" << "c" << "c" );
         QTest::newRow( stri + "qua12" ) << QString("((([a-j])){2,4})") << QString("a") << -1 << -1
-			       << QStringList( QStringList() << QString()
-					          << QString()
-					          << QString() );
+                               << QStringList( QStringList() << QString()
+                                                  << QString()
+                                                  << QString() );
         QTest::newRow( stri + "qua13" ) << QString("((([a-j])){2,4})") << QString("ab") << 0 << 2
-			       << QStringList( QStringList() << "ab" << "b" << "b" );
+                               << QStringList( QStringList() << "ab" << "b" << "b" );
         QTest::newRow( stri + "qua14" ) << QString("((([a-j])){2,4})") << QString("abcd") << 0 << 4
-			       << QStringList( QStringList() << "abcd" << "d" << "d" );
+                               << QStringList( QStringList() << "abcd" << "d" << "d" );
         QTest::newRow( stri + "qua15" ) << QString("((([a-j])){2,4})") << QString("abcdef") << 0 << 4
-			       << QStringList( QStringList() << "abcd" << "d" << "d" );
+                               << QStringList( QStringList() << "abcd" << "d" << "d" );
         QTest::newRow( stri + "qua16" ) << QString("((([a-j])){2,4})") << QString("xaybcd") << 3 << 3
-			       << QStringList( QStringList() << "bcd" << "d" << "d" );
+                               << QStringList( QStringList() << "bcd" << "d" << "d" );
         QTest::newRow( stri + "qua17" ) << QString("((([a-j])){0,})") << QString("abcdefgh") << 0 << 8
-			       << QStringList( QStringList() << "abcdefgh" << "h" << "h" );
+                               << QStringList( QStringList() << "abcdefgh" << "h" << "h" );
         QTest::newRow( stri + "qua18" ) << QString("((([a-j])){,0})") << QString("abcdefgh") << 0 << 0
-			       << QStringList( QStringList() << "" << "" << "" );
+                               << QStringList( QStringList() << "" << "" << "" );
         QTest::newRow( stri + "qua19" ) << QString("(1(2(3){3,4}){2,3}){1,2}") << QString("123332333") << 0
-			       << 9
-			       << QStringList( QStringList() << "123332333" << "2333"
-					          << "3" );
+                               << 9
+                               << QStringList( QStringList() << "123332333" << "2333"
+                                                  << "3" );
         QTest::newRow( stri + "qua20" ) << QString("(1(2(3){3,4}){2,3}){1,2}")
-			       << QString("12333323333233331233332333323333") << 0 << 32
-			       << QStringList( QStringList() << "1233332333323333"
-					          << "23333" << "3" );
+                               << QString("12333323333233331233332333323333") << 0 << 32
+                               << QStringList( QStringList() << "1233332333323333"
+                                                  << "23333" << "3" );
         QTest::newRow( stri + "qua21" ) << QString("(1(2(3){3,4}){2,3}){1,2}") << QString("") << -1 << -1
-			       << QStringList( QStringList() << QString()
-					          << QString()
-					          << QString() );
+                               << QStringList( QStringList() << QString()
+                                                  << QString()
+                                                  << QString() );
         QTest::newRow( stri + "qua22" ) << QString("(1(2(3){3,4}){2,3}){1,2}") << QString("12333") << -1
-			       << -1
-			       << QStringList( QStringList() << QString()
-					          << QString()
-					          << QString() );
+                               << -1
+                               << QStringList( QStringList() << QString()
+                                                  << QString()
+                                                  << QString() );
         QTest::newRow( stri + "qua23" ) << QString("(1(2(3){3,4}){2,3}){1,2}") << QString("12333233") << -1
-			       << -1
-			       << QStringList( QStringList() << QString()
-					          << QString()
-					          << QString() );
+                               << -1
+                               << QStringList( QStringList() << QString()
+                                                  << QString()
+                                                  << QString() );
         QTest::newRow( stri + "qua24" ) << QString("(1(2(3){3,4}){2,3}){1,2}") << QString("122333") << -1
-			       << -1
-			       << QStringList( QStringList() << QString()
-					          << QString()
-					          << QString() );
+                               << -1
+                               << QStringList( QStringList() << QString()
+                                                  << QString()
+                                                  << QString() );
 
         // star operator
         QTest::newRow( stri + "star00" ) << QString("(?:)*") << QString("") << 0 << 0 << QStringList();
@@ -476,28 +467,28 @@ void tst_QRegExp::indexIn_addMoreRows(const QByteArray &stri)
         QTest::newRow( stri + "star03" ) << QString("(?:a)*") << QString("a") << 0 << 1 << QStringList();
         QTest::newRow( stri + "star04" ) << QString("(?:a)*") << QString("aaa") << 0 << 3 << QStringList();
         QTest::newRow( stri + "star05" ) << QString("(?:a)*") << QString("bbbbaaa") << 0 << 0
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star06" ) << QString("(?:a)*") << QString("bbbbaaabbaaaaa") << 0 << 0
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star07" ) << QString("(?:b)*(?:a)*") << QString("") << 0 << 0
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star08" ) << QString("(?:b)*(?:a)*") << QString("a") << 0 << 1
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star09" ) << QString("(?:b)*(?:a)*") << QString("aaa") << 0 << 3
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star10" ) << QString("(?:b)*(?:a)*") << QString("bbbbaaa") << 0 << 7
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star11" ) << QString("(?:b)*(?:a)*") << QString("bbbbaaabbaaaaa") << 0 << 7
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star12" ) << QString("(?:a|b)*") << QString("c") << 0 << 0 << QStringList();
         QTest::newRow( stri + "star13" ) << QString("(?:a|b)*") << QString("abac") << 0 << 3
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star14" ) << QString("(?:a|b|)*") << QString("c") << 0 << 0
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star15" ) << QString("(?:a|b|)*") << QString("abac") << 0 << 3
-			        << QStringList();
+                                << QStringList();
         QTest::newRow( stri + "star16" ) << QString("(?:ab|ba|b)*") << QString("abbbababbbaaab") << 0 << 11
-			        << QStringList();
+                                << QStringList();
 }
 
 /*
@@ -544,19 +535,19 @@ void tst_QRegExp::exactMatch()
     QRegExp rx_W( "\\W" );
 
     for ( int i = 0; i < 65536; i++ ) {
-	QChar ch( i );
-	bool is_d = ( ch.category() == QChar::Number_DecimalDigit );
-	bool is_s = ch.isSpace();
-	bool is_w = ( ch.isLetterOrNumber()
+        QChar ch( i );
+        bool is_d = ( ch.category() == QChar::Number_DecimalDigit );
+        bool is_s = ch.isSpace();
+        bool is_w = ( ch.isLetterOrNumber()
         || ch.isMark()
         || ch == '_' );
 
-	QVERIFY( rx_d.exactMatch(QString(ch)) == is_d );
-	QVERIFY( rx_s.exactMatch(QString(ch)) == is_s );
-	QVERIFY( rx_w.exactMatch(QString(ch)) == is_w );
-	QVERIFY( rx_D.exactMatch(QString(ch)) != is_d );
-	QVERIFY( rx_S.exactMatch(QString(ch)) != is_s );
-	QVERIFY( rx_W.exactMatch(QString(ch)) != is_w );
+        QVERIFY( rx_d.exactMatch(QString(ch)) == is_d );
+        QVERIFY( rx_s.exactMatch(QString(ch)) == is_s );
+        QVERIFY( rx_w.exactMatch(QString(ch)) == is_w );
+        QVERIFY( rx_D.exactMatch(QString(ch)) != is_d );
+        QVERIFY( rx_S.exactMatch(QString(ch)) != is_s );
+        QVERIFY( rx_W.exactMatch(QString(ch)) != is_w );
     }
 }
 
@@ -652,9 +643,9 @@ void tst_QRegExp::indexIn()
         QCOMPARE( mypos, pos );
         QCOMPARE( mylen, len );
         if ( caps.size() > 1 && caps[1] != "IGNORE ME" ) {
-	    QCOMPARE( mycaps.count(), caps.count() );
-	    for ( int i = 1; i < (int) mycaps.count(); i++ )
-	        QCOMPARE( mycaps[i], caps[i] );
+            QCOMPARE( mycaps.count(), caps.count() );
+            for ( int i = 1; i < (int) mycaps.count(); i++ )
+                QCOMPARE( mycaps[i], caps[i] );
         }
     }
 
@@ -670,9 +661,9 @@ void tst_QRegExp::indexIn()
         QCOMPARE( mypos, pos );
         QCOMPARE( mylen, len );
         if ( caps.size() > 1 && caps[1] != "IGNORE ME" ) {
-	    QCOMPARE( mycaps.count(), caps.count() );
-	    for ( int i = 1; i < (int) mycaps.count(); i++ )
-	        QCOMPARE( mycaps[i], caps[i] );
+            QCOMPARE( mycaps.count(), caps.count() );
+            for ( int i = 1; i < (int) mycaps.count(); i++ )
+                QCOMPARE( mycaps[i], caps[i] );
         }
     }
 }
@@ -702,14 +693,14 @@ void tst_QRegExp::lastIndexIn()
         QStringList mycaps = rx.capturedTexts();
 
         if ( mypos <= pos || pos == -1 ) {
-	    QCOMPARE( mypos, pos );
-	    QCOMPARE( mylen, len );
-
-	    if (caps.size() > 1 && caps[1] != "IGNORE ME") {
-	        QCOMPARE( mycaps.count(), caps.count() );
-	        for ( int i = 1; i < (int) mycaps.count(); i++ )
-		    QCOMPARE( mycaps[i], caps[i] );
-	    }
+            QCOMPARE( mypos, pos );
+            QCOMPARE( mylen, len );
+
+            if (caps.size() > 1 && caps[1] != "IGNORE ME") {
+                QCOMPARE( mycaps.count(), caps.count() );
+                for ( int i = 1; i < (int) mycaps.count(); i++ )
+                    QCOMPARE( mycaps[i], caps[i] );
+            }
         }
     }
 
@@ -722,14 +713,14 @@ void tst_QRegExp::lastIndexIn()
         QStringList mycaps = rx.capturedTexts();
 
         if ( mypos <= pos || pos == -1 ) {
-	    QCOMPARE( mypos, pos );
-	    QCOMPARE( mylen, len );
-
-	    if (caps.size() > 1 && caps[1] != "IGNORE ME") {
-	        QCOMPARE( mycaps.count(), caps.count() );
-	        for ( int i = 1; i < (int) mycaps.count(); i++ )
-		    QCOMPARE( mycaps[i], caps[i] );
-	    }
+            QCOMPARE( mypos, pos );
+            QCOMPARE( mylen, len );
+
+            if (caps.size() > 1 && caps[1] != "IGNORE ME") {
+                QCOMPARE( mycaps.count(), caps.count() );
+                for ( int i = 1; i < (int) mycaps.count(); i++ )
+                    QCOMPARE( mycaps[i], caps[i] );
+            }
         }
     }
 }
@@ -924,8 +915,8 @@ void tst_QRegExp::testEscapingWildcard_data(){
     QTest::newRow("a true '\\' in input") << "\\Qt;" <<  "\\Qt;" << true;
     QTest::newRow("two true '\\' in input") << "\\\\Qt;" <<  "\\\\Qt;" << true;
     QTest::newRow("a '\\' at the end") << "\\\\Qt;" <<  "\\\\Qt;" << true;
-
 }
+
 void tst_QRegExp::testEscapingWildcard(){
     QFETCH(QString, pattern);
 
@@ -949,8 +940,8 @@ void tst_QRegExp::testInvalidWildcard_data(){
     QTest::newRow("ending [\\") << "abc[\\" << false;
     QTest::newRow("ending []") << "abc[]" << false;
     QTest::newRow("ending [[") << "abc[[" << false;
-
 }
+
 void tst_QRegExp::testInvalidWildcard(){
     QFETCH(QString, pattern);
 
@@ -1018,7 +1009,7 @@ void tst_QRegExp::rainersSlowRegExpCopyBug()
     // this test should take an extreme amount of time if QRegExp is broken
     QRegExp original(email);
 #if defined(Q_OS_WINCE)
-	for (int i = 0; i < 100; ++i) {
+    for (int i = 0; i < 100; ++i) {
 #else
     for (int i = 0; i < 100000; ++i) {
 #endif
@@ -1071,7 +1062,7 @@ void Thread::run()
     int x;
 
 #if defined(Q_OS_WINCE)
-	for (int j = 0; j < 100; ++j) {
+    for (int j = 0; j < 100; ++j) {
 #else
     for (int j = 0; j < 10000; ++j) {
 #endif
@@ -1113,7 +1104,7 @@ void Thread2::run()
     int x;
 
 #if defined(Q_OS_WINCE)
-	for (int j = 0; j < 100; ++j) {
+    for (int j = 0; j < 100; ++j) {
 #else
     for (int j = 0; j < 10000; ++j) {
 #endif
diff --git a/tests/auto/corelib/tools/qsize/tst_qsize.cpp b/tests/auto/corelib/tools/qsize/tst_qsize.cpp
index da636a3747..03a6f1d62d 100644
--- a/tests/auto/corelib/tools/qsize/tst_qsize.cpp
+++ b/tests/auto/corelib/tools/qsize/tst_qsize.cpp
@@ -165,11 +165,11 @@ void tst_QSize::expandedTo_data()
     QTest::addColumn<QSize>("input2");
     QTest::addColumn<QSize>("expected");
 
-    QTest::newRow("data0") << QSize(10,12) << QSize(6,4)	<< QSize(10,12);
-    QTest::newRow("data1") << QSize(0,0)   << QSize(6,4)	<< QSize(6,4);
+    QTest::newRow("data0") << QSize(10,12) << QSize(6,4) << QSize(10,12);
+    QTest::newRow("data1") << QSize(0,0)   << QSize(6,4) << QSize(6,4);
     // This should pick the highest of w,h components independently of each other,
     // thus the results don't have to be equal to neither input1 nor input2.
-    QTest::newRow("data3") << QSize(6,4)   << QSize(4,6)	<< QSize(6,6);
+    QTest::newRow("data3") << QSize(6,4)   << QSize(4,6) << QSize(6,6);
 }
 
 void tst_QSize::expandedTo()
@@ -187,11 +187,11 @@ void tst_QSize::boundedTo_data()
     QTest::addColumn<QSize>("input2");
     QTest::addColumn<QSize>("expected");
 
-    QTest::newRow("data0") << QSize(10,12) << QSize(6,4)	<< QSize(6,4);
-    QTest::newRow("data1") << QSize(0,0)	<< QSize(6,4)	<< QSize(0,0);
+    QTest::newRow("data0") << QSize(10,12) << QSize(6,4) << QSize(6,4);
+    QTest::newRow("data1") << QSize(0,0) << QSize(6,4) << QSize(0,0);
     // This should pick the lowest of w,h components independently of each other,
     // thus the results don't have to be equal to neither input1 nor input2.
-    QTest::newRow("data3") << QSize(6,4)	<< QSize(4,6)	<< QSize(4,4);
+    QTest::newRow("data3") << QSize(6,4) << QSize(4,6) << QSize(4,4);
 }
 
 void tst_QSize::boundedTo()
@@ -209,8 +209,8 @@ void tst_QSize::transpose_data()
     QTest::addColumn<QSize>("expected");
 
     QTest::newRow("data0") << QSize(10,12) << QSize(12,10);
-    QTest::newRow("data1") << QSize(0,0)	<< QSize(0,0);
-    QTest::newRow("data3") << QSize(6,4)	<< QSize(4,6);
+    QTest::newRow("data1") << QSize(0,0) << QSize(0,0);
+    QTest::newRow("data3") << QSize(6,4) << QSize(4,6);
 }
 
 void tst_QSize::transpose()
diff --git a/tests/auto/corelib/tools/qstring/tst_qstring.cpp b/tests/auto/corelib/tools/qstring/tst_qstring.cpp
index 3922e482c8..a51667e459 100644
--- a/tests/auto/corelib/tools/qstring/tst_qstring.cpp
+++ b/tests/auto/corelib/tools/qstring/tst_qstring.cpp
@@ -562,19 +562,19 @@ void tst_QString::utf8_data()
     QTest::addColumn<QString>("res" );
 
     QTest::newRow( "str0" ) << QByteArray("abcdefgh")
-			  << QString("abcdefgh");
+                          << QString("abcdefgh");
     QTest::newRow( "str1" ) << QByteArray("\303\266\303\244\303\274\303\226\303\204\303\234\303\270\303\246\303\245\303\230\303\206\303\205")
-			  << QString("\366\344\374\326\304\334\370\346\345\330\306\305") ;
+                          << QString("\366\344\374\326\304\334\370\346\345\330\306\305") ;
     str += QChar( 0x05e9 );
     str += QChar( 0x05d3 );
     str += QChar( 0x05d2 );
     QTest::newRow( "str2" ) << QByteArray("\327\251\327\223\327\222")
-			  << str;
+                          << str;
 
     str = QChar( 0x20ac );
     str += " some text";
     QTest::newRow( "str3" ) << QByteArray("\342\202\254 some text")
-			  << str;
+                          << str;
 
     str = "Old Italic: ";
     str += QChar(0xd800);
@@ -710,14 +710,14 @@ void tst_QString::acc_01()
     QVERIFY(*a.toLatin1().constData() == '\0');
     {
 #if defined(Q_OS_WINCE)
-    int argc = 0;
-    QCoreApplication app(argc, 0);
+        int argc = 0;
+        QCoreApplication app(argc, 0);
 #endif
-	QFile f("COMPARE.txt");
-	f.open(QIODevice::ReadOnly);
-	QTextStream ts( &f );
+        QFile f("COMPARE.txt");
+        f.open(QIODevice::ReadOnly);
+        QTextStream ts( &f );
         ts.setCodec(QTextCodec::codecForName("UTF-16"));
-	ts << "Abc";
+        ts << "Abc";
     }
 }
 
@@ -775,8 +775,6 @@ void tst_QString::constructor()
     QVERIFY( empty.isEmpty() );
 }
 
-
-
 void tst_QString::constructorQByteArray_data()
 {
     QTest::addColumn<QByteArray>("src" );
@@ -1187,17 +1185,17 @@ void tst_QString::indexOf2()
     QCOMPARE( haystack.indexOf(ref, 0, Qt::CaseInsensitive), resultpos );
     QCOMPARE( QStringMatcher(needle, Qt::CaseInsensitive).indexIn(haystack, 0), resultpos );
     if ( needle.length() > 0 ) {
-	got = haystack.lastIndexOf( needle, -1, Qt::CaseSensitive );
-	QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
-	got = haystack.lastIndexOf( needle, -1, Qt::CaseInsensitive );
-	QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
+        got = haystack.lastIndexOf( needle, -1, Qt::CaseSensitive );
+        QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
+        got = haystack.lastIndexOf( needle, -1, Qt::CaseInsensitive );
+        QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
     }
 
     QCOMPARE( chaystack.indexOf(cneedle, 0), resultpos );
     QCOMPARE( QByteArrayMatcher(cneedle).indexIn(chaystack, 0), resultpos );
     if ( cneedle.length() > 0 ) {
-	got = chaystack.lastIndexOf(cneedle, -1);
-	QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
+        got = chaystack.lastIndexOf(cneedle, -1);
+        QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
     }
 }
 
@@ -1778,22 +1776,22 @@ void tst_QString::append_bytearray_data()
 void tst_QString::append_bytearray()
 {
     {
-	QFETCH( QString, str );
-	QFETCH( QByteArray, ba );
+        QFETCH( QString, str );
+        QFETCH( QByteArray, ba );
 
-	str.append( ba );
+        str.append( ba );
 
-	QTEST( str, "res" );
+        QTEST( str, "res" );
     }
     {
-	QFETCH( QString, str );
-	QFETCH( QByteArray, ba );
+        QFETCH( QString, str );
+        QFETCH( QByteArray, ba );
 
-	QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
-	str.append( ba );
-	QTextCodec::setCodecForCStrings( 0 );
+        QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
+        str.append( ba );
+        QTextCodec::setCodecForCStrings( 0 );
 
-	QTEST( str, "res" );
+        QTEST( str, "res" );
     }
 }
 
@@ -1805,22 +1803,22 @@ void tst_QString::operator_pluseq_bytearray_data()
 void tst_QString::operator_pluseq_bytearray()
 {
     {
-	QFETCH( QString, str );
-	QFETCH( QByteArray, ba );
+        QFETCH( QString, str );
+        QFETCH( QByteArray, ba );
 
-	str += ba;
+        str += ba;
 
-	QTEST( str, "res" );
+        QTEST( str, "res" );
     }
     {
-	QFETCH( QString, str );
-	QFETCH( QByteArray, ba );
+        QFETCH( QString, str );
+        QFETCH( QByteArray, ba );
 
-	QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
-	str += ba;
-	QTextCodec::setCodecForCStrings( 0 );
+        QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
+        str += ba;
+        QTextCodec::setCodecForCStrings( 0 );
 
-	QTEST( str, "res" );
+        QTEST( str, "res" );
     }
 }
 
@@ -1866,23 +1864,23 @@ void tst_QString::prepend_bytearray_data()
 void tst_QString::prepend_bytearray()
 {
     {
-	QFETCH( QString, str );
-	QFETCH( QByteArray, ba );
+        QFETCH( QString, str );
+        QFETCH( QByteArray, ba );
 
-    str.prepend( ba );
+        str.prepend( ba );
 
-	QFETCH( QString, res );
-	QCOMPARE( str, res );
+        QFETCH( QString, res );
+        QCOMPARE( str, res );
     }
     {
-	QFETCH( QString, str );
-	QFETCH( QByteArray, ba );
+        QFETCH( QString, str );
+        QFETCH( QByteArray, ba );
 
-	QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
-	str.prepend( ba );
-	QTextCodec::setCodecForCStrings( 0 );
+        QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
+        str.prepend( ba );
+        QTextCodec::setCodecForCStrings( 0 );
 
-	QTEST( str, "res" );
+        QTEST( str, "res" );
     }
 }
 
@@ -1902,13 +1900,13 @@ void tst_QString::replace_uint_uint()
     QTEST( s2, "result" );
 
     if ( after.length() == 1 ) {
-	QString s3 = string;
-	s3.replace( (uint) index, (uint) len, QChar(after[0]) );
-	QTEST( s3, "result" );
+        QString s3 = string;
+        s3.replace( (uint) index, (uint) len, QChar(after[0]) );
+        QTEST( s3, "result" );
 
-	QString s4 = string;
-	s4.replace( (uint) index, (uint) len, QChar(after[0]).toLatin1() );
-	QTEST( s4, "result" );
+        QString s4 = string;
+        s4.replace( (uint) index, (uint) len, QChar(after[0]).toLatin1() );
+        QTEST( s4, "result" );
     }
 }
 
@@ -1961,17 +1959,17 @@ void tst_QString::replace_string()
     Qt::CaseSensitivity cs = bcs ? Qt::CaseSensitive : Qt::CaseInsensitive;
 
     if ( before.length() == 1 ) {
-	QChar ch = before.at( 0 );
+        QChar ch = before.at( 0 );
 
-	QString s1 = string;
-	s1.replace( ch, after, cs );
-	QTEST( s1, "result" );
+        QString s1 = string;
+        s1.replace( ch, after, cs );
+        QTEST( s1, "result" );
 
-	if ( QChar(ch.toLatin1()) == ch ) {
-	    QString s2 = string;
-	    s2.replace( ch.toLatin1(), after, cs );
-	    QTEST( s2, "result" );
-	}
+        if ( QChar(ch.toLatin1()) == ch ) {
+            QString s2 = string;
+            s2.replace( ch.toLatin1(), after, cs );
+            QTEST( s2, "result" );
+        }
     }
 
     QString s3 = string;
@@ -2006,11 +2004,11 @@ void tst_QString::remove_uint_uint()
     QFETCH( QString, after );
 
     if ( after.length() == 0 ) {
-	QString s1 = string;
-	s1.remove( (uint) index, (uint) len );
-	QTEST( s1, "result" );
+        QString s1 = string;
+        s1.remove( (uint) index, (uint) len );
+        QTEST( s1, "result" );
     } else
-	QCOMPARE( 0, 0 ); // shut QtTest
+        QCOMPARE( 0, 0 ); // shut QtTest
 }
 
 void tst_QString::remove_string()
@@ -2023,33 +2021,33 @@ void tst_QString::remove_string()
     Qt::CaseSensitivity cs = bcs ? Qt::CaseSensitive : Qt::CaseInsensitive;
 
     if ( after.length() == 0 ) {
-	if ( before.length() == 1 && cs ) {
-	    QChar ch = before.at( 0 );
-
-	    QString s1 = string;
-	    s1.remove( ch );
-	    QTEST( s1, "result" );
-
-	    if ( QChar(ch.toLatin1()) == ch ) {
-		QString s2 = string;
-		s2.remove( ch );
-		QTEST( s2, "result" );
-	    }
-	}
-
-	QString s3 = string;
-	s3.remove( before, cs );
-	QTEST( s3, "result" );
-
-	QString s4 = string;
-	s4.replace( QRegExp(QRegExp::escape(before), cs), after );
-	QTEST( s4, "result" );
-
-	QString s5 = string;
-	s5.replace( QRegExp(before, cs, QRegExp::FixedString), after );
-	QTEST( s5, "result" );
+        if ( before.length() == 1 && cs ) {
+            QChar ch = before.at( 0 );
+
+            QString s1 = string;
+            s1.remove( ch );
+            QTEST( s1, "result" );
+
+            if ( QChar(ch.toLatin1()) == ch ) {
+                QString s2 = string;
+                s2.remove( ch );
+                QTEST( s2, "result" );
+            }
+        }
+
+        QString s3 = string;
+        s3.remove( before, cs );
+        QTEST( s3, "result" );
+
+        QString s4 = string;
+        s4.replace( QRegExp(QRegExp::escape(before), cs), after );
+        QTEST( s4, "result" );
+
+        QString s5 = string;
+        s5.replace( QRegExp(before, cs, QRegExp::FixedString), after );
+        QTEST( s5, "result" );
     } else {
-	QCOMPARE( 0, 0 ); // shut QtTest
+        QCOMPARE( 0, 0 ); // shut QtTest
     }
 }
 
@@ -2060,10 +2058,10 @@ void tst_QString::remove_regexp()
     QFETCH( QString, after );
 
     if ( after.length() == 0 ) {
-	string.remove( QRegExp(regexp) );
-	QTEST( string, "result" );
+        string.remove( QRegExp(regexp) );
+        QTEST( string, "result" );
     } else {
-	QCOMPARE( 0, 0 ); // shut QtTest
+        QCOMPARE( 0, 0 ); // shut QtTest
     }
 }
 
@@ -2354,15 +2352,15 @@ void tst_QString::toUShort()
     QVERIFY(ok);
 
     if (sizeof(short) == 2) {
-	a = "65536";
-	QCOMPARE(a.toUShort(),(ushort)0);
-	QCOMPARE(a.toUShort(&ok),(ushort)0);
-	QVERIFY(!ok);
-
-	a = "123456";
-	QCOMPARE(a.toUShort(),(ushort)0);
-	QCOMPARE(a.toUShort(&ok),(ushort)0);
-	QVERIFY(!ok);
+        a = "65536";
+        QCOMPARE(a.toUShort(),(ushort)0);
+        QCOMPARE(a.toUShort(&ok),(ushort)0);
+        QVERIFY(!ok);
+
+        a = "123456";
+        QCOMPARE(a.toUShort(),(ushort)0);
+        QCOMPARE(a.toUShort(&ok),(ushort)0);
+        QVERIFY(!ok);
     }
 }
 
@@ -2430,15 +2428,15 @@ void tst_QString::toShort()
     QVERIFY(ok);
 
     if (sizeof(short) == 2) {
-	a = "32768";
-	QCOMPARE(a.toShort(),(short)0);
-	QCOMPARE(a.toShort(&ok),(short)0);
-	QVERIFY(!ok);
-
-	a = "-32769";
-	QCOMPARE(a.toShort(),(short)0);
-	QCOMPARE(a.toShort(&ok),(short)0);
-	QVERIFY(!ok);
+        a = "32768";
+        QCOMPARE(a.toShort(),(short)0);
+        QCOMPARE(a.toShort(&ok),(short)0);
+        QVERIFY(!ok);
+
+        a = "-32769";
+        QCOMPARE(a.toShort(),(short)0);
+        QCOMPARE(a.toShort(&ok),(short)0);
+        QVERIFY(!ok);
     }
 }
 
@@ -2506,25 +2504,25 @@ void tst_QString::toInt()
     QVERIFY(ok);
 
     if (sizeof(int) == 4) {
-	a = "-2147483647"; // -(2**31 - 1)
-	QCOMPARE(a.toInt(),-2147483647);
-	QCOMPARE(a.toInt(&ok),-2147483647);
-	QVERIFY(ok);
-
-	a = "2147483648"; // 2**31
-	QCOMPARE(a.toInt(),0);
-	QCOMPARE(a.toInt(&ok),0);
-	QVERIFY(!ok);
-
-	a = "-2147483648"; // -2**31
-	QCOMPARE(a.toInt(),-2147483647 - 1);
-	QCOMPARE(a.toInt(&ok),-2147483647 - 1);
-	QVERIFY(ok);
-
-	a = "2147483649"; // 2**31 + 1
-	QCOMPARE(a.toInt(),0);
-	QCOMPARE(a.toInt(&ok),0);
-	QVERIFY(!ok);
+        a = "-2147483647"; // -(2**31 - 1)
+        QCOMPARE(a.toInt(),-2147483647);
+        QCOMPARE(a.toInt(&ok),-2147483647);
+        QVERIFY(ok);
+
+        a = "2147483648"; // 2**31
+        QCOMPARE(a.toInt(),0);
+        QCOMPARE(a.toInt(&ok),0);
+        QVERIFY(!ok);
+
+        a = "-2147483648"; // -2**31
+        QCOMPARE(a.toInt(),-2147483647 - 1);
+        QCOMPARE(a.toInt(&ok),-2147483647 - 1);
+        QVERIFY(ok);
+
+        a = "2147483649"; // 2**31 + 1
+        QCOMPARE(a.toInt(),0);
+        QCOMPARE(a.toInt(&ok),0);
+        QVERIFY(!ok);
     }
 }
 
@@ -2547,10 +2545,10 @@ void tst_QString::toUInt()
     QVERIFY(ok);
 
     if (sizeof(int) == 4) {
-	a = "4294967296"; // 2**32
-	QCOMPARE(a.toUInt(),0u);
-	QCOMPARE(a.toUInt(&ok),0u);
-	QVERIFY(!ok);
+        a = "4294967296"; // 2**32
+        QCOMPARE(a.toUInt(),0u);
+        QCOMPARE(a.toUInt(&ok),0u);
+        QVERIFY(!ok);
     }
 }
 
@@ -2649,9 +2647,9 @@ void tst_QString::toLongLong()
 
     str = "-9223372036854775808"; // LLONG_MIN
     QCOMPARE( str.toLongLong( 0 ),
-	     -Q_INT64_C(9223372036854775807) - Q_INT64_C(1) );
+             -Q_INT64_C(9223372036854775807) - Q_INT64_C(1) );
     QCOMPARE( str.toLongLong( &ok ),
-	     -Q_INT64_C(9223372036854775807) - Q_INT64_C(1) );
+             -Q_INT64_C(9223372036854775807) - Q_INT64_C(1) );
     QVERIFY( ok );
 
     str = "aaaa9223372036854775807aaaa";
@@ -2738,10 +2736,10 @@ void tst_QString::toDouble()
     bool ok;
     double d = str.toDouble( &ok );
     if ( result_ok ) {
-	QTEST( d, "result" );
-	QVERIFY( ok );
+        QTEST( d, "result" );
+        QVERIFY( ok );
     } else {
-	QVERIFY( !ok );
+        QVERIFY( !ok );
     }
 }
 
@@ -2770,11 +2768,11 @@ void tst_QString::setNum()
     QCOMPARE(a.setNum(Q_INT64_C(-1099511627776)), QString("-1099511627776"));
     QCOMPARE(a.setNum(Q_UINT64_C(1099511627776)), QString("1099511627776"));
     QCOMPARE(a.setNum(Q_INT64_C(9223372036854775807)), // LLONG_MAX
-	    QString("9223372036854775807"));
+            QString("9223372036854775807"));
     QCOMPARE(a.setNum(-Q_INT64_C(9223372036854775807) - Q_INT64_C(1)),
-	    QString("-9223372036854775808"));
+            QString("-9223372036854775808"));
     QCOMPARE(a.setNum(Q_UINT64_C(18446744073709551615)), // ULLONG_MAX
-	    QString("18446744073709551615"));
+            QString("18446744073709551615"));
     QCOMPARE(a.setNum(0.000000000931322574615478515625),QString("9.31323e-10"));
 
 //  QCOMPARE(a.setNum(0.000000000931322574615478515625,'g',30),(QString)"9.31322574615478515625e-010");
@@ -2989,8 +2987,8 @@ void tst_QString::check_QDataStream()
     QString a;
     QByteArray ar;
     {
-	QDataStream out(&ar,QIODevice::WriteOnly);
-	out << QString("COMPARE Text");
+        QDataStream out(&ar,QIODevice::WriteOnly);
+        out << QString("COMPARE Text");
     }
     {
         QDataStream in(&ar,QIODevice::ReadOnly);
@@ -3004,13 +3002,13 @@ void tst_QString::check_QTextStream()
     QString a;
     QByteArray ar;
     {
-	QTextStream out(&ar,QIODevice::WriteOnly);
-	out << QString("This is COMPARE Text");
+        QTextStream out(&ar,QIODevice::WriteOnly);
+        out << QString("This is COMPARE Text");
     }
     {
-	QTextStream in(&ar,QIODevice::ReadOnly);
-	in >> a;
-	QCOMPARE(a,(QString)"This");
+        QTextStream in(&ar,QIODevice::ReadOnly);
+        in >> a;
+        QCOMPARE(a,(QString)"This");
     }
 }
 
@@ -3018,17 +3016,17 @@ void tst_QString::check_QTextIOStream()
 {
     QString a;
     {
-	a="";
-	QTextStream ts(&a);
-	ts << "pi \261= " << 3.125;
-	QCOMPARE(a,(QString)"pi \261= 3.125");
+        a="";
+        QTextStream ts(&a);
+        ts << "pi \261= " << 3.125;
+        QCOMPARE(a,(QString)"pi \261= 3.125");
     }
     {
-	a="123 456";
-	int x,y;
-	QTextStream(&a) >> x >> y;
-	QCOMPARE(x,123);
-	QCOMPARE(y,456);
+        a="123 456";
+        int x,y;
+        QTextStream(&a) >> x >> y;
+        QCOMPARE(x,123);
+        QCOMPARE(y,456);
     }
 }
 
@@ -3256,8 +3254,8 @@ void tst_QString::fromLocal8Bit_data()
     QString longQString;
 
     for (int l=0;l<111;l++) {
-	longQByteArray = longQByteArray + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-	longQString += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        longQByteArray = longQByteArray + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        longQString += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     }
 
     //QTest::newRow("longString") << longQByteArray << -1 << longQString;
@@ -3303,8 +3301,8 @@ void tst_QString::local8Bit_data()
     QString longQString;
 
     for (int l=0;l<111;l++) {
-	longQByteArray = longQByteArray + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-	longQString += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        longQByteArray = longQByteArray + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        longQString += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     }
 
     QTest::newRow("longString") << longQString << longQByteArray;
@@ -3569,7 +3567,7 @@ void tst_QString::arg()
     QString firstName( "James" );
     QString lastName( "Bond" );
     QString fullName = QString( "My name is %2, %1 %2" )
-		       .arg( firstName ).arg( lastName );
+                       .arg( firstName ).arg( lastName );
     QCOMPARE( fullName, QString("My name is Bond, James Bond") );
 
     // number overloads
@@ -3577,7 +3575,7 @@ void tst_QString::arg()
     QCOMPARE( s4.arg(-1), QString("[-1]") );
     QCOMPARE( s4.arg(4294967295UL), QString("[4294967295]") ); // ULONG_MAX 32
     QCOMPARE( s4.arg(Q_INT64_C(9223372036854775807)), // LLONG_MAX
-	     QString("[9223372036854775807]") );
+             QString("[9223372036854775807]") );
 
     QCOMPARE( QString().arg(0), QString() );
     QCOMPARE( QString("").arg(0), QString("") );
@@ -4009,7 +4007,7 @@ void tst_QString::integer_conversion()
     QCOMPARE(ok, good);
 
     if (ok) {
-	QCOMPARE(d, num);
+        QCOMPARE(d, num);
     }
 
     QLocale::setDefault(QLocale::C);
@@ -4088,8 +4086,8 @@ void tst_QString::double_conversion_data()
 */
     // Let's try some Arabic
     const quint16 arabic_str[] = { 0x0660, 0x066B, 0x0661, 0x0662,
-				    0x0663, 0x0664, 0x0065, 0x0662,
-				    0x0000 };			    // "0.1234e2"
+                                    0x0663, 0x0664, 0x0065, 0x0662,
+                                    0x0000 };                            // "0.1234e2"
     QTest::newRow("ar_SA") << QString("ar_SA") << QString::fromUtf16(arabic_str) << true << 0.1234e2;
 }
 
@@ -4110,10 +4108,10 @@ void tst_QString::double_conversion()
     QCOMPARE(ok, good);
 
     if (ok) {
-	double diff = d - num;
-	if (diff < 0)
-	    diff = -diff;
-	QVERIFY(diff <= MY_DOUBLE_EPSILON);
+        double diff = d - num;
+        if (diff < 0)
+            diff = -diff;
+        QVERIFY(diff <= MY_DOUBLE_EPSILON);
     }
 
     QLocale::setDefault(QLocale::C);
@@ -4130,11 +4128,11 @@ void tst_QString::tortureSprintfDouble()
     QString s;
 
     for (; data->fmt != 0; ++data) {
-	double d;
-	char *buff = (char *)&d;
-#	ifndef Q_BYTE_ORDER
-#	    error "Q_BYTE_ORDER not defined"
-#	endif
+        double d;
+        char *buff = (char *)&d;
+#        ifndef Q_BYTE_ORDER
+#            error "Q_BYTE_ORDER not defined"
+#        endif
 
 #       ifdef QT_ARMFPA
         buff[0] = data->bytes[4];
@@ -4145,20 +4143,20 @@ void tst_QString::tortureSprintfDouble()
         buff[5] = data->bytes[1];
         buff[6] = data->bytes[2];
         buff[7] = data->bytes[3];
-#	elif Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-	for (uint i = 0; i < 8; ++i)
-	    buff[i] = data->bytes[i];
-#	else
-	for (uint i = 0; i < 8; ++i)
-	    buff[7 - i] = data->bytes[i];
-#	endif
-	s.sprintf(data->fmt, d);
+#        elif Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+        for (uint i = 0; i < 8; ++i)
+            buff[i] = data->bytes[i];
+#        else
+        for (uint i = 0; i < 8; ++i)
+            buff[7 - i] = data->bytes[i];
+#        endif
+        s.sprintf(data->fmt, d);
 #ifdef QT_NO_FPU // reduced precision when running with hardfloats in qemu
-	if (d - 0.1 < 1e12)
+        if (d - 0.1 < 1e12)
             QSKIP("clib sprintf doesn't fill with 0's on this platform");
-	QCOMPARE(s.left(16), QString(data->expected).left(16));
+        QCOMPARE(s.left(16), QString(data->expected).left(16));
 #else
-	QCOMPARE(s, QString(data->expected));
+        QCOMPARE(s, QString(data->expected));
 #endif
     }
 }
@@ -4361,7 +4359,7 @@ void tst_QString::localeAwareCompare()
 
 #else
     if (!locale.isEmpty())
-	    setlocale(LC_ALL, "");
+            setlocale(LC_ALL, "");
 #endif
 }
 #endif
@@ -4374,7 +4372,7 @@ void tst_QString::split_data()
 
     QTest::newRow("1") << "a,b,c" << "," << (QStringList() << "a" << "b" << "c");
     QTest::newRow("2") << QString("-rw-r--r--  1 0  0  519240 Jul  9  2002 bigfile")
-		    << " "
+                    << " "
                     << (QStringList() << "-rw-r--r--" << "" << "1" << "0" << "" << "0" << ""
                                       << "519240" << "Jul" << "" << "9" << "" << "2002" << "bigfile");
     QTest::newRow("one-empty") << "" << " " << (QStringList() << "");
@@ -4580,14 +4578,14 @@ void tst_QString::arg_fillChar_data()
     replaceValues << QVariant((int)5.5) << QVariant(QString("foo")) << QVariant((qulonglong)INT_MAX);
     widths << 10 << 2 << 5;
     QTest::newRow("str1") << QString("%3.%1.%3.%2") << replaceValues << widths << QString("0 c")
-		       << QString("2147483647.0000000005.2147483647.foo");
+                       << QString("2147483647.0000000005.2147483647.foo");
 
     replaceValues.clear();
     widths.clear();
     replaceValues << QVariant(QString("fisk"));
     widths << 100;
     QTest::newRow("str2") << QString("%9 og poteter") << replaceValues << widths << QString("f")
-		       << QString("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffisk og poteter");
+                       << QString("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffisk og poteter");
 }
 
 void tst_QString::arg_fillChar()
@@ -4606,9 +4604,9 @@ void tst_QString::arg_fillChar()
 
     QString actual = pattern;
     for (int i=0; i<replaceValues.count(); ++i) {
-	const QVariant &var = replaceValues.at(i);
-	const int width = widths.at(i);
-	const QChar &fillChar = fillChars.at(i);
+        const QVariant &var = replaceValues.at(i);
+        const int width = widths.at(i);
+        const QChar &fillChar = fillChars.at(i);
         switch (var.type()) {
         case QVariant::String: actual = actual.arg(var.toString(), width, fillChar); break;
         case QVariant::Int: actual = actual.arg(var.toInt(), width, base, fillChar); break;
diff --git a/tests/auto/corelib/tools/qstringref/tst_qstringref.cpp b/tests/auto/corelib/tools/qstringref/tst_qstringref.cpp
index 7b0009fc6e..305439ed11 100644
--- a/tests/auto/corelib/tools/qstringref/tst_qstringref.cpp
+++ b/tests/auto/corelib/tools/qstringref/tst_qstringref.cpp
@@ -410,20 +410,20 @@ void tst_QStringRef::indexOf2()
     QCOMPARE(haystackRef.indexOf(needle, 0, Qt::CaseInsensitive), resultpos);
     QCOMPARE(haystackRef.indexOf(needleRef, 0, Qt::CaseInsensitive), resultpos);
     if (needle.length() > 0) {
-	got = haystackRef.lastIndexOf(needle, -1, Qt::CaseSensitive);
-	QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
-	got = haystackRef.lastIndexOf(needle, -1, Qt::CaseInsensitive);
-	QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
-
-	got = haystack.lastIndexOf(needleRef, -1, Qt::CaseSensitive);
-	QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
-	got = haystack.lastIndexOf(needleRef, -1, Qt::CaseInsensitive);
-	QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
-
-	got = haystackRef.lastIndexOf(needleRef, -1, Qt::CaseSensitive);
-	QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
-	got = haystackRef.lastIndexOf(needleRef, -1, Qt::CaseInsensitive);
-	QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
+        got = haystackRef.lastIndexOf(needle, -1, Qt::CaseSensitive);
+        QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
+        got = haystackRef.lastIndexOf(needle, -1, Qt::CaseInsensitive);
+        QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
+
+        got = haystack.lastIndexOf(needleRef, -1, Qt::CaseSensitive);
+        QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
+        got = haystack.lastIndexOf(needleRef, -1, Qt::CaseInsensitive);
+        QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
+
+        got = haystackRef.lastIndexOf(needleRef, -1, Qt::CaseSensitive);
+        QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
+        got = haystackRef.lastIndexOf(needleRef, -1, Qt::CaseInsensitive);
+        QVERIFY(got == resultpos || (resultpos >= 0 && got >= resultpos));
     }
 }
 
diff --git a/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp b/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp
index f3a4f11216..7c353867f8 100644
--- a/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp
+++ b/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp
@@ -108,9 +108,9 @@ void tst_QTimeLine::range()
     QSignalSpy spy(&timeLine, SIGNAL(frameChanged(int)));
     timeLine.start();
 #ifdef Q_OS_WINCE
-	QTest::qWait(1000);
+    QTest::qWait(1000);
 #else
-	QTest::qWait(100);
+    QTest::qWait(100);
 #endif
     QCOMPARE(timeLine.state(), QTimeLine::Running);
     int oldValue = timeLine.currentFrame();
@@ -301,7 +301,7 @@ void tst_QTimeLine::loopCount()
     timeLine.stop();
 
     timeLine.setDuration(2500); // ### some platforms have a very low resolution timer
-	timeLine.setFrameRange(0, 2);
+    timeLine.setFrameRange(0, 2);
     timeLine.setLoopCount(4);
 
     QSignalSpy finishedSpy(&timeLine, SIGNAL(finished()));
@@ -333,9 +333,9 @@ void tst_QTimeLine::loopCount()
 
     QCOMPARE(finishedSpy.count(), 2);
     QCOMPARE(frameChangedSpy.count(), 22);
-	for (int i = 11; i < 22; ++i) {
+    for (int i = 11; i < 22; ++i) {
         QCOMPARE(frameChangedSpy.at(i).at(0).toInt(), 2 - (i+2) % 3);
-	}
+    }
 }
 
 void tst_QTimeLine::interpolation()
diff --git a/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp b/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
index d10094c78e..b6bdd9d1cf 100644
--- a/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
+++ b/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
@@ -118,39 +118,39 @@ void tst_QVarLengthArray::removeLast()
 void tst_QVarLengthArray::oldTests()
 {
     {
-	QVarLengthArray<int, 256> sa(128);
-	QVERIFY(sa.data() == &sa[0]);
-	sa[0] = 0xfee;
-	sa[10] = 0xff;
-	QVERIFY(sa[0] == 0xfee);
-	QVERIFY(sa[10] == 0xff);
-	sa.resize(512);
-	QVERIFY(sa.data() == &sa[0]);
-	QVERIFY(sa[0] == 0xfee);
-	QVERIFY(sa[10] == 0xff);
+        QVarLengthArray<int, 256> sa(128);
+        QVERIFY(sa.data() == &sa[0]);
+        sa[0] = 0xfee;
+        sa[10] = 0xff;
+        QVERIFY(sa[0] == 0xfee);
+        QVERIFY(sa[10] == 0xff);
+        sa.resize(512);
+        QVERIFY(sa.data() == &sa[0]);
+        QVERIFY(sa[0] == 0xfee);
+        QVERIFY(sa[10] == 0xff);
         QVERIFY(sa.at(0) == 0xfee);
         QVERIFY(sa.at(10) == 0xff);
         QVERIFY(sa.value(0) == 0xfee);
         QVERIFY(sa.value(10) == 0xff);
         QVERIFY(sa.value(1000) == 0);
         QVERIFY(sa.value(1000, 12) == 12);
-	QVERIFY(sa.size() == 512);
-	sa.reserve(1024);
-	QVERIFY(sa.capacity() == 1024);
-	QVERIFY(sa.size() == 512);
+        QVERIFY(sa.size() == 512);
+        sa.reserve(1024);
+        QVERIFY(sa.capacity() == 1024);
+        QVERIFY(sa.size() == 512);
     }
     {
-	QVarLengthArray<QString> sa(10);
-	sa[0] = "Hello";
-	sa[9] = "World";
-	QVERIFY(*sa.data() == "Hello");
-	QVERIFY(sa[9] == "World");
-	sa.reserve(512);
-	QVERIFY(*sa.data() == "Hello");
-	QVERIFY(sa[9] == "World");
-	sa.resize(512);
-	QVERIFY(*sa.data() == "Hello");
-	QVERIFY(sa[9] == "World");
+        QVarLengthArray<QString> sa(10);
+        sa[0] = "Hello";
+        sa[9] = "World";
+        QVERIFY(*sa.data() == "Hello");
+        QVERIFY(sa[9] == "World");
+        sa.reserve(512);
+        QVERIFY(*sa.data() == "Hello");
+        QVERIFY(sa[9] == "World");
+        sa.resize(512);
+        QVERIFY(*sa.data() == "Hello");
+        QVERIFY(sa[9] == "World");
     }
     {
         int arr[2] = {1, 2};