17 files changed, 753 insertions, 205 deletions

diff --git a/tests/auto/qcombobox/tst_qcombobox.cpp b/tests/auto/qcombobox/tst_qcombobox.cpp
index 2fff6d0..816b2e8 100644
--- a/tests/auto/qcombobox/tst_qcombobox.cpp
+++ b/tests/auto/qcombobox/tst_qcombobox.cpp
@@ -2171,7 +2171,7 @@ void tst_QComboBox::noScrollbar_data()
     QTest::newRow("everything and more") << QString::fromLatin1("QAbstractItemView {  border: 1px 3px 5px 1px solid blue; "
                                                        " padding: 2px 5px 3px 1px; margin: 2px 5px 3px 1px;  } "
                                                        " QAbstractItemView::item {  border: 2px solid green; "
-                                                       "                      padding: 1px 1px 2px 2px margin: 1px; } " );
+                                                       "                      padding: 1px 1px 2px 2px; margin: 1px; } " );
 }
 
 void tst_QComboBox::noScrollbar()
@@ -2179,10 +2179,11 @@ void tst_QComboBox::noScrollbar()
     QStringList initialContent;
     initialContent << "foo" << "bar" << "foobar" << "moo";
     QFETCH(QString, stylesheet);
+    QString oldCss = qApp->styleSheet();
+    qApp->setStyleSheet(stylesheet);
 
     {
         QComboBox comboBox;
-        comboBox.setStyleSheet(stylesheet);
         comboBox.addItems(initialContent);
         comboBox.show();
         comboBox.resize(200, comboBox.height());
@@ -2196,7 +2197,6 @@ void tst_QComboBox::noScrollbar()
     {
         QTableWidget *table = new QTableWidget(2,2);
         QComboBox comboBox;
-        comboBox.setStyleSheet(stylesheet);
         comboBox.setView(table);
         comboBox.setModel(table->model());
         comboBox.show();
@@ -2207,6 +2207,8 @@ void tst_QComboBox::noScrollbar()
         QVERIFY(!comboBox.view()->horizontalScrollBar()->isVisible());
         QVERIFY(!comboBox.view()->verticalScrollBar()->isVisible());
     }
+
+    qApp->setStyleSheet(oldCss);
 }
 
 void tst_QComboBox::setItemDelegate()
diff --git a/tests/auto/qdate/tst_qdate.cpp b/tests/auto/qdate/tst_qdate.cpp
index d4273d0..4d6c80c 100644
--- a/tests/auto/qdate/tst_qdate.cpp
+++ b/tests/auto/qdate/tst_qdate.cpp
@@ -82,6 +82,8 @@ private slots:
     void operator_gt_eq();
     void fromString_data();
     void fromString();
+    void fromString_format_data();
+    void fromString_format();
     void toString_format_data();
     void toString_format();
     void isLeapYear();
@@ -618,6 +620,30 @@ void tst_QDate::fromString()
         QCOMPARE( QDate::fromString( str2, Qt::ISODate ), d1 );
 }
 
+void tst_QDate::fromString_format_data()
+{
+    QTest::addColumn<QString>("string");
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<QDate>("date");
+
+    //year with yy is always 19xx for compatibility
+    QTest::newRow( "data0" ) << QString("21052006") << QString("ddMMyyyy") << QDate(2006,5,21);
+    QTest::newRow( "data1" ) << QString("210506") << QString("ddMMyy") << QDate(1906,5,21);
+    QTest::newRow( "data2" ) << QString("21/5/2006") << QString("d/M/yyyy") << QDate(2006,5,21);
+    QTest::newRow( "data3" ) << QString("21/5/06") << QString("d/M/yy") << QDate(1906,5,21);
+    QTest::newRow( "data4" ) << QString("20060521") << QString("yyyyMMdd") << QDate(2006,5,21);
+    QTest::newRow( "data5" ) << QString("060521") << QString("yyMMdd") << QDate(1906,5,21);
+}
+
+void tst_QDate::fromString_format()
+{
+    QFETCH( QString, string );
+    QFETCH( QString, format );
+    QFETCH( QDate, date );
+
+    QCOMPARE( QDate::fromString( string, format ), date );
+}
+
 void tst_QDate::toString_format_data()
 {
     QTest::addColumn<QDate>("t");
diff --git a/tests/auto/qeasingcurve/tst_qeasingcurve.cpp b/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
index 8fe15b1..b25cdc7 100644
--- a/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
+++ b/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
@@ -371,182 +371,6 @@ void tst_QEasingCurve::valueForProgress_data()
          << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
          << (RealList() << 0.5 << 0.7939 << 0.9755 << 0.9755 << 0.7939 << 0.5 << 0.2061 << 0.02447 << 0.02447 << 0.2061 << 0.5);
 
-    /*
-    QTest::newRow("InQuad") << int(QEasingCurve::InQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (RealList()  << 0 << 0.01 << 0.04 << 0.09 << 0.16 << 0.25 << 0.36 << 0.49 << 0.64 << 0.81 << 1);
-    QTest::newRow("OutQuad") << int(QEasingCurve::OutQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0.19 << 0.36 << 0.51 << 0.64 << 0.75 << 0.84 << 0.91 << 0.96 << 0.99 << 1);
-
-    QTest::newRow("InOutQuad") << int(QEasingCurve::InOutQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 2 << 8 << 18 << 32 << 50 << 68 << 82 << 92 << 98 << 100);
-
-    QTest::newRow("OutInQuad") << int(QEasingCurve::OutInQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 18 << 32 << 42 << 48 << 50 << 52 << 57 << 68 << 82 << 100);
-
-    QTest::newRow("InCubic") << int(QEasingCurve::InCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 2 << 6 << 12 << 21 << 34 << 51 << 72 << 100);
-
-    QTest::newRow("OutCubic") << int(QEasingCurve::OutCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 27 << 48 << 65 << 78 << 87 << 93 << 97 << 99 << 99 << 100);
-
-    QTest::newRow("InOutCubic") << int(QEasingCurve::InOutCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 3 << 10 << 25 << 50 << 74 << 89 << 96 << 99 << 100);
-
-    QTest::newRow("OutInCubic") << int(QEasingCurve::OutInCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 24 << 39 << 46 << 49 << 50 << 50 << 53 << 60 << 75 << 100);
-
-    QTest::newRow("InQuart") << int(QEasingCurve::InQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 2 << 6 << 12 << 24 << 40 << 65 << 100);
-
-    QTest::newRow("OutQuart") << int(QEasingCurve::OutQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 34 << 59 << 75 << 87 << 93 << 97 << 99 << 99 << 99 << 100);
-
-    QTest::newRow("InOutQuart") << int(QEasingCurve::InOutQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 1 << 6 << 20 << 50 << 79 << 93 << 98 << 99 << 100);
-
-    QTest::newRow("OutInQuart") << int(QEasingCurve::OutInQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 29 << 43 << 48 << 49 << 50 << 50 << 51 << 56 << 70 << 100);
-
-    QTest::newRow("InQuint") << int(QEasingCurve::InQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 1 << 3 << 7 << 16 << 32 << 59 << 100);
-
-    QTest::newRow("OutQuint") << int(QEasingCurve::OutQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 40 << 67 << 83 << 92 << 96 << 98 << 99 << 99 << 99 << 100);
-
-    QTest::newRow("InOutQuint") << int(QEasingCurve::InOutQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 3 << 16 << 50 << 83 << 96 << 99 << 99 << 100);
-
-    QTest::newRow("OutInQuint") << int(QEasingCurve::OutInQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 33 << 46 << 49 << 49 << 50 << 50 << 50 << 53 << 66 << 100);
-
-    QTest::newRow("InSine") << int(QEasingCurve::InSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 4 << 10 << 19 << 29 << 41 << 54 << 69 << 84 << 100);
-
-    QTest::newRow("OutSine") << int(QEasingCurve::OutSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 15 << 30 << 45 << 58 << 70 << 80 << 89 << 95 << 98 << 100);
-
-    QTest::newRow("InOutSine") << int(QEasingCurve::InOutSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 2 << 9 << 20 << 34 << 49 << 65 << 79 << 90 << 97 << 100);
-
-    QTest::newRow("OutInSine") << int(QEasingCurve::OutInSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 15 << 29 << 40 << 47 << 50 << 52 << 59 << 70 << 84 << 100);
-
-    QTest::newRow("InExpo") << int(QEasingCurve::InExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 1 << 3 << 6 << 12 << 24 << 49 << 100);
-
-    QTest::newRow("OutExpo") << int(QEasingCurve::OutExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 50 << 75 << 87 << 93 << 96 << 98 << 99 << 99 << 99 << 100);
-
-    QTest::newRow("InOutExpo") << int(QEasingCurve::InOutExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 3 << 12 << 50 << 87 << 96 << 99 << 99 << 100);
-
-    QTest::newRow("OutInExpo") << int(QEasingCurve::OutInExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 37 << 46 << 49 << 49 << 50 << 50 << 50 << 53 << 62 << 100);
-
-    QTest::newRow("InCirc") << int(QEasingCurve::InCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 2 << 4 << 8 << 13 << 19 << 28 << 40 << 56 << 100);
-
-    QTest::newRow("OutCirc") << int(QEasingCurve::OutCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 43 << 59 << 71 << 80 << 86 << 91 << 95 << 97 << 99 << 100);
-
-    QTest::newRow("InOutCirc") << int(QEasingCurve::InOutCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 4 << 9 << 20 << 50 << 80 << 89 << 95 << 98 << 100);
-
-    QTest::newRow("OutInCirc") << int(QEasingCurve::OutInCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 29 << 40 << 45 << 48 << 50 << 51 << 54 << 60 << 70 << 100);
-
-    QTest::newRow("InElastic") << int(QEasingCurve::InElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 1 << -1 << -3 << 12 << -12 << -25 << 100);
-
-    QTest::newRow("OutElastic") << int(QEasingCurve::OutElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 125 << 112 << 87 << 103 << 101 << 98 << 100 << 100 << 99 << 100);
-
-    QTest::newRow("InOutElastic") << int(QEasingCurve::InOutElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << -1 << -6 << 50 << 106 << 101 << 99 << 100 << 100);
-
-    QTest::newRow("OutInElastic") << int(QEasingCurve::OutInElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 37 << 56 << 49 << 49 << 50 << 49 << 50 << 53 << 24 << 100);
-
-    QTest::newRow("InBack") << int(QEasingCurve::InBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << -1 << -4 << -8 << -9 << -8 << -2 << 9 << 29 << 59 << 100);
-
-    QTest::newRow("OutBack") << int(QEasingCurve::OutBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 40 << 70 << 90 << 102 << 108 << 109 << 108 << 104 << 101 << 100);
-
-    QTest::newRow("InOutBack") << int(QEasingCurve::InOutBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << -3 << -9 << -7 << 8 << 50 << 91 << 107 << 109 << 103 << 100);
-
-    QTest::newRow("OutInBack") << int(QEasingCurve::OutInBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 35 << 51 << 54 << 52 << 50 << 47 << 45 << 48 << 64 << 100);
-
-    QTest::newRow("InBounce") << int(QEasingCurve::InBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 6 << 6 << 22 << 23 << 9 << 31 << 69 << 92 << 100);
-
-    QTest::newRow("OutBounce") << int(QEasingCurve::OutBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 7 << 30 << 68 << 90 << 76 << 77 << 93 << 94 << 98 << 100);
-
-    QTest::newRow("InOutBounce") << int(QEasingCurve::InOutBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 3 << 11 << 4 << 34 << 50 << 65 << 95 << 88 << 97 << 100);
-
-    QTest::newRow("OutInBounce") << int(QEasingCurve::OutInBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 15 << 40 << 27 << 43 << 50 << 56 << 72 << 58 << 84 << 100);
-
-    QTest::newRow("InCurve") << int(QEasingCurve::InCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 2 << 10 << 23 << 37 << 50 << 60 << 70 << 80 << 90 << 100);
-
-    QTest::newRow("OutCurve") << int(QEasingCurve::OutCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 39 << 50 << 62 << 76 << 89 << 97 << 100);
-
-    QTest::newRow("SineCurve") << int(QEasingCurve::SineCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 9 << 34 << 65 << 90 << 100 << 90 << 65 << 34 << 9 << 0);
-
-    QTest::newRow("CosineCurve") << int(QEasingCurve::CosineCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 50 << 79 << 97 << 97 << 79 << 50 << 20 << 2 << 2 << 20 << 49);
-*/
 }
 
 
@@ -590,7 +414,11 @@ void tst_QEasingCurve::valueForProgress()
         // converting ease to 4 precision qreal to match the generated samples
         qreal easeConv = qreal(QString().setNum(ease, 'g', 4).toDouble());
         qreal ex = expected.at(i);
-        QVERIFY(qFuzzyCompare(easeConv, ex));
+
+        // the least significant digit it is still subject to rounding errors
+        qreal error = easeConv - ex;
+        // accept the potential rounding error in the least significant digit
+        QVERIFY(error <= 0.00001 );
     }
 #endif
 }
diff --git a/tests/auto/qfiledialog/tst_qfiledialog.cpp b/tests/auto/qfiledialog/tst_qfiledialog.cpp
index 689f73d..16c84d8 100644
--- a/tests/auto/qfiledialog/tst_qfiledialog.cpp
+++ b/tests/auto/qfiledialog/tst_qfiledialog.cpp
@@ -159,6 +159,7 @@ private slots:
     void task218353_relativePaths();
     void task251321_sideBarHiddenEntries();
     void task251341_sideBarRemoveEntries();
+    void task254490_selectFileMultipleTimes();
 
 private:
     QByteArray userSettings;
@@ -1981,5 +1982,37 @@ void tst_QFiledialog::task251341_sideBarRemoveEntries()
     current.rmdir("testDir");
 }
 
+void tst_QFiledialog::task254490_selectFileMultipleTimes()
+{
+    QString tempPath = QDir::tempPath();
+    QTemporaryFile *t;
+    t = new QTemporaryFile;
+    t->open();
+    QNonNativeFileDialog fd(0, "TestFileDialog");
+
+    fd.setDirectory(tempPath);
+    fd.setViewMode(QFileDialog::List);
+    fd.setAcceptMode(QFileDialog::AcceptSave);
+    fd.setFileMode(QFileDialog::AnyFile);
+
+    //This should select the file in the QFileDialog
+    fd.selectFile(t->fileName());
+
+    //This should clear the selection and write it into the filename line edit
+    fd.selectFile("new_file.txt");
+
+    fd.show();
+    QTest::qWait(250);
+
+    QLineEdit *lineEdit = qFindChild<QLineEdit*>(&fd, "fileNameEdit");
+    QVERIFY(lineEdit);
+    QCOMPARE(lineEdit->text(),QLatin1String("new_file.txt"));
+    QListView *list = qFindChild<QListView*>(&fd, "listView");
+    QVERIFY(list);
+    QCOMPARE(list->selectionModel()->selectedRows(0).count(), 0);
+
+    t->deleteLater();
+}
+
 QTEST_MAIN(tst_QFiledialog)
 #include "tst_qfiledialog.moc"
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index c03c420..8afdeb4 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -230,6 +230,7 @@ private slots:
     void task240400_clickOnTextItem_data();
     void task240400_clickOnTextItem();
     void task243707_addChildBeforeParent();
+    void task197802_childrenVisibility();
 };
 
 void tst_QGraphicsItem::init()
@@ -5437,6 +5438,41 @@ void tst_QGraphicsItem::task243707_addChildBeforeParent()
     QVERIFY(!widget2->commonAncestorItem(widget));
 }
 
+void tst_QGraphicsItem::task197802_childrenVisibility()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem item(QRectF(0,0,20,20));
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(0,0,10,10), &item);
+    scene.addItem(&item);
+
+    //freshly created: both visible
+    QVERIFY(item.isVisible());
+    QVERIFY(item2->isVisible());
+
+    //hide child: parent visible, child not
+    item2->hide();
+    QVERIFY(item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //hide parent: parent and child invisible
+    item.hide();
+    QVERIFY(!item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //ask to show the child: parent and child invisible anyways
+    item2->show();
+    QVERIFY(!item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //show the parent: both parent and child visible
+    item.show();
+    QVERIFY(item.isVisible());
+    QVERIFY(item2->isVisible());
+
+    delete item2;
+}
+
 void tst_QGraphicsItem::boundingRegion_data()
 {
     QTest::addColumn<QLineF>("line");
diff --git a/tests/auto/qimage/tst_qimage.cpp b/tests/auto/qimage/tst_qimage.cpp
index c6b0560..b7199f3 100644
--- a/tests/auto/qimage/tst_qimage.cpp
+++ b/tests/auto/qimage/tst_qimage.cpp
@@ -131,6 +131,8 @@ private slots:
     void nullSize();
 
     void premultipliedAlphaConsistency();
+
+    void compareIndexed();
 };
 
 tst_QImage::tst_QImage()
@@ -1762,5 +1764,31 @@ void tst_QImage::premultipliedAlphaConsistency()
     }
 }
 
+void tst_QImage::compareIndexed()
+{
+    QImage img(256, 1, QImage::Format_Indexed8);
+
+    QVector<QRgb> colorTable(256);
+    for (int i = 0; i < 256; ++i)
+        colorTable[i] = qRgb(i, i, i);
+    img.setColorTable(colorTable);
+
+    for (int i = 0; i < 256; ++i) {
+        img.setPixel(i, 0, i);
+    }
+
+    QImage imgInverted(256, 1, QImage::Format_Indexed8);
+    QVector<QRgb> invertedColorTable(256);
+    for (int i = 0; i < 256; ++i)
+        invertedColorTable[255-i] = qRgb(i, i, i);
+    imgInverted.setColorTable(invertedColorTable);
+
+    for (int i = 0; i < 256; ++i) {
+        imgInverted.setPixel(i, 0, (255-i));
+    }
+
+    QCOMPARE(img, imgInverted);
+}
+
 QTEST_MAIN(tst_QImage)
 #include "tst_qimage.moc"
diff --git a/tests/auto/qmake/tst_qmake.cpp b/tests/auto/qmake/tst_qmake.cpp
index 70f1f3c..1178c81 100644
--- a/tests/auto/qmake/tst_qmake.cpp
+++ b/tests/auto/qmake/tst_qmake.cpp
@@ -63,6 +63,7 @@ public slots:
 
 private slots:
     void simple_app();
+    void simple_app_shadowbuild();
     void simple_lib();
     void simple_dll();
     void subdirs();
@@ -143,6 +144,21 @@ void tst_qmake::simple_app()
     QVERIFY( test_compiler.removeMakefile( workDir ) );
 }
 
+void tst_qmake::simple_app_shadowbuild()
+{
+    QString workDir = base_path + "/testdata/simple_app";
+    QString buildDir = base_path + "/testdata/simple_app_build";
+
+    QVERIFY( test_compiler.qmake( workDir, "simple_app", buildDir ));
+    QVERIFY( test_compiler.make( buildDir ));
+    QVERIFY( test_compiler.exists( buildDir, "simple_app", Exe, "1.0.0" ));
+    QVERIFY( test_compiler.makeClean( buildDir ));
+    QVERIFY( test_compiler.exists( buildDir, "simple_app", Exe, "1.0.0" )); // Should still exist after a make clean
+    QVERIFY( test_compiler.makeDistClean( buildDir ));
+    QVERIFY( !test_compiler.exists( buildDir, "simple_app", Exe, "1.0.0" )); // Should not exist after a make distclean
+    QVERIFY( test_compiler.removeMakefile( buildDir ) );
+}
+
 void tst_qmake::simple_dll()
 {
     QString workDir = base_path + "/testdata/simple_dll";
diff --git a/tests/auto/qobject/tst_qobject.cpp b/tests/auto/qobject/tst_qobject.cpp
index fb46073..399d021 100644
--- a/tests/auto/qobject/tst_qobject.cpp
+++ b/tests/auto/qobject/tst_qobject.cpp
@@ -116,6 +116,7 @@ private slots:
     void dumpObjectInfo();
     void connectToSender();
     void qobjectConstCast();
+    void uniqConnection();
 protected:
 };
 
@@ -204,12 +205,20 @@ public:
 	sequence_slot3 = 0;
 	sequence_slot2 = 0;
 	sequence_slot1 = 0;
+        count_slot1 = 0;
+        count_slot2 = 0;
+        count_slot3 = 0;
+        count_slot4 = 0;
     }
 
     int sequence_slot1;
     int sequence_slot2;
     int sequence_slot3;
     int sequence_slot4;
+    int count_slot1;
+    int count_slot2;
+    int count_slot3;
+    int count_slot4;
 
     bool called(int slot) {
         switch (slot) {
@@ -224,10 +233,10 @@ public:
     static int sequence;
 
 public slots:
-    void slot1() { sequence_slot1 = ++sequence; }
-    void slot2() { sequence_slot2 = ++sequence; }
-    void slot3() { sequence_slot3 = ++sequence; }
-    void slot4() { sequence_slot4 = ++sequence; }
+    void slot1() { sequence_slot1 = ++sequence; count_slot1++; }
+    void slot2() { sequence_slot2 = ++sequence; count_slot2++; }
+    void slot3() { sequence_slot3 = ++sequence; count_slot3++; }
+    void slot4() { sequence_slot4 = ++sequence; count_slot4++; }
 
 };
 
@@ -2783,5 +2792,69 @@ void tst_QObject::qobjectConstCast()
     QVERIFY(qobject_cast<const FooObject *>(cptr));
 }
 
+void tst_QObject::uniqConnection()
+{
+    SenderObject *s = new SenderObject;
+    ReceiverObject *r1 = new ReceiverObject;
+    ReceiverObject *r2 = new ReceiverObject;
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    QVERIFY( connect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r2, SLOT( slot1() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r1, SLOT( slot3() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal3() ), r1, SLOT( slot3() ) , Qt::UniqueConnection) );
+
+    s->emitSignal1();
+    s->emitSignal2();
+    s->emitSignal3();
+    s->emitSignal4();
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 2 );
+    QCOMPARE( r1->count_slot4, 0 );
+    QCOMPARE( r2->count_slot1, 1 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+    QCOMPARE( r2->count_slot4, 0 );
+    QCOMPARE( r1->sequence_slot1, 1 );
+    QCOMPARE( r2->sequence_slot1, 2 );
+    QCOMPARE( r1->sequence_slot3, 4 );
+
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    QVERIFY( connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal4() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY(!connect( s, SIGNAL( signal4() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY(!connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) , Qt::UniqueConnection) );
+
+    s->emitSignal4();
+    QCOMPARE( r1->count_slot4, 1 );
+    QCOMPARE( r2->count_slot4, 1 );
+    QCOMPARE( r1->sequence_slot4, 1 );
+    QCOMPARE( r2->sequence_slot4, 2 );
+
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) );
+
+    s->emitSignal4();
+    QCOMPARE( r1->count_slot4, 2 );
+    QCOMPARE( r2->count_slot4, 1 );
+    QCOMPARE( r1->sequence_slot4, 3 );
+    QCOMPARE( r2->sequence_slot4, 2 );
+
+    delete s;
+    delete r1;
+    delete r2;
+}
+
 QTEST_MAIN(tst_QObject)
 #include "tst_qobject.moc"
diff --git a/tests/auto/qpixmapcache/tst_qpixmapcache.cpp b/tests/auto/qpixmapcache/tst_qpixmapcache.cpp
index 405ac34..fb5998a 100644
--- a/tests/auto/qpixmapcache/tst_qpixmapcache.cpp
+++ b/tests/auto/qpixmapcache/tst_qpixmapcache.cpp
@@ -369,6 +369,14 @@ void tst_QPixmapCache::remove()
     key = QPixmapCache::insert(p1);
     QCOMPARE(getPrivate(key)->key, 1);
 
+    //Test if pixmaps are correctly deleted
+    QPixmapCache::clear();
+    key = QPixmapCache::insert(p1);
+    QCOMPARE(getPrivate(key)->key, 1);
+    QVERIFY(QPixmapCache::find(key, &p1) != 0);
+    QPixmapCache::remove(key);
+    QCOMPARE(p1.isDetached(), true);
+
     //We mix both part of the API
     QPixmapCache::clear();
     p1.fill(Qt::red);
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
index 7e910d4..0aeac91 100644
--- a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -63,6 +63,18 @@ protected:
     }
 };
 
+class MyObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal x READ x WRITE setX) 
+public:
+    MyObject() : m_x(0) { }
+    qreal x() const { return m_x; }
+    void setX(qreal x) { m_x = x; }
+private:
+    qreal m_x;
+};
+
 class tst_QPropertyAnimation : public QObject
 {
   Q_OBJECT
@@ -92,6 +104,7 @@ private slots:
     void startWithoutStartValue();
     void playForwardBackward();
     void interpolated();
+    void setStartEndValues_data();
     void setStartEndValues();
     void zeroDurationStart();
     void operationsInStates_data();
@@ -283,7 +296,7 @@ void tst_QPropertyAnimation::statesAndSignals()
 void tst_QPropertyAnimation::deletion1()
 {
     QObject *object = new QWidget;
-    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object,"minimumWidth");
+    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object, "minimumWidth");
 
     //test that the animation is deleted correctly depending of the deletion flag passed in start()
     QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
@@ -686,52 +699,78 @@ void tst_QPropertyAnimation::interpolated()
     }
 }
 
+Q_DECLARE_METATYPE(QVariant)
+
+void tst_QPropertyAnimation::setStartEndValues_data()
+{
+    QTest::addColumn<QByteArray>("propertyName");
+    QTest::addColumn<QVariant>("initialValue");
+    QTest::addColumn<QVariant>("startValue");
+    QTest::addColumn<QVariant>("endValue");
+
+    QTest::newRow("dynamic property")  << QByteArray("ole") << QVariant(42) << QVariant(0) << QVariant(10);
+    QTest::newRow("real property, with unmatching types") << QByteArray("x") << QVariant(42.) << QVariant(0) << QVariant(10.);
+}
+
 void tst_QPropertyAnimation::setStartEndValues()
 {
+    MyObject object;
+    QFETCH(QByteArray, propertyName);
+    QFETCH(QVariant, initialValue);
+    QFETCH(QVariant, startValue);
+    QFETCH(QVariant, endValue);
+
     //this tests the start value, end value and default start value
-    QObject o;
-    o.setProperty("ole", 42);
-    QPropertyAnimation anim(&o, "ole");
+    object.setProperty(propertyName, initialValue);
+    QPropertyAnimation anim(&object, propertyName);
     QVariantAnimation::KeyValues values;
     QCOMPARE(anim.keyValues(), values);
 
     //let's add a start value
-    anim.setStartValue(0);
-    values << QVariantAnimation::KeyValue(0, 0);
+    anim.setStartValue(startValue);
+    values << QVariantAnimation::KeyValue(0, startValue);
     QCOMPARE(anim.keyValues(), values);
 
-    anim.setEndValue(10);
-    values << QVariantAnimation::KeyValue(1, 10);
+    anim.setEndValue(endValue);
+    values << QVariantAnimation::KeyValue(1, endValue);
     QCOMPARE(anim.keyValues(), values);
 
     //now we can play with objects
-    QCOMPARE(o.property("ole").toInt(), 42);
-    QCOMPARE(o.property("ole").toInt(), 42);
+    QCOMPARE(object.property(propertyName).toDouble(), initialValue.toDouble());
     anim.start();
     QVERIFY(anim.startValue().isValid());
-    QCOMPARE(o.property("ole"), anim.startValue());
+    QCOMPARE(object.property(propertyName), anim.startValue());
+    anim.setCurrentTime(anim.duration()/2);
+    QCOMPARE(object.property(propertyName).toDouble(), (startValue.toDouble() + endValue.toDouble())/2 ); //just in the middle of the animation
+    anim.setCurrentTime(anim.duration()); //we go to the end of the animation
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped); //it should have stopped
+    QVERIFY(anim.endValue().isValid());
+    QCOMPARE(object.property(propertyName), anim.endValue()); //end of the animations
 
     //now we remove the explicit start value and test the implicit one
     anim.stop();
-    o.setProperty("ole", 42);
+    object.setProperty(propertyName, initialValue);
+
+    //let's reset the start value
     values.remove(0);
-    anim.setStartValue(QVariant()); //reset the start value
+    anim.setStartValue(QVariant());
     QCOMPARE(anim.keyValues(), values);
     QVERIFY(!anim.startValue().isValid());
+
     anim.start();
-    QCOMPARE(o.property("ole").toInt(), 42);
+    QCOMPARE(object.property(propertyName), initialValue);
     anim.setCurrentTime(anim.duration()/2);
-    QCOMPARE(o.property("ole").toInt(), 26); //just in the middle of the animation
-    anim.setCurrentTime(anim.duration());
+    QCOMPARE(object.property(propertyName).toDouble(), (initialValue.toDouble() + endValue.toDouble())/2 ); //just in the middle of the animation
+    anim.setCurrentTime(anim.duration()); //we go to the end of the animation
     QCOMPARE(anim.state(), QAnimationGroup::Stopped); //it should have stopped
     QVERIFY(anim.endValue().isValid());
-    QCOMPARE(o.property("ole"), anim.endValue()); //end of the animations
+    QCOMPARE(object.property(propertyName), anim.endValue()); //end of the animations
 
     //now we set back the startValue
-    anim.setStartValue(5);
+    anim.setStartValue(startValue);
     QVERIFY(anim.startValue().isValid());
     anim.start();
-    QCOMPARE(o.property("ole").toInt(), 5);
+    QCOMPARE(object.property(propertyName), startValue);
 }
 
 void tst_QPropertyAnimation::zeroDurationStart()
diff --git a/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp b/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
index f414d3a..d7c231f 100644
--- a/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
+++ b/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
@@ -2585,6 +2585,16 @@ void tst_QSortFilterProxyModel::task248868_dynamicSorting()
         QModelIndex index = proxy1.index(row, 0, QModelIndex());
         QCOMPARE(proxy1.data(index, Qt::DisplayRole).toString(), expected.at(row));
     }
+
+    //set up the sorting before seting the model up
+    QSortFilterProxyModel proxy2;
+    proxy2.setDynamicSortFilter(true);
+    proxy2.sort(0);
+    proxy2.setSourceModel(&model2);
+    for (int row = 0; row < proxy2.rowCount(QModelIndex()); ++row) {
+        QModelIndex index = proxy2.index(row, 0, QModelIndex());
+        QCOMPARE(proxy2.data(index, Qt::DisplayRole).toString(), expected.at(row));
+    }
 }
 
 class QtTestModel: public QAbstractItemModel
diff --git a/tests/auto/qtreeview/tst_qtreeview.cpp b/tests/auto/qtreeview/tst_qtreeview.cpp
index c4517d6..2ef76a4 100644
--- a/tests/auto/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/qtreeview/tst_qtreeview.cpp
@@ -227,6 +227,7 @@ private slots:
     void task246536_scrollbarsNotWorking();
     void task250683_wrongSectionSize();
     void task239271_addRowsWithFirstColumnHidden();
+    void task254234_proxySort();
 };
 
 class QtTestModel: public QAbstractItemModel
@@ -2498,7 +2499,6 @@ void tst_QTreeView::sortByColumn()
     QCOMPARE(view.header()->sortIndicatorSection(), 0);
     QCOMPARE(view.model()->data(view.model()->index(0,0)).toString(), QString::fromLatin1("a"));
     QCOMPARE(view.model()->data(view.model()->index(1,0)).toString(), QString::fromLatin1("b"));
-    
 }
 
 /*
@@ -3346,7 +3346,6 @@ void tst_QTreeView::task246536_scrollbarsNotWorking()
     QVERIFY(o.count > 0);
 }
 
-
 void tst_QTreeView::task250683_wrongSectionSize()
 {
     QDirModel model;
@@ -3400,5 +3399,32 @@ void tst_QTreeView::task239271_addRowsWithFirstColumnHidden()
     QVERIFY(delegate.paintedIndexes.contains(sub11.index()));
 }
 
+void tst_QTreeView::task254234_proxySort()
+{
+    //based on tst_QTreeView::sortByColumn
+    // it used not to work when setting the source of a proxy after enabling sorting
+    QTreeView view;
+    QStandardItemModel model(4,2);
+    model.setItem(0,0,new QStandardItem("b"));
+    model.setItem(1,0,new QStandardItem("d"));
+    model.setItem(2,0,new QStandardItem("c"));
+    model.setItem(3,0,new QStandardItem("a"));
+    model.setItem(0,1,new QStandardItem("e"));
+    model.setItem(1,1,new QStandardItem("g"));
+    model.setItem(2,1,new QStandardItem("h"));
+    model.setItem(3,1,new QStandardItem("f"));
+
+    view.sortByColumn(1);
+    view.setSortingEnabled(true);
+
+    QSortFilterProxyModel proxy;
+    proxy.setDynamicSortFilter(true);
+    view.setModel(&proxy);
+    proxy.setSourceModel(&model);
+    QCOMPARE(view.header()->sortIndicatorSection(), 1);
+    QCOMPARE(view.model()->data(view.model()->index(0,1)).toString(), QString::fromLatin1("h"));
+    QCOMPARE(view.model()->data(view.model()->index(1,1)).toString(), QString::fromLatin1("g"));
+}
+
 QTEST_MAIN(tst_QTreeView)
 #include "tst_qtreeview.moc"
diff --git a/tests/benchmarks/qgraphicsview/images/wine-big.jpeg b/tests/benchmarks/qgraphicsview/images/wine-big.jpeg
new file mode 100644
index 0000000..9900a50
--- /dev/null
+++ b/tests/benchmarks/qgraphicsview/images/wine-big.jpeg
diff --git a/tests/benchmarks/qgraphicsview/qgraphicsview.qrc b/tests/benchmarks/qgraphicsview/qgraphicsview.qrc
index 5e80029..3681648 100644
--- a/tests/benchmarks/qgraphicsview/qgraphicsview.qrc
+++ b/tests/benchmarks/qgraphicsview/qgraphicsview.qrc
@@ -2,6 +2,7 @@
 <qresource>
     <file>images/designer.png</file>
     <file>images/wine.jpeg</file>
+    <file>images/wine-big.jpeg</file>
     <file>random.data</file>
 </qresource>
 </RCC>
diff --git a/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp b/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp
index a06e033..570f744 100644
--- a/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp
@@ -124,6 +124,8 @@ private slots:
     void textRiver();
     void moveItemCache_data();
     void moveItemCache();
+    void paintItemCache_data();
+    void paintItemCache();
 };
 
 tst_QGraphicsView::tst_QGraphicsView()
@@ -796,5 +798,105 @@ void tst_QGraphicsView::moveItemCache()
     }
 }
 
+class UpdatedPixmapCacheItem : public QGraphicsPixmapItem
+{
+public:
+    UpdatedPixmapCacheItem(bool partial, QGraphicsItem *parent = 0)
+        : QGraphicsPixmapItem(parent), partial(partial)
+    {
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
+    {
+        QGraphicsPixmapItem::paint(painter,option,widget);
+    }
+protected:
+    void advance(int i)
+    {
+        if (partial)
+            update(QRectF(boundingRect().center().x(), boundingRect().center().x(), 30, 30));
+        else
+            update();
+    }
+
+private:
+    bool partial;
+};
+
+void tst_QGraphicsView::paintItemCache_data()
+{
+    QTest::addColumn<bool>("updatePartial");
+    QTest::addColumn<bool>("rotation");
+    QTest::addColumn<int>("cacheMode");
+    QTest::newRow("Partial Update : ItemCoordinate Cache") << true << false << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Partial Update : DeviceCoordinate Cache") << true << false << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Partial Update : No Cache") << true << false << (int)QGraphicsItem::NoCache;
+    QTest::newRow("Full Update : ItemCoordinate Cache") << false << false << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Full Update : DeviceCoordinate Cache") << false << false << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Full Update : No Cache") << false << false << (int)QGraphicsItem::NoCache;
+    QTest::newRow("Partial Update : ItemCoordinate Cache item rotated") << true << true << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Partial Update : DeviceCoordinate Cache item rotated") << true << true << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Partial Update : No Cache item rotated") << true << true << (int)QGraphicsItem::NoCache;
+    QTest::newRow("Full Update : ItemCoordinate Cache item rotated") << false  << true << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Full Update : DeviceCoordinate Cache item rotated") << false << true << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Full Update : No Cache item rotated") << false << true <<(int)QGraphicsItem::NoCache;
+}
+
+void tst_QGraphicsView::paintItemCache()
+{
+    QFETCH(bool, updatePartial);
+    QFETCH(bool, rotation);
+    QFETCH(int, cacheMode);
+
+    QGraphicsScene scene(0, 0, 300, 300);
+
+    CountPaintEventView view(&scene);
+    view.resize(600, 600);
+    view.setFrameStyle(0);
+    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.show();
+
+    QPixmap pix(":/images/wine.jpeg");
+    QVERIFY(!pix.isNull());
+
+    QList<QGraphicsItem *> items;
+    QFile file(":/random.data");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QDataStream str(&file);
+    UpdatedPixmapCacheItem *item = new UpdatedPixmapCacheItem(updatePartial);
+    item->setPixmap(pix);
+    item->setCacheMode((QGraphicsItem::CacheMode)cacheMode);
+    if (rotation)
+        item->setTransform(QTransform().rotate(45));
+    item->setPos(-100, -100);
+    scene.addItem(item);
+
+    QPixmap pix2(":/images/wine-big.jpeg");
+    item = new UpdatedPixmapCacheItem(updatePartial);
+    item->setPixmap(pix2);
+    item->setCacheMode((QGraphicsItem::CacheMode)cacheMode);
+    if (rotation)
+        item->setTransform(QTransform().rotate(45));
+    item->setPos(0, 0);
+    scene.addItem(item);
+
+    view.count = 0;
+
+    QBENCHMARK {
+#ifdef CALLGRIND_DEBUG
+        CALLGRIND_START_INSTRUMENTATION
+#endif
+        for (int i = 0; i < 50; ++i) {
+            scene.advance();
+            while (view.count < (i+1))
+                qApp->processEvents();
+        }
+#ifdef CALLGRIND_DEBUG
+        CALLGRIND_STOP_INSTRUMENTATION
+#endif
+    }
+}
+
 QTEST_MAIN(tst_QGraphicsView)
 #include "tst_qgraphicsview.moc"
diff --git a/tests/benchmarks/qstringbuilder/main.cpp b/tests/benchmarks/qstringbuilder/main.cpp
new file mode 100644
index 0000000..8eb4e78
--- /dev/null
+++ b/tests/benchmarks/qstringbuilder/main.cpp
@@ -0,0 +1,304 @@
+
+#include "qstringbuilder.h"
+
+#include <QDebug>
+#include <QString>
+
+#include <qtest.h>
+
+
+#define COMPARE(a, b) QCOMPARE(a, b)
+//#define COMPARE(a, b)
+
+#define SEP(s) qDebug() << "\n\n-------- " s "  ---------";
+#define L(s) QLatin1String(s)
+
+class tst_qstringbuilder : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_qstringbuilder()
+      : l1literal("some string literal"),
+        l1string("some string literal"),
+        ba("some string literal"),
+        string(l1string),
+        stringref(&string, 2, 10),
+        achar('c')
+    {}
+
+
+public:
+    enum { N = 10000 };
+
+    int run_traditional()
+    {
+        int s = 0;
+        for (int i = 0; i < N; ++i) {
+#if 0
+            s += QString(l1string + l1string).size();
+            s += QString(l1string + l1string + l1string).size();
+            s += QString(l1string + l1string + l1string + l1string).size();
+            s += QString(l1string + l1string + l1string + l1string + l1string).size();
+#endif
+            s += QString(achar + l1string + achar).size();
+        }
+        return s;
+    }
+
+    int run_builder()
+    {
+        int s = 0;
+        for (int i = 0; i < N; ++i) {
+#if 0
+            s += QString(l1literal % l1literal).size();
+            s += QString(l1literal % l1literal % l1literal).size();
+            s += QString(l1literal % l1literal % l1literal % l1literal).size();
+            s += QString(l1literal % l1literal % l1literal % l1literal % l1literal).size();
+#endif
+            s += QString(achar % l1literal % achar).size();
+        }
+        return s;
+    }
+
+private slots:
+
+    void separator_0() {
+        qDebug() << "\nIn each block the QStringBuilder based result appear first, "
+            "QStringBased second.\n";
+    }
+
+    void separator_1() { SEP("literal + literal  (builder first)"); }
+
+    void b_2_l1literal() {
+        QBENCHMARK { r = l1literal % l1literal; }
+        COMPARE(r, QString(l1string + l1string));
+    }
+    void s_2_l1string() {
+        QBENCHMARK { r = l1string + l1string; }
+        COMPARE(r, QString(l1literal % l1literal));
+    }
+
+
+    void separator_2() { SEP("2 strings"); }
+
+    void b_2_string() {
+        QBENCHMARK { r = string % string; }
+        COMPARE(r, QString(string + string));
+    }
+    void s_2_string() {
+        QBENCHMARK { r = string + string; }
+        COMPARE(r, QString(string % string));
+    }
+
+
+    void separator_2c() { SEP("2 string refs"); }
+
+    void b_2_stringref() {
+        QBENCHMARK { r = stringref % stringref; }
+        COMPARE(r, QString(stringref.toString() + stringref.toString()));
+    }
+    void s_2_stringref() {
+        QBENCHMARK { r = stringref.toString() + stringref.toString(); }
+        COMPARE(r, QString(stringref % stringref));
+    }
+
+
+    void separator_2b() { SEP("3 strings"); }
+
+    void b_3_string() {
+        QBENCHMARK { r = string % string % string; }
+        COMPARE(r, QString(string + string + string));
+    }
+    void s_3_string() {
+        QBENCHMARK { r = string + string + string; }
+        COMPARE(r, QString(string % string % string));
+    }
+
+
+    void separator_2a() { SEP("string + literal  (builder first)"); }
+
+    void b_string_l1literal() {
+        QBENCHMARK { r = string % l1literal; }
+        COMPARE(r, QString(string + l1string));
+    }
+    void b_string_l1string() {
+        QBENCHMARK { r = string % l1string; }
+        COMPARE(r, QString(string + l1string));
+    }
+    void s_string_l1literal() {
+        QBENCHMARK { r = string + l1string; }
+        COMPARE(r, QString(string % l1literal));
+    }
+    void s_string_l1string() {
+        QBENCHMARK { r = string + l1string; }
+        COMPARE(r, QString(string % l1literal));
+    }
+
+
+    void separator_3() { SEP("3 literals"); }
+
+    void b_3_l1literal() {
+        QBENCHMARK { r = l1literal % l1literal % l1literal; }
+        COMPARE(r, QString(l1string + l1string + l1string));
+    }
+    void s_3_l1string() {
+        QBENCHMARK { r = l1string + l1string + l1string; }
+        COMPARE(r, QString(l1literal % l1literal % l1literal));
+    }
+
+
+    void separator_4() { SEP("4 literals"); }
+
+    void b_4_l1literal() {
+        QBENCHMARK { r = l1literal % l1literal % l1literal % l1literal; }
+        COMPARE(r, QString(l1string + l1string + l1string + l1string));
+    }
+    void s_4_l1string() {
+        QBENCHMARK { r = l1string + l1string + l1string + l1string; }
+        COMPARE(r, QString(l1literal % l1literal % l1literal % l1literal));
+    }
+
+
+    void separator_5() { SEP("5 literals"); }
+
+    void b_5_l1literal() {
+        QBENCHMARK { r = l1literal % l1literal % l1literal % l1literal %l1literal; }
+        COMPARE(r, QString(l1string + l1string + l1string + l1string + l1string));
+    }
+
+    void s_5_l1string() {
+        QBENCHMARK { r = l1string + l1string + l1string + l1string + l1string; }
+        COMPARE(r, QString(l1literal % l1literal % l1literal % l1literal % l1literal));
+    }
+
+
+    void separator_6() { SEP("4 chars"); }
+
+    void b_string_4_char() {
+        QBENCHMARK { r = string + achar + achar + achar + achar; }
+        COMPARE(r, QString(string % achar % achar % achar % achar));
+    }
+
+    void s_string_4_char() {
+        QBENCHMARK { r = string + achar + achar + achar + achar; }
+        COMPARE(r, QString(string % achar % achar % achar % achar));
+    }
+
+
+    void separator_7() { SEP("char + string + char"); }
+
+    void b_char_string_char() {
+        QBENCHMARK { r = achar + string + achar; }
+        COMPARE(r, QString(achar % string % achar));
+    }
+
+    void s_char_string_char() {
+        QBENCHMARK { r = achar + string + achar; }
+        COMPARE(r, QString(achar % string % achar));
+    }
+
+    void separator_8() { SEP("string.arg"); }
+
+    void b_string_arg() {
+        const QString pattern = l1string + QLatin1String("%1") + l1string;
+        QBENCHMARK { r = l1literal % string % l1literal; }
+        COMPARE(r, QString(l1string + string + l1string));
+    }
+
+    void s_string_arg() {
+        const QString pattern = l1string + QLatin1String("%1") + l1string;
+        QBENCHMARK { r = pattern.arg(string); }
+        COMPARE(r, QString(l1string + string + l1string));
+    }
+
+    void s_bytearray_arg() {
+        QByteArray result;
+        QBENCHMARK { result = ba + ba + ba; }
+    }
+
+
+    void separator_9() { SEP("QString::reserve()"); }
+
+    void b_reserve() {
+        QBENCHMARK {
+            r.clear();
+            r = string % string % string % string;
+        }
+        COMPARE(r, QString(string + string + string + string));
+    }
+    void b_reserve_lit() {
+        QBENCHMARK {
+            r.clear();
+            r = string % l1literal % string % string;
+        }
+        COMPARE(r, QString(string + string + string + string));
+    }
+    void s_reserve() {
+        QBENCHMARK {
+            r.clear();
+            r.reserve(string.size() + string.size() + string.size() + string.size());
+            r += string;
+            r += string;
+            r += string;
+            r += string;
+        }
+        COMPARE(r, QString(string + string + string + string));
+    }
+    void s_reserve_lit() {
+        QBENCHMARK {
+            r.clear();
+            //r.reserve(string.size() + qstrlen(l1string.latin1())
+            //    + string.size() + string.size());
+            r.reserve(1024);
+            r += string;
+            r += l1string;
+            r += string;
+            r += string;
+        }
+        COMPARE(r, QString(string + string + string + string));
+    }
+
+private:
+    const QLatin1Literal l1literal;
+    const QLatin1String l1string;
+    const QByteArray ba;
+    const QString string;
+    const QStringRef stringref;
+    const QLatin1Char achar;
+
+    QString r;
+};
+
+
+//void operator%(QString, int) {}
+
+int main(int argc, char *argv[])
+{
+    //qDebug() << (QString("xx") * QLatin1String("y")).toString();
+    //42 % 3; // Sanity test, should always work.
+    //QString("x") % 2; // Sanity test, should only compile when the 
+    // operator%(QString, int) is visible.
+
+    if (argc == 2 && (argv[1] == L("--run-builder") || argv[1] == L("-b"))) {
+        tst_qstringbuilder test;
+        return test.run_builder();
+    }
+
+    if (argc == 2 && (argv[1] == L("--run-traditional") || argv[1] == L("-t"))) {
+        tst_qstringbuilder test;
+        return test.run_traditional();
+    }
+
+    if (argc == 1) {
+        QCoreApplication app(argc, argv);
+        QStringList args = app.arguments();
+        tst_qstringbuilder test;
+        return QTest::qExec(&test, argc, argv);
+    }
+
+    qDebug() << "Usage: " << argv[0] << " [--run-builder|-r|--run-traditional|-t]";
+}
+
+
+#include "main.moc"
diff --git a/tests/benchmarks/qstringbuilder/qstringbuilder.pro b/tests/benchmarks/qstringbuilder/qstringbuilder.pro
new file mode 100644
index 0000000..02daaaa
--- /dev/null
+++ b/tests/benchmarks/qstringbuilder/qstringbuilder.pro
@@ -0,0 +1,16 @@
+load(qttest_p4)
+TEMPLATE = app
+TARGET = tst_qstringbuilder
+
+# Uncomment to test compilation of the drop-in
+# replacement operator+()
+#DEFINES += QT_USE_FAST_OPERATOR_PLUS
+
+QMAKE_CXXFLAGS += -g
+QMAKE_CFLAGS += -g
+
+QT -= gui
+
+CONFIG += release
+
+SOURCES += main.cpp