3 files changed, 169 insertions, 1 deletions

diff --git a/tests/auto/qdatastream/tst_qdatastream.cpp b/tests/auto/qdatastream/tst_qdatastream.cpp
index 31e12fe..c03bc71 100644
--- a/tests/auto/qdatastream/tst_qdatastream.cpp
+++ b/tests/auto/qdatastream/tst_qdatastream.cpp
@@ -1820,7 +1820,7 @@ void tst_QDataStream::stream_QPixmap()
 #ifdef Q_OS_WINCE
     QSKIP("Test depends on more memory than available on Qt/CE", SkipAll);
 #endif
-    STREAM_IMPL(QIcon);
+    STREAM_IMPL(QPixmap);
 }
 
 void tst_QDataStream::stream_QIcon_data()
diff --git a/tests/auto/qtreeview/tst_qtreeview.cpp b/tests/auto/qtreeview/tst_qtreeview.cpp
index 75a4c62..7e2e800 100644
--- a/tests/auto/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/qtreeview/tst_qtreeview.cpp
@@ -239,6 +239,7 @@ private slots:
     void doubleClickedWithSpans();
     void taskQTBUG_6450_selectAllWith1stColumnHidden();
     void taskQTBUG_9216_setSizeAndUniformRowHeightsWrongRepaint();
+    void taskQTBUG_11466_keyboardNavigationRegression();
 };
 
 class QtTestModel: public QAbstractItemModel
@@ -3785,5 +3786,129 @@ void tst_QTreeView::keyboardNavigationWithDisabled()
     QCOMPARE(view.currentIndex(), model.index(6, 0));
 }
 
+class Model_11466 : public QAbstractItemModel
+{
+    Q_OBJECT
+public:
+    Model_11466(QObject *parent) :
+        m_block(false)
+    {
+        // set up the model to have two top level items and a few others
+        m_selectionModel = new QItemSelectionModel(this, this); // owned by this
+
+        connect(m_selectionModel, SIGNAL(currentChanged(const QModelIndex &,const QModelIndex &)),
+                this, SLOT(slotCurrentChanged(const QModelIndex &,const QModelIndex &)));
+    };
+
+    int rowCount(const QModelIndex &parent) const
+    {
+        if (parent.isValid())
+            return (parent.internalId() == 0) ? 4 : 0;
+        return 2; // two top level items
+    }
+
+    int columnCount(const QModelIndex &parent) const
+    {
+        return 2;
+    }
+
+    QVariant data(const QModelIndex &index, int role) const
+    {
+        if (role == Qt::DisplayRole && index.isValid()) {
+            qint64 parentRowPlusOne = index.internalId();
+            QString str;
+            QTextStream stream(&str);
+            if (parentRowPlusOne > 0)
+                stream << parentRowPlusOne << " -> " << index.row() << " : " << index.column();
+            else
+                stream << index.row() << " : " << index.column();
+            return QVariant(str);
+        }
+        return QVariant();
+    }
+
+    QModelIndex parent(const QModelIndex &index) const
+    {
+        if (index.isValid()) {
+            qint64 parentRowPlusOne = index.internalId();
+            if (parentRowPlusOne > 0) {
+                int row = static_cast<int>(parentRowPlusOne - 1);
+                return createIndex(row, 0, (quint32)0);
+            }
+        }
+        return QModelIndex();
+    }
+
+    void bindView(QTreeView *view)
+    {
+        // sets the view to this model with a shared selection model
+        QItemSelectionModel *oldModel = view->selectionModel();
+        if (oldModel != m_selectionModel)
+            delete oldModel;
+        view->setModel(this); // this creates a new selection model for the view, but we dont want it either ...
+        oldModel = view->selectionModel();
+        view->setSelectionModel(m_selectionModel);
+        delete oldModel;
+    }
+
+    QModelIndex index(int row, int column, const QModelIndex &parent) const
+    {
+        return createIndex(row, column, parent.isValid() ? (quint32)(parent.row() + 1) : (quint32)0);
+    }
+
+public slots:
+    void slotCurrentChanged(const QModelIndex &current,const QModelIndex &)
+    {
+        if (m_block)
+            return;
+
+        if (current.isValid()) {
+            int selectedRow = current.row();
+            quint32 parentRowPlusOne = static_cast<quint32>(current.internalId());
+
+            for (int i = 0; i < 2; ++i) {
+                // announce the removal of all non top level items
+                beginRemoveRows(createIndex(i, 0, 0), 0, 3);
+                // nothing to actually do for the removal
+                endRemoveRows();
+
+                // put them back in again
+                beginInsertRows(createIndex(i, 0, 0), 0, 3);
+                // nothing to actually do for the insertion
+                endInsertRows();
+            }
+            // reselect the current item ...
+            QModelIndex selectedIndex = createIndex(selectedRow, 0, parentRowPlusOne);
+
+            m_block = true; // recursion block
+            m_selectionModel->select(selectedIndex, QItemSelectionModel::ClearAndSelect|QItemSelectionModel::Current|QItemSelectionModel::Rows);
+            m_selectionModel->setCurrentIndex(selectedIndex, QItemSelectionModel::NoUpdate);
+            m_block = false;
+        } else {
+            m_selectionModel->clear();
+        }
+    }
+
+private:
+    bool m_block;
+    QItemSelectionModel *m_selectionModel;
+};
+
+void tst_QTreeView::taskQTBUG_11466_keyboardNavigationRegression()
+{
+    QTreeView treeView;
+    treeView.setSelectionBehavior(QAbstractItemView::SelectRows);
+    treeView.setSelectionMode(QAbstractItemView::SingleSelection);
+    Model_11466 model(&treeView);
+    model.bindView(&treeView);
+    treeView.expandAll();
+    treeView.show();
+    QTest::qWaitForWindowShown(&treeView);
+
+    QTest::keyPress(treeView.viewport(), Qt::Key_Down);
+    QTest::qWait(10);
+    QTRY_COMPARE(treeView.currentIndex(), treeView.selectionModel()->selection().indexes().first());
+}
+
 QTEST_MAIN(tst_QTreeView)
 #include "tst_qtreeview.moc"
diff --git a/tests/benchmarks/gui/image/blendbench/main.cpp b/tests/benchmarks/gui/image/blendbench/main.cpp
index f53654b..d420d6c 100644
--- a/tests/benchmarks/gui/image/blendbench/main.cpp
+++ b/tests/benchmarks/gui/image/blendbench/main.cpp
@@ -106,6 +106,9 @@ private slots:
 
     void blendBenchAlpha_data();
     void blendBenchAlpha();
+
+    void unalignedBlendArgb32_data();
+    void unalignedBlendArgb32();
 };
 
 void BlendBench::blendBench_data()
@@ -179,6 +182,46 @@ void BlendBench::blendBenchAlpha()
     }
 }
 
+void BlendBench::unalignedBlendArgb32_data()
+{
+    // The performance of blending can depend of the alignment of the data
+    // on 16 bytes. Some SIMD instruction set have significantly better
+    // memory access when the memory is aligned on 16 bytes boundary.
+
+    // offset in 32 bits words
+    QTest::addColumn<int>("offset");
+    QTest::newRow("aligned on 16 bytes") << 0;
+    QTest::newRow("unaligned by 4 bytes") << 1;
+    QTest::newRow("unaligned by 8 bytes") << 2;
+    QTest::newRow("unaligned by 12 bytes") << 3;
+}
+
+void BlendBench::unalignedBlendArgb32()
+{
+    const int dimension = 1024;
+
+    // We use dst aligned by design. We don't want to test all the combination of alignemnt for src and dst.
+    // Moreover, it make sense for us to align dst in the implementation because it is accessed more often.
+    uchar *dstMemory = static_cast<uchar*>(qMallocAligned((dimension * dimension * sizeof(quint32)), 16));
+    QImage destination(dstMemory, dimension, dimension, QImage::Format_ARGB32_Premultiplied);
+    destination.fill(0x12345678); // avoid special cases of alpha
+
+    uchar *srcMemory = static_cast<uchar*>(qMallocAligned((dimension * dimension * sizeof(quint32)) + 16, 16));
+    QFETCH(int, offset);
+    srcMemory += (offset * sizeof(quint32));
+
+    QImage src(srcMemory, dimension, dimension, QImage::Format_ARGB32_Premultiplied);
+    src.fill(0x87654321);
+
+    QPainter painter(&destination);
+    QBENCHMARK {
+        painter.drawImage(QPoint(), src);
+    }
+
+    qFreeAligned(srcMemory);
+    qFreeAligned(dstMemory);
+}
+
 QTEST_MAIN(BlendBench)
 
 #include "main.moc"