Merge branch '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.6

14 files changed, 951 insertions, 50 deletions

diff --git a/tests/auto/qbytearray/tst_qbytearray.cpp b/tests/auto/qbytearray/tst_qbytearray.cpp
index 35e44632d7..5c72c7a572 100644
--- a/tests/auto/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/qbytearray/tst_qbytearray.cpp
@@ -76,6 +76,7 @@ private slots:
     void qCompress();
     void qUncompress_data();
     void qUncompress();
+    void qCompressionZeroTermination();
 #endif
     void constByteArray();
     void leftJustified();
@@ -261,6 +262,14 @@ void tst_QByteArray::qUncompress()
     }
     QCOMPARE(res, out);
 }
+
+void tst_QByteArray::qCompressionZeroTermination()
+{
+    QString s = "Hello, I'm a string.";
+    QByteArray ba = ::qUncompress(::qCompress(s.toLocal8Bit()));
+    QVERIFY((int) *(ba.data() + ba.size()) == 0);
+}
+
 #endif
 
 void tst_QByteArray::constByteArray()
diff --git a/tests/auto/qgraphicseffect/tst_qgraphicseffect.cpp b/tests/auto/qgraphicseffect/tst_qgraphicseffect.cpp
index 51e2a577b8..795431bd4e 100644
--- a/tests/auto/qgraphicseffect/tst_qgraphicseffect.cpp
+++ b/tests/auto/qgraphicseffect/tst_qgraphicseffect.cpp
@@ -71,6 +71,7 @@ private slots:
     void colorize();
     void drawPixmapItem();
     void deviceCoordinateTranslateCaching();
+    void inheritOpacity();
 };
 
 void tst_QGraphicsEffect::initTestCase()
@@ -79,8 +80,8 @@ void tst_QGraphicsEffect::initTestCase()
 class CustomItem : public QGraphicsRectItem
 {
 public:
-    CustomItem(qreal x, qreal y, qreal width, qreal height)
-        : QGraphicsRectItem(x, y, width, height), numRepaints(0),
+    CustomItem(qreal x, qreal y, qreal width, qreal height, QGraphicsItem *parent = 0)
+        : QGraphicsRectItem(x, y, width, height, parent), numRepaints(0),
           m_painter(0), m_styleOption(0)
     {}
 
@@ -560,6 +561,35 @@ void tst_QGraphicsEffect::deviceCoordinateTranslateCaching()
     QVERIFY(item->numRepaints == numRepaints);
 }
 
+void tst_QGraphicsEffect::inheritOpacity()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 10, 10);
+    CustomItem *item = new CustomItem(0, 0, 10, 10, rectItem);
+
+    scene.addItem(rectItem);
+
+    item->setGraphicsEffect(new DeviceEffect);
+    item->setPen(Qt::NoPen);
+    item->setBrush(Qt::red);
+
+    rectItem->setOpacity(0.5);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QTRY_VERIFY(item->numRepaints >= 1);
+
+    int numRepaints = item->numRepaints;
+
+    rectItem->setOpacity(1);
+    QTest::qWait(50);
+
+    // item should have been rerendered due to opacity changing
+    QTRY_VERIFY(item->numRepaints > numRepaints);
+}
+
 QTEST_MAIN(tst_QGraphicsEffect)
 #include "tst_qgraphicseffect.moc"
 
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 8e43bce901..14b9ef0a42 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -316,6 +316,7 @@ private slots:
     void childrenBoundingRectTransformed();
     void childrenBoundingRect2();
     void childrenBoundingRect3();
+    void childrenBoundingRect4();
     void group();
     void setGroup();
     void setGroup2();
@@ -417,6 +418,7 @@ private slots:
     void task197802_childrenVisibility();
     void QTBUG_4233_updateCachedWithSceneRect();
     void QTBUG_5418_textItemSetDefaultColor();
+    void QTBUG_6738_missingUpdateWithSetParent();
 
 private:
     QList<QGraphicsItem *> paintedItems;
@@ -3257,6 +3259,32 @@ void tst_QGraphicsItem::childrenBoundingRect3()
     QCOMPARE(subTreeRect.height(), qreal(251.7766952966369));
 }
 
+void tst_QGraphicsItem::childrenBoundingRect4()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 10, 10));
+    QGraphicsRectItem *rect2 = scene.addRect(QRectF(0, 0, 20, 20));
+    QGraphicsRectItem *rect3 = scene.addRect(QRectF(0, 0, 30, 30));
+    rect2->setParentItem(rect);
+    rect3->setParentItem(rect);
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+
+    // Try to mess up the cached bounding rect.
+    rect->childrenBoundingRect();
+    rect2->childrenBoundingRect();
+
+    rect3->setOpacity(0.0);
+    rect3->setParentItem(rect2);
+
+    QCOMPARE(rect->childrenBoundingRect(), rect3->boundingRect());
+    QCOMPARE(rect2->childrenBoundingRect(), rect3->boundingRect());
+}
+
 void tst_QGraphicsItem::group()
 {
     QGraphicsScene scene;
@@ -9869,5 +9897,63 @@ void  tst_QGraphicsItem::QTBUG_5418_textItemSetDefaultColor()
     QCOMPARE(i->painted, 0); //same color as before should not trigger an update (QTBUG-6242)
 }
 
+void tst_QGraphicsItem::QTBUG_6738_missingUpdateWithSetParent()
+{
+    // In all 3 test cases below the reparented item should disappear
+    EventTester *parent = new EventTester;
+    EventTester *child = new EventTester(parent);
+    EventTester *child2 = new EventTester(parent);
+    EventTester *child3 = new EventTester(parent);
+    EventTester *child4 = new EventTester(parent);
+
+    child->setPos(10, 10);
+    child2->setPos(20, 20);
+    child3->setPos(30, 30);
+    child4->setPos(40, 40);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    class MyGraphicsView : public QGraphicsView
+    { public:
+        int repaints;
+        QRegion paintedRegion;
+        MyGraphicsView(QGraphicsScene *scene) : QGraphicsView(scene), repaints(0) {}
+        void paintEvent(QPaintEvent *e)
+        {
+            ++repaints;
+            paintedRegion += e->region();
+            QGraphicsView::paintEvent(e);
+        }
+        void reset() { repaints = 0; paintedRegion = QRegion(); }
+    };
+
+    MyGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints > 0);
+
+    // test case #1
+    view.reset();
+    child2->setVisible(false);
+    child2->setParentItem(child);
+
+    QTRY_VERIFY(view.repaints == 1);
+
+    // test case #2
+    view.reset();
+    child3->setOpacity(0.0);
+    child3->setParentItem(child);
+
+    QTRY_VERIFY(view.repaints == 1);
+
+    // test case #3
+    view.reset();
+    child4->setParentItem(child);
+    child4->setVisible(false);
+
+    QTRY_VERIFY(view.repaints == 1);
+}
+
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
index c08a628eed..6743fbe9d7 100644
--- a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
+++ b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
@@ -270,6 +270,7 @@ private slots:
     void initialFocus_data();
     void initialFocus();
     void polishItems();
+    void polishItems2();
     void isActive();
     void siblingIndexAlwaysValid();
 
@@ -3942,14 +3943,23 @@ void tst_QGraphicsScene::initialFocus()
 class PolishItem : public QGraphicsTextItem
 {
 public:
-    PolishItem(QGraphicsItem *parent = 0) : QGraphicsTextItem(parent) { }
+    PolishItem(QGraphicsItem *parent = 0)
+        : QGraphicsTextItem(parent), polished(false), deleteChildrenInPolish(true), addChildrenInPolish(false) { }
 
+    bool polished;
+    bool deleteChildrenInPolish;
+    bool addChildrenInPolish;
 protected:
     QVariant itemChange(GraphicsItemChange change, const QVariant& value)
     {
         if (change == ItemVisibleChange) {
-            if (value.toBool())
+            polished = true;
+            if (deleteChildrenInPolish)
                 qDeleteAll(childItems());
+            if (addChildrenInPolish) {
+                for (int i = 0; i < 10; ++i)
+                    new PolishItem(this);
+            }
         }
         return QGraphicsItem::itemChange(change, value);
     }
@@ -3966,6 +3976,35 @@ void tst_QGraphicsScene::polishItems()
     QMetaObject::invokeMethod(&scene,"_q_polishItems");
 }
 
+void tst_QGraphicsScene::polishItems2()
+{
+    QGraphicsScene scene;
+    PolishItem *item = new PolishItem;
+    item->addChildrenInPolish = true;
+    item->deleteChildrenInPolish = true;
+    // These children should be deleted in the polish.
+    for (int i = 0; i < 20; ++i)
+        new PolishItem(item);
+    scene.addItem(item);
+
+    // Wait for the polish event to be delivered.
+    QVERIFY(!item->polished);
+    QApplication::sendPostedEvents(&scene, QEvent::MetaCall);
+    QVERIFY(item->polished);
+
+    // We deleted the children we added above, but we also
+    // added 10 new children. These should be polished in the next
+    // event loop iteration.
+    QList<QGraphicsItem *> children = item->childItems();
+    QCOMPARE(children.count(), 10);
+    foreach (QGraphicsItem *child, children)
+        QVERIFY(!static_cast<PolishItem *>(child)->polished);
+
+    QApplication::sendPostedEvents(&scene, QEvent::MetaCall);
+    foreach (QGraphicsItem *child, children)
+        QVERIFY(static_cast<PolishItem *>(child)->polished);
+}
+
 void tst_QGraphicsScene::isActive()
 {
     QGraphicsScene scene1;
diff --git a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
index 909ea545c5..d3132fe09d 100644
--- a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
+++ b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
@@ -163,6 +163,7 @@ private slots:
     void addChildInpolishEvent();
     void polishEvent();
     void polishEvent2();
+    void initialShow();
 
     // Task fixes
     void task236127_bspTreeIndexFails();
@@ -2856,6 +2857,30 @@ void tst_QGraphicsWidget::polishEvent2()
     QVERIFY(widget->events.contains(QEvent::Polish));
 }
 
+void tst_QGraphicsWidget::initialShow()
+{
+    class MyGraphicsWidget : public QGraphicsWidget
+    { public:
+        MyGraphicsWidget() : repaints(0) {}
+        int repaints;
+        void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget*) { ++repaints; }
+        void polishEvent() { update(); }
+    };
+
+    QGraphicsScene scene;
+    MyGraphicsWidget *widget = new MyGraphicsWidget;
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QTest::qWait(100);
+    scene.addItem(widget);
+    QTest::qWait(100);
+
+    QCOMPARE(widget->repaints, 1);
+}
+
 void tst_QGraphicsWidget::QT_BUG_6544_tabFocusFirstUnsetWhenRemovingItems()
 {
     QGraphicsScene scene;
diff --git a/tests/auto/qsslcertificate/more-certificates/malformed-just-begin-no-newline.pem b/tests/auto/qsslcertificate/more-certificates/malformed-just-begin-no-newline.pem
new file mode 100644
index 0000000000..75f3c32241
--- /dev/null
+++ b/tests/auto/qsslcertificate/more-certificates/malformed-just-begin-no-newline.pem
@@ -0,0 +1 @@
+-----BEGIN CERTIFICATE-----
\ No newline at end of file
diff --git a/tests/auto/qsslcertificate/more-certificates/malformed-just-begin.pem b/tests/auto/qsslcertificate/more-certificates/malformed-just-begin.pem
new file mode 100644
index 0000000000..a71aecf9af
--- /dev/null
+++ b/tests/auto/qsslcertificate/more-certificates/malformed-just-begin.pem
@@ -0,0 +1 @@
+-----BEGIN CERTIFICATE----- 
diff --git a/tests/auto/qsslcertificate/more-certificates/no-ending-newline.pem b/tests/auto/qsslcertificate/more-certificates/no-ending-newline.pem
new file mode 100644
index 0000000000..f8056c72d0
--- /dev/null
+++ b/tests/auto/qsslcertificate/more-certificates/no-ending-newline.pem
@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE----- 
+MIIB8zCCAVwCAREwDQYJKoZIhvcNAQEFBQAwWzELMAkGA1UEBhMCQVUxEzARBgNV 
+BAgTClF1ZWVuc2xhbmQxGjAYBgNVBAoTEUNyeXB0U29mdCBQdHkgTHRkMRswGQYD 
+VQQDExJUZXN0IENBICgxMDI0IGJpdCkwHhcNMDcwNDE3MDc0MDI2WhcNMDcwNTE3 
+MDc0MDI2WjApMRowGAYDVQQDExFuYW1lL3dpdGgvc2xhc2hlczELMAkGA1UEBhMC 
+Tk8wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAOud6QOsME+pWANExxgmL0iT 
+1ayg++hTxHsqAYnm/FoMxfUh+NdKkgJn2/GfNppinfPOSI667VqonU+7JBZDTLV5 
+CPbZIo9fFQpDJQN6naev4yaxU1VeYFfI7S8c8zYKeGSR+RenNNeLvfH80YxPpZZ1 
+snv8IfDH2V8MVxiyr7lLAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAleaU4pgzV6KY 
++q9QuXapUYMsC2GiNtDmkG3k+MTHUO8XlE4hqPrIM6rRf7zKQdZ950R2wL9FSnYl 
+Qm1Tdv38dCka6ivMBqvRuOt9axH3m0G7nzHL7U3zaCbtEx3yVln+b3yYtiVpTuq0 
+3MLrt7tQGAW6ra8ISf6YY1W65/uVXZE= 
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/tests/auto/qsslcertificate/tst_qsslcertificate.cpp b/tests/auto/qsslcertificate/tst_qsslcertificate.cpp
index 44f85224c6..c76c11fe56 100644
--- a/tests/auto/qsslcertificate/tst_qsslcertificate.cpp
+++ b/tests/auto/qsslcertificate/tst_qsslcertificate.cpp
@@ -543,6 +543,9 @@ void tst_QSslCertificate::fromPath_data()
     QTest::newRow("\"d.*/c.*.pem\" wildcard der") << QString("d.*/c.*.pem") << int(QRegExp::Wildcard) << false << 0;
 
     QTest::newRow("trailing-whitespace") << QString("more-certificates/trailing-whitespace.pem") << int(QRegExp::FixedString) << true << 1;
+    QTest::newRow("no-ending-newline") << QString("more-certificates/no-ending-newline.pem") << int(QRegExp::FixedString) << true << 1;
+    QTest::newRow("malformed-just-begin") << QString("more-certificates/malformed-just-begin.pem") << int(QRegExp::FixedString) << true << 0;
+    QTest::newRow("malformed-just-begin-no-newline") << QString("more-certificates/malformed-just-begin-no-newline.pem") << int(QRegExp::FixedString) << true << 0;
 }
 
 void tst_QSslCertificate::fromPath()
diff --git a/tests/auto/qtableview/tst_qtableview.cpp b/tests/auto/qtableview/tst_qtableview.cpp
index 7a5e68fbe1..430712c716 100644
--- a/tests/auto/qtableview/tst_qtableview.cpp
+++ b/tests/auto/qtableview/tst_qtableview.cpp
@@ -3024,6 +3024,14 @@ void tst_QTableView::spans_data()
       << QPoint(0, 0)
       << 1
       << 1;
+
+    QTest::newRow("QTBUG-6004 (follow-up): No failing Q_ASSERT, then it passes.")
+      << 10 << 10
+      << (SpanList() << QRect(2, 2, 1, 3) << QRect(2, 2, 1, 1))
+      << false
+      << QPoint(0, 0)
+      << 1
+      << 1;
 }
 
 void tst_QTableView::spans()
diff --git a/tests/auto/qurl/tst_qurl.cpp b/tests/auto/qurl/tst_qurl.cpp
index ecd6f09da0..33812fedd8 100644
--- a/tests/auto/qurl/tst_qurl.cpp
+++ b/tests/auto/qurl/tst_qurl.cpp
@@ -90,7 +90,6 @@ public slots:
 private slots:
     void getSetCheck();
     void constructing();
-    void isDetached();
     void assignment();
     void comparison();
     void copying();
@@ -319,25 +318,6 @@ void tst_QUrl::constructing()
     QVERIFY(!buildUNC.isEmpty());
 }
 
-void tst_QUrl::isDetached()
-{
-    QUrl url;
-    QVERIFY(!url.isDetached());
-
-    url = "http://qt.nokia.com/";
-    QVERIFY(url.isDetached());
-
-    url.clear();
-    QVERIFY(!url.isDetached());
-
-    url.setHost("qt.nokia.com");
-    QVERIFY(url.isDetached());
-
-    QUrl url2 = url;
-    QVERIFY(!url.isDetached());
-    QVERIFY(!url2.isDetached());
-}
-
 void tst_QUrl::assignment()
 {
     QUrl url("http://qt.nokia.com/");
diff --git a/tests/auto/qwidget/tst_qwidget.cpp b/tests/auto/qwidget/tst_qwidget.cpp
index ee4e726933..ea90ae3f82 100644
--- a/tests/auto/qwidget/tst_qwidget.cpp
+++ b/tests/auto/qwidget/tst_qwidget.cpp
@@ -5439,26 +5439,24 @@ public:
     QRegion r;
 };
 
-template<typename R, typename C>
-void verifyColor(R const& region, C const& color)
-{
-    const QRegion r = QRegion(region);
-    for (int i = 0; i < r.rects().size(); ++i) {
-        const QRect rect = r.rects().at(i);
-        for (int t = 0; t < 5; t++) {
-            const QPixmap pixmap = QPixmap::grabWindow(QDesktopWidget().winId(),
-                                                   rect.left(), rect.top(),
-                                                   rect.width(), rect.height());
-            QCOMPARE(pixmap.size(), rect.size());
-            QPixmap expectedPixmap(pixmap); /* ensure equal formats */
-            expectedPixmap.fill(color);
-            if (pixmap.toImage().pixel(0,0) != QColor(color).rgb() && t < 4 )
-            { QTest::qWait(200); continue; }
-            QCOMPARE(pixmap.toImage().pixel(0,0), QColor(color).rgb());
-            QCOMPARE(pixmap, expectedPixmap);
-            break;
-        }
-    }
+#define VERIFY_COLOR(region, color) {                                   \
+    const QRegion r = QRegion(region);                                  \
+    for (int i = 0; i < r.rects().size(); ++i) {                        \
+        const QRect rect = r.rects().at(i);                             \
+        for (int t = 0; t < 5; t++) {                                   \
+            const QPixmap pixmap = QPixmap::grabWindow(QDesktopWidget().winId(), \
+                                                   rect.left(), rect.top(), \
+                                                   rect.width(), rect.height()); \
+            QCOMPARE(pixmap.size(), rect.size());                       \
+            QPixmap expectedPixmap(pixmap); /* ensure equal formats */  \
+            expectedPixmap.fill(color);                                 \
+            if (pixmap.toImage().pixel(0,0) != QColor(color).rgb() && t < 4 ) \
+            { QTest::qWait(200); continue; }                            \
+            QCOMPARE(pixmap.toImage().pixel(0,0), QColor(color).rgb()); \
+            QCOMPARE(pixmap, expectedPixmap);                           \
+            break;                                                      \
+        }                                                               \
+    }                                                                   \
 }
 
 void tst_QWidget::moveChild_data()
@@ -5499,9 +5497,9 @@ void tst_QWidget::moveChild()
 #endif
     QTRY_COMPARE(parent.r, QRegion(parent.rect()) - child.geometry());
     QTRY_COMPARE(child.r, QRegion(child.rect()));
-    verifyColor(child.geometry().translated(tlwOffset),
+    VERIFY_COLOR(child.geometry().translated(tlwOffset),
                  child.color);
-    verifyColor(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset),
+    VERIFY_COLOR(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset),
                  parent.color);
     parent.reset();
     child.reset();
@@ -5520,9 +5518,9 @@ void tst_QWidget::moveChild()
     // should be scrolled in backingstore
     QCOMPARE(child.r, QRegion());
 #endif
-    verifyColor(child.geometry().translated(tlwOffset),
+    VERIFY_COLOR(child.geometry().translated(tlwOffset),
                 child.color);
-    verifyColor(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset),
+    VERIFY_COLOR(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset),
                 parent.color);
 }
 
@@ -5553,8 +5551,8 @@ void tst_QWidget::showAndMoveChild()
     child.move(desktopDimensions.width()/2, desktopDimensions.height()/2);
     qApp->processEvents();
 
-    verifyColor(child.geometry().translated(tlwOffset), Qt::blue);
-    verifyColor(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset), Qt::red);
+    VERIFY_COLOR(child.geometry().translated(tlwOffset), Qt::blue);
+    VERIFY_COLOR(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset), Qt::red);
 }
 
 void tst_QWidget::subtractOpaqueSiblings()
diff --git a/tests/benchmarks/qpainter/tst_qpainter.cpp b/tests/benchmarks/qpainter/tst_qpainter.cpp
index 7c6634e89b..39b2244eaf 100644
--- a/tests/benchmarks/qpainter/tst_qpainter.cpp
+++ b/tests/benchmarks/qpainter/tst_qpainter.cpp
@@ -45,6 +45,10 @@
 #include <QDialog>
 #include <QImage>
 #include <QPaintEngine>
+#include <math.h>
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
 Q_DECLARE_METATYPE(QLine)
 Q_DECLARE_METATYPE(QRect)
@@ -178,6 +182,35 @@ private slots:
     void clipAndFill_data();
     void clipAndFill();
 
+    void drawRoundedRect();
+    void drawScaledRoundedRect();
+    void drawTransformedRoundedRect();
+
+    void drawScaledAntialiasedRoundedRect_data();
+    void drawTransformedAntialiasedRoundedRect_data();
+    void drawAntialiasedRoundedRect();
+    void drawScaledAntialiasedRoundedRect();
+    void drawTransformedAntialiasedRoundedRect();
+
+    void drawScaledImageRoundedRect_data();
+    void drawTransformedImageRoundedRect_data();
+    void drawImageRoundedRect();
+    void drawScaledImageRoundedRect();
+    void drawTransformedImageRoundedRect();
+
+    void drawScaledBorderPixmapRoundedRect_data();
+    void drawTransformedBorderPixmapRoundedRect_data();
+    void drawBorderPixmapRoundedRect();
+    void drawScaledBorderPixmapRoundedRect();
+    void drawTransformedBorderPixmapRoundedRect();
+
+    void drawTransformedTransparentImage_data();
+    void drawTransformedSemiTransparentImage_data();
+    void drawTransformedFilledImage_data();
+    void drawTransformedTransparentImage();
+    void drawTransformedSemiTransparentImage();
+    void drawTransformedFilledImage();
+
 private:
     void setupBrushes();
     void createPrimitives();
@@ -185,6 +218,8 @@ private:
     void drawPrimitives_data_helper(bool fancypens);
     void fillPrimitives_helper(QPainter *painter, PrimitiveType type, PrimitiveSet *s);
 
+    QTransform transformForAngle(qreal angle);
+
     QPaintDevice *surface()
     {
         return new QPixmap(1024, 1024);
@@ -1123,6 +1158,474 @@ void tst_QPainter::clipAndFill()
     }
 }
 
+QTransform tst_QPainter::transformForAngle(qreal angle)
+{
+    const qreal inv_dist_to_plane = 1. / 1024.;
+
+    QTransform transform;
+
+    QTransform rotTrans;
+    rotTrans.translate(-40, 0);
+    QTransform rotTrans2;
+    rotTrans2.translate(40, 0);
+
+    qreal rad = angle * 2. * M_PI / 360.;
+    qreal c = ::cos(rad);
+    qreal s = ::sin(rad);
+
+    qreal x = 0;
+    qreal y = 80;
+    qreal z = 0;
+
+    qreal len = x * x + y * y + z * z;
+    if (len != 1.) {
+        len = ::sqrt(len);
+        x /= len;
+        y /= len;
+        z /= len;
+    }
+
+    QTransform rot(x*x*(1-c)+c, x*y*(1-c)-z*s, x*z*(1-c)+y*s*inv_dist_to_plane,
+                   y*x*(1-c)+z*s, y*y*(1-c)+c, y*z*(1-c)-x*s*inv_dist_to_plane,
+                   0, 0, 1);
+
+    transform *= rotTrans;
+    transform *= rot;
+    transform *= rotTrans2;
+
+    return transform;
+}
+
+void tst_QPainter::drawRoundedRect()
+{
+    QImage surface(100, 100, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    p.setPen(QPen(Qt::black, 1));
+    p.setBrush(Qt::red);
+
+    QBENCHMARK {
+        p.drawRoundedRect(QRectF(.5, .5, 80, 80), 10, 10);
+    }
+}
+
+void tst_QPainter::drawScaledRoundedRect()
+{
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    p.setPen(QPen(Qt::black, 1));
+    p.setBrush(Qt::red);
+    p.scale(3, 3);
+
+    QBENCHMARK {
+        p.drawRoundedRect(10, 10, 80, 80, 10, 10);
+    }
+}
+
+void tst_QPainter::drawTransformedRoundedRect()
+{
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    p.setPen(QPen(Qt::black, 1));
+    p.setBrush(Qt::red);
+
+    QBENCHMARK {
+        p.setWorldTransform(QTransform(0.956957, 0, 0.000704124, 0, 1, 0, 16.141, 0, 0.735953));
+        p.drawRoundedRect(100, 100, 80, 80, 10, 10);
+    }
+}
+
+void tst_QPainter::drawAntialiasedRoundedRect()
+{
+    QImage surface(100, 100, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    p.setRenderHint(QPainter::Antialiasing, true);
+    p.setPen(QPen(Qt::black, 1));
+    p.setBrush(Qt::red);
+
+    QBENCHMARK {
+        p.drawRoundedRect(QRectF(.5, .5, 80, 80), 10, 10);
+    }
+}
+
+void tst_QPainter::drawScaledAntialiasedRoundedRect_data()
+{
+    QTest::addColumn<float>("scale");
+
+    for (float i = 0; i < 3; i += .1)
+        QTest::newRow(QString(QLatin1String("scale=%1")).arg(i).toLatin1()) << i;
+}
+
+void tst_QPainter::drawScaledAntialiasedRoundedRect()
+{
+    QFETCH(float, scale);
+
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    p.setRenderHint(QPainter::Antialiasing, true);
+    p.setPen(QPen(Qt::black, 1));
+    p.setBrush(Qt::red);
+    p.scale(scale, scale);
+
+    QBENCHMARK {
+        p.drawRoundedRect(10, 10, 80, 80, 10, 10);
+    }
+}
+
+void tst_QPainter::drawTransformedAntialiasedRoundedRect_data()
+{
+    QTest::addColumn<QTransform>("transform");
+
+    for (float angle = 0; angle < 360; angle += 10)
+        QTest::newRow(QString(QLatin1String("angle=%1")).arg(angle).toLatin1()) << transformForAngle(angle);
+}
+
+void tst_QPainter::drawTransformedAntialiasedRoundedRect()
+{
+    QFETCH(QTransform, transform);
+
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    p.setRenderHint(QPainter::Antialiasing, true);
+    p.setPen(QPen(Qt::black, 1));
+    p.setBrush(Qt::red);
+
+    QBENCHMARK {
+        p.setWorldTransform(transform);
+        p.drawRoundedRect(100, 100, 80, 80, 10, 10);
+    }
+}
+
+void tst_QPainter::drawImageRoundedRect()
+{
+    //setup image
+    const int radius = 10;
+    QImage rectImage(81, 81, QImage::Format_ARGB32_Premultiplied);
+    rectImage.fill(0);
+    QPainter rp(&rectImage);
+    rp.setRenderHint(QPainter::Antialiasing);
+    rp.setPen(Qt::black);
+    rp.setBrush(Qt::red);
+    rp.drawRoundedRect(QRectF(.5, .5, 80, 80), radius, radius);
+
+    //setup surface
+    QImage surface(100, 100, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        p.drawImage(0,0, rectImage);
+    }
+}
+
+void tst_QPainter::drawScaledImageRoundedRect_data()
+{
+    QTest::addColumn<int>("imageType");
+
+    QTest::newRow("imagetype=ARGB32_Pre") << (int)QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("imagetype=ARGB8565_Pre") << (int)QImage::Format_ARGB8565_Premultiplied;
+}
+
+void tst_QPainter::drawScaledImageRoundedRect()
+{
+    QFETCH(int, imageType);
+
+    //setup image
+    const int radius = 10;
+    QImage rectImage(81, 81, (QImage::Format)imageType);
+    rectImage.fill(0);
+    QPainter rp(&rectImage);
+    rp.setRenderHint(QPainter::Antialiasing);
+    rp.setPen(Qt::black);
+    rp.setBrush(Qt::red);
+    rp.drawRoundedRect(QRectF(.5, .5, 80, 80), radius, radius);
+
+    //setup surface
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+    p.scale(3, 3);
+
+    QBENCHMARK {
+        p.drawImage(0,0, rectImage);
+    }
+}
+
+void tst_QPainter::drawTransformedImageRoundedRect_data()
+{
+    QTest::addColumn<int>("imageType");
+
+    QTest::newRow("imagetype=ARGB32_Pre") << (int)QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("imagetype=ARGB8565_Pre") << (int)QImage::Format_ARGB8565_Premultiplied;
+}
+
+void tst_QPainter::drawTransformedImageRoundedRect()
+{
+    QFETCH(int, imageType);
+
+    //setup image
+    const int radius = 10;
+    QImage rectImage(81, 81, (QImage::Format)imageType);
+    rectImage.fill(0);
+    QPainter rp(&rectImage);
+    rp.setRenderHint(QPainter::Antialiasing);
+    rp.setPen(Qt::black);
+    rp.setBrush(Qt::red);
+    rp.drawRoundedRect(QRectF(.5, .5, 80, 80), radius, radius);
+
+    //setup surface
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        p.setWorldTransform(QTransform(0.956957, 0, 0.000704124, 0, 1, 0, 16.141, 0, 0.735953));
+        p.drawImage(100,100, rectImage);
+    }
+}
+
+//code from QmlGraphicsRectangle for drawing rounded rects
+void tst_QPainter::drawBorderPixmapRoundedRect()
+{
+    //setup image
+    const int pw = 1;
+    const int radius = 10;
+    QImage rectImage(radius*2 + 3 + pw*2, radius*2 + 3 + pw*2, QImage::Format_ARGB32_Premultiplied);
+    rectImage.fill(0);
+    QPainter rp(&rectImage);
+    rp.setRenderHint(QPainter::Antialiasing);
+    rp.setPen(Qt::black);
+    rp.setBrush(Qt::red);
+    if (pw%2)
+        rp.drawRoundedRect(QRectF(qreal(pw)/2+1, qreal(pw)/2+1, rectImage.width()-(pw+1), rectImage.height()-(pw+1)), radius, radius);
+    else
+        rp.drawRoundedRect(QRectF(qreal(pw)/2, qreal(pw)/2, rectImage.width()-pw, rectImage.height()-pw), radius, radius);
+    QPixmap rectPixmap = QPixmap::fromImage(rectImage);
+
+    //setup surface
+    QImage surface(100, 100, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        const int pw = 2;
+        int width = 80;
+        int height = 80;
+
+        int xOffset = (rectPixmap.width()-1)/2;
+        int yOffset = (rectPixmap.height()-1)/2;
+        Q_ASSERT(rectPixmap.width() == 2*xOffset + 1);
+        Q_ASSERT(rectPixmap.height() == 2*yOffset + 1);
+
+        QMargins margins(xOffset, yOffset, xOffset, yOffset);
+        QTileRules rules(Qt::StretchTile, Qt::StretchTile);
+        //NOTE: even though our item may have qreal-based width and height, qDrawBorderPixmap only supports QRects
+        qDrawBorderPixmap(&p, QRect(-pw/2, -pw/2, width+pw, height+pw), margins, rectPixmap, rectPixmap.rect(), margins, rules);
+    }
+}
+
+void tst_QPainter::drawScaledBorderPixmapRoundedRect_data()
+{
+    QTest::addColumn<float>("scale");
+    QTest::addColumn<int>("imageType");
+
+    for (float i = 0; i < 3; i += .1)
+        QTest::newRow(QString(QLatin1String("scale=%1; imagetype=ARGB32_Pre")).arg(i).toLatin1()) << i << (int)QImage::Format_ARGB32_Premultiplied;
+    //for (float i = 0; i < 3; i += .1)
+    //    QTest::newRow(QString(QLatin1String("scale=%1; imagetype=ARGB8565_Pre")).arg(i).toLatin1()) << i << (int)QImage::Format_ARGB8565_Premultiplied;
+}
+
+//code from QmlGraphicsRectangle for drawing rounded rects
+void tst_QPainter::drawScaledBorderPixmapRoundedRect()
+{
+    QFETCH(float, scale);
+    QFETCH(int, imageType);
+
+    //setup image
+    const int pw = 1;
+    const int radius = 10;
+    QImage rectImage(radius*2 + 3 + pw*2, radius*2 + 3 + pw*2, (QImage::Format)imageType);
+    rectImage.fill(0);
+    QPainter rp(&rectImage);
+    rp.setRenderHint(QPainter::Antialiasing);
+    rp.setPen(Qt::black);
+    rp.setBrush(Qt::red);
+    if (pw%2)
+        rp.drawRoundedRect(QRectF(qreal(pw)/2+1, qreal(pw)/2+1, rectImage.width()-(pw+1), rectImage.height()-(pw+1)), radius, radius);
+    else
+        rp.drawRoundedRect(QRectF(qreal(pw)/2, qreal(pw)/2, rectImage.width()-pw, rectImage.height()-pw), radius, radius);
+
+    QPixmap rectPixmap = QPixmap::fromImage(rectImage);
+
+    //setup surface
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+    p.scale(scale, scale);
+
+    QBENCHMARK {
+        const int pw = 2;
+        int width = 80;
+        int height = 80;
+
+        int xOffset = (rectPixmap.width()-1)/2;
+        int yOffset = (rectPixmap.height()-1)/2;
+        Q_ASSERT(rectPixmap.width() == 2*xOffset + 1);
+        Q_ASSERT(rectPixmap.height() == 2*yOffset + 1);
+
+        QMargins margins(xOffset, yOffset, xOffset, yOffset);
+        QTileRules rules(Qt::StretchTile, Qt::StretchTile);
+        qDrawBorderPixmap(&p, QRect(-pw/2, -pw/2, width+pw, height+pw), margins, rectPixmap, rectPixmap.rect(), margins, rules);
+    }
+}
+
+void tst_QPainter::drawTransformedBorderPixmapRoundedRect_data()
+{
+    QTest::addColumn<QTransform>("transform");
+    QTest::addColumn<int>("imageType");
+
+    for (float angle = 0; angle < 360; angle += 10)
+        QTest::newRow(QString(QLatin1String("angle=%1; imagetype=ARGB32_Pre")).arg(angle).toLatin1()) << transformForAngle(angle) << (int)QImage::Format_ARGB32_Premultiplied;
+    //for (float angle = 0; angle < 360; angle += 10)
+    //    QTest::newRow(QString(QLatin1String("angle=%1; imagetype=ARGB8565_Pre")).arg(angle).toLatin1()) << transformForAngle(angle) << (int)QImage::Format_ARGB8565_Premultiplied;
+
+}
+
+//code from QmlGraphicsRectangle for drawing rounded rects
+void tst_QPainter::drawTransformedBorderPixmapRoundedRect()
+{
+    QFETCH(QTransform, transform);
+    QFETCH(int, imageType);
+
+    //setup image
+    const int pw = 1;
+    const int radius = 10;
+    QImage rectImage(radius*2 + 3 + pw*2, radius*2 + 3 + pw*2, (QImage::Format)imageType);
+    rectImage.fill(0);
+    QPainter rp(&rectImage);
+    rp.setRenderHint(QPainter::Antialiasing);
+    rp.setPen(Qt::black);
+    rp.setBrush(Qt::red);
+    if (pw%2)
+        rp.drawRoundedRect(QRectF(qreal(pw)/2+1, qreal(pw)/2+1, rectImage.width()-(pw+1), rectImage.height()-(pw+1)), radius, radius);
+    else
+        rp.drawRoundedRect(QRectF(qreal(pw)/2, qreal(pw)/2, rectImage.width()-pw, rectImage.height()-pw), radius, radius);
+
+    QPixmap rectPixmap = QPixmap::fromImage(rectImage);
+
+    //setup surface
+    QImage surface(400, 400, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        p.setWorldTransform(transform);
+        const int pw = 2;
+        int width = 80;
+        int height = 80;
+
+        int xOffset = (rectPixmap.width()-1)/2;
+        int yOffset = (rectPixmap.height()-1)/2;
+        Q_ASSERT(rectPixmap.width() == 2*xOffset + 1);
+        Q_ASSERT(rectPixmap.height() == 2*yOffset + 1);
+
+        QMargins margins(xOffset, yOffset, xOffset, yOffset);
+        QTileRules rules(Qt::StretchTile, Qt::StretchTile);
+        qDrawBorderPixmap(&p, QRect(-pw/2, -pw/2, width+pw, height+pw), margins, rectPixmap, rectPixmap.rect(), margins, rules);
+    }
+}
+
+void tst_QPainter::drawTransformedTransparentImage_data()
+{
+    QTest::addColumn<int>("imageType");
+
+    QTest::newRow("imagetype=ARGB32_Pre") << (int)QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("imagetype=ARGB8565_Pre") << (int)QImage::Format_ARGB8565_Premultiplied;
+}
+
+void tst_QPainter::drawTransformedTransparentImage()
+{
+    QFETCH(int, imageType);
+
+    //setup image
+    QImage transImage(200, 200, (QImage::Format)imageType);
+    transImage.fill(0);
+
+    //setup surface
+    QImage surface(200, 200, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        p.setWorldTransform(QTransform(0.956957, 0, 0.000704124, 0, 1, 0, 16.141, 0, 0.735953));
+        p.drawImage(0,0, transImage);
+    }
+}
+
+void tst_QPainter::drawTransformedSemiTransparentImage_data()
+{
+    QTest::addColumn<int>("imageType");
+
+    QTest::newRow("imagetype=ARGB32_Pre") << (int)QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("imagetype=ARGB8565_Pre") << (int)QImage::Format_ARGB8565_Premultiplied;
+}
+
+void tst_QPainter::drawTransformedSemiTransparentImage()
+{
+    QFETCH(int, imageType);
+
+    //setup image
+    QImage transImage(200, 200, (QImage::Format)imageType);
+    transImage.fill(QColor(0,0,0, 128).rgba());
+
+    //setup surface
+    QImage surface(200, 200, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        p.setWorldTransform(QTransform(0.956957, 0, 0.000704124, 0, 1, 0, 16.141, 0, 0.735953));
+        p.drawImage(0,0, transImage);
+    }
+}
+
+void tst_QPainter::drawTransformedFilledImage_data()
+{
+    QTest::addColumn<int>("imageType");
+
+    QTest::newRow("imagetype=ARGB32_Pre") << (int)QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("imagetype=ARGB8565_Pre") << (int)QImage::Format_ARGB8565_Premultiplied;
+}
+
+void tst_QPainter::drawTransformedFilledImage()
+{
+    QFETCH(int, imageType);
+
+    //setup image
+    QImage filledImage(200, 200, (QImage::Format)imageType);
+    filledImage.fill(QColor(0,0,0).rgb());
+
+    //setup surface
+    QImage surface(200, 200, QImage::Format_RGB16);
+    surface.fill(QColor(255,255,255).rgb());
+    QPainter p(&surface);
+
+    QBENCHMARK {
+        p.setWorldTransform(QTransform(0.956957, 0, 0.000704124, 0, 1, 0, 16.141, 0, 0.735953));
+        p.drawImage(0,0, filledImage);
+    }
+}
 
 
 QTEST_MAIN(tst_QPainter)
diff --git a/tests/benchmarks/qtext/main.cpp b/tests/benchmarks/qtext/main.cpp
index 4bd2beed46..9854a9f72c 100644
--- a/tests/benchmarks/qtext/main.cpp
+++ b/tests/benchmarks/qtext/main.cpp
@@ -44,7 +44,10 @@
 #include <QTextDocumentWriter>
 #include <QTextLayout>
 #include <QTextCursor>
+#include <private/qtextcontrol_p.h>
+#include <qmath.h>
 #include <QFile>
+#include <QPainter>
 #include <QBuffer>
 #include <qtest.h>
 
@@ -56,6 +59,7 @@ class tst_QText: public QObject
 public:
     tst_QText() {
         m_lorem = QString::fromLatin1("Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi.");
+        m_shortLorem = QString::fromLatin1("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
     }
 
 private slots:
@@ -69,8 +73,26 @@ private slots:
     void odfWriting_text();
     void odfWriting_images();
 
+    void constructControl();
+    void constructDocument();
+
+    void layout();
+    void paintLayoutToPixmap();
+    void paintLayoutToPixmap_painterFill();
+
+    void document();
+    void paintDocToPixmap();
+    void paintDocToPixmap_painterFill();
+
+    void control();
+    void paintControlToPixmap();
+    void paintControlToPixmap_painterFill();
+
 private:
+    QSize setupTextLayout(QTextLayout *layout);
+
     QString m_lorem;
+    QString m_shortLorem;
 };
 
 void tst_QText::loadHtml_data()
@@ -195,6 +217,189 @@ void tst_QText::odfWriting_images()
     delete doc;
 }
 
+QSize tst_QText::setupTextLayout(QTextLayout *layout)
+{
+    bool wrap = true;
+    int wrapWidth = 300;
+    layout->setCacheEnabled(true);
+
+    int height = 0;
+    qreal widthUsed = 0;
+    qreal lineWidth = 0;
+
+    //set manual width
+    if (wrap)
+        lineWidth = wrapWidth;
+
+    layout->beginLayout();
+
+    while (1) {
+        QTextLine line = layout->createLine();
+        if (!line.isValid())
+            break;
+
+        if (wrap)
+            line.setLineWidth(lineWidth);
+    }
+    layout->endLayout();
+
+    for (int i = 0; i < layout->lineCount(); ++i) {
+        QTextLine line = layout->lineAt(i);
+        widthUsed = qMax(widthUsed, line.naturalTextWidth());
+        line.setPosition(QPointF(0, height));
+        height += int(line.height());
+    }
+    return QSize(qCeil(widthUsed), height);
+}
+
+void tst_QText::constructControl()
+{
+    QTextControl *control = new QTextControl;
+    delete control;
+
+    QBENCHMARK {
+        QTextControl *control = new QTextControl;
+        delete control;
+    }
+}
+
+void tst_QText::constructDocument()
+{
+    QTextDocument *doc = new QTextDocument;
+    delete doc;
+
+    QBENCHMARK {
+        QTextDocument *doc = new QTextDocument;
+        delete doc;
+    }
+}
+
+void tst_QText::layout()
+{
+    QTextLayout layout(m_shortLorem);
+    setupTextLayout(&layout);
+
+    QBENCHMARK {
+        QTextLayout layout(m_shortLorem);
+        setupTextLayout(&layout);
+    }
+}
+
+void tst_QText::paintLayoutToPixmap()
+{
+    QTextLayout layout(m_shortLorem);
+    QSize size = setupTextLayout(&layout);
+
+    QBENCHMARK {
+        QPixmap img(size);
+        img.fill(Qt::transparent);
+        QPainter p(&img);
+        layout.draw(&p, QPointF(0, 0));
+    }
+}
+
+void tst_QText::paintLayoutToPixmap_painterFill()
+{
+    QTextLayout layout(m_shortLorem);
+    QSize size = setupTextLayout(&layout);
+
+    QBENCHMARK {
+        QPixmap img(size);
+        QPainter p(&img);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        p.fillRect(0, 0, img.width(), img.height(), Qt::transparent);
+        p.setCompositionMode(QPainter::CompositionMode_SourceOver);
+        layout.draw(&p, QPointF(0, 0));
+    }
+}
+
+void tst_QText::document()
+{
+    QTextDocument *doc = new QTextDocument;
+
+    QBENCHMARK {
+        QTextDocument *doc = new QTextDocument;
+        doc->setHtml(m_shortLorem);
+    }
+}
+
+void tst_QText::paintDocToPixmap()
+{
+    QTextDocument *doc = new QTextDocument;
+    doc->setHtml(m_shortLorem);
+    doc->setTextWidth(300);
+    QSize size = doc->size().toSize();
+
+    QBENCHMARK {
+        QPixmap img(size);
+        img.fill(Qt::transparent);
+        QPainter p(&img);
+        doc->drawContents(&p);
+    }
+}
+
+void tst_QText::paintDocToPixmap_painterFill()
+{
+    QTextDocument *doc = new QTextDocument;
+    doc->setHtml(m_shortLorem);
+    doc->setTextWidth(300);
+    QSize size = doc->size().toSize();
+
+    QBENCHMARK {
+        QPixmap img(size);
+        QPainter p(&img);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        p.fillRect(0, 0, img.width(), img.height(), Qt::transparent);
+        p.setCompositionMode(QPainter::CompositionMode_SourceOver);
+        doc->drawContents(&p);
+    }
+}
+
+void tst_QText::control()
+{
+    QTextControl *control = new QTextControl(m_shortLorem);
+
+    QBENCHMARK {
+        QTextControl *control = new QTextControl;
+        QTextDocument *doc = control->document();
+        doc->setHtml(m_shortLorem);
+    }
+}
+
+void tst_QText::paintControlToPixmap()
+{
+    QTextControl *control = new QTextControl;
+    QTextDocument *doc = control->document();
+    doc->setHtml(m_shortLorem);
+    doc->setTextWidth(300);
+    QSize size = doc->size().toSize();
+
+    QBENCHMARK {
+        QPixmap img(size);
+        img.fill(Qt::transparent);
+        QPainter p(&img);
+        control->drawContents(&p, QRectF(QPointF(0, 0), QSizeF(size)));
+    }
+}
+
+void tst_QText::paintControlToPixmap_painterFill()
+{
+    QTextControl *control = new QTextControl;
+    QTextDocument *doc = control->document();
+    doc->setHtml(m_shortLorem);
+    doc->setTextWidth(300);
+    QSize size = doc->size().toSize();
+
+    QBENCHMARK {
+        QPixmap img(size);
+        QPainter p(&img);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        p.fillRect(0, 0, img.width(), img.height(), Qt::transparent);
+        p.setCompositionMode(QPainter::CompositionMode_SourceOver);
+        control->drawContents(&p, QRectF(QPointF(0, 0), QSizeF(size)));
+    }
+}
+
 QTEST_MAIN(tst_QText)
 
 #include "main.moc"