Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

3 files changed, 2605 insertions, 0 deletions

diff --git a/tests/auto/qcombobox/.gitignore b/tests/auto/qcombobox/.gitignore
new file mode 100644
index 0000000000..0db112206b
--- /dev/null
+++ b/tests/auto/qcombobox/.gitignore
@@ -0,0 +1 @@
+tst_qcombobox
diff --git a/tests/auto/qcombobox/qcombobox.pro b/tests/auto/qcombobox/qcombobox.pro
new file mode 100644
index 0000000000..f36a6fe622
--- /dev/null
+++ b/tests/auto/qcombobox/qcombobox.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+SOURCES  += tst_qcombobox.cpp
+contains(QT_CONFIG, qt3support): QT += qt3support
+
diff --git a/tests/auto/qcombobox/tst_qcombobox.cpp b/tests/auto/qcombobox/tst_qcombobox.cpp
new file mode 100644
index 0000000000..d525068893
--- /dev/null
+++ b/tests/auto/qcombobox/tst_qcombobox.cpp
@@ -0,0 +1,2600 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+
+#include "qcombobox.h"
+#include <private/qcombobox_p.h>
+
+#include <qfontcombobox.h>
+#include <qdesktopwidget.h>
+#include <qapplication.h>
+#include <qpushbutton.h>
+#include <qdialog.h>
+#include <qevent.h>
+#include <qlineedit.h>
+#include <qlistview.h>
+#include <qheaderview.h>
+#include <qlistwidget.h>
+#include <qtreewidget.h>
+#include <qtablewidget.h>
+#include <qscrollbar.h>
+#include <qboxlayout.h>
+#ifdef Q_WS_MAC
+#include <qmacstyle_mac.h>
+#elif defined Q_WS_X11
+#include <private/qt_x11_p.h>
+#endif
+
+#include <qstandarditemmodel.h>
+#include <qstringlistmodel.h>
+#include <qcombobox.h>
+#include <qpushbutton.h>
+#include <qdialog.h>
+#include <qstringlist.h>
+#include <qvalidator.h>
+#include <qcompleter.h>
+#ifndef QT_NO_STYLE_CLEANLOOKS
+#include <qcleanlooksstyle.h>
+#endif
+#include <qabstractitemview.h>
+#include "../../shared/util.h"
+#include <qstyleditemdelegate.h>
+#ifndef QT_NO_STYLE_WINDOWS
+#include <qwindowsstyle.h>
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QComboBox : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QComboBox();
+    ~tst_QComboBox();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void getSetCheck();
+    void ensureReturnIsIgnored();
+    void setEditable();
+    void setPalette();
+    void sizeAdjustPolicy();
+    void clear();
+    void insertPolicy_data();
+    void insertPolicy();
+    void virtualAutocompletion();
+    void autoCompletionCaseSensitivity();
+    void hide();
+    void currentIndex_data();
+    void currentIndex();
+    void insertItems_data();
+    void insertItems();
+    void insertItem_data();
+    void insertItem();
+    void insertOnCurrentIndex();
+    void textpixmapdata_data();
+    void textpixmapdata();
+    void editTextChanged();
+    void setModel();
+    void modelDeleted();
+    void setMaxCount();
+    void setCurrentIndex();
+    void convenienceViews();
+    void findText_data();
+    void findText();
+    void flaggedItems_data();
+    void flaggedItems();
+    void pixmapIcon();
+    void mouseWheel_data();
+    void mouseWheel();
+    void layoutDirection();
+    void itemListPosition();
+    void separatorItem_data();
+    void separatorItem();
+    void task190351_layout();
+    void task191329_size();
+    void task166349_setEditableOnReturn();
+    void task190205_setModelAdjustToContents();
+    void task248169_popupWithMinimalSize();
+    void task247863_keyBoardSelection();
+    void task220195_keyBoardSelection2();
+    void setModelColumn();
+    void noScrollbar_data();
+    void noScrollbar();
+    void setItemDelegate();
+    void task253944_itemDelegateIsReset();
+    void subControlRectsWithOffset_data();
+    void subControlRectsWithOffset();
+    void task260974_menuItemRectangleForComboBoxPopup();
+    void removeItem();
+    void resetModel();
+    void keyBoardNavigationWithMouse();
+    void task_QTBUG_1071_changingFocusEmitsActivated();
+    void maxVisibleItems();
+    void task_QTBUG_10491_currentIndexAndModelColumn();
+
+protected slots:
+    void onEditTextChanged( const QString &newString );
+
+private:
+    QComboBox *testWidget;
+    QWidget *parent;
+    QPushButton* ok;
+    int editTextCount;
+    QString editText;
+};
+
+class MyAbstractItemDelegate : public QAbstractItemDelegate
+{
+public:
+    MyAbstractItemDelegate() : QAbstractItemDelegate() {};
+    void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const {}
+    QSize sizeHint(const QStyleOptionViewItem &, const QModelIndex &) const { return QSize(); }
+};
+
+class MyAbstractItemModel: public QAbstractItemModel
+{
+public:
+    MyAbstractItemModel() : QAbstractItemModel() {};
+    QModelIndex index(int, int, const QModelIndex &) const { return QModelIndex(); }
+    QModelIndex parent(const QModelIndex &) const  { return QModelIndex(); }
+    int rowCount(const QModelIndex &) const { return 0; }
+    int columnCount(const QModelIndex &) const { return 0; }
+    bool hasChildren(const QModelIndex &) const { return false; }
+    QVariant data(const QModelIndex &, int) const { return QVariant(); }
+    bool setData(const QModelIndex &, const QVariant &, int) { return false; }
+    bool insertRows(int, int, const QModelIndex &) { return false; }
+    bool insertColumns(int, int, const QModelIndex &) { return false; }
+    void setPersistent(const QModelIndex &, const QModelIndex &) {}
+    bool removeRows (int, int, const QModelIndex &) { return false; }
+    bool removeColumns(int, int, const QModelIndex &) { return false; }
+    void reset() {}
+};
+
+class MyAbstractItemView : public QAbstractItemView
+{
+public:
+    MyAbstractItemView() : QAbstractItemView() {}
+    QRect visualRect(const QModelIndex &) const { return QRect(); }
+    void scrollTo(const QModelIndex &, ScrollHint) {}
+    QModelIndex indexAt(const QPoint &) const { return QModelIndex(); }
+protected:
+    QModelIndex moveCursor(CursorAction, Qt::KeyboardModifiers) { return QModelIndex(); }
+    int horizontalOffset() const { return 0; }
+    int verticalOffset() const { return 0; }
+    bool isIndexHidden(const QModelIndex &) const { return false; }
+    void setSelection(const QRect &, QItemSelectionModel::SelectionFlags) {}
+    QRegion visualRegionForSelection(const QItemSelection &) const { return QRegion(); }
+};
+
+// Testing get/set functions
+void tst_QComboBox::getSetCheck()
+{
+    QComboBox obj1;
+    // int QComboBox::maxVisibleItems()
+    // void QComboBox::setMaxVisibleItems(int)
+    obj1.setMaxVisibleItems(100);
+    QCOMPARE(100, obj1.maxVisibleItems());
+    obj1.setMaxVisibleItems(0);
+    QCOMPARE(obj1.maxVisibleItems(), 0);
+    QTest::ignoreMessage(QtWarningMsg, "QComboBox::setMaxVisibleItems: "
+                         "Invalid max visible items (-2147483648) must be >= 0");
+    obj1.setMaxVisibleItems(INT_MIN);
+    QCOMPARE(obj1.maxVisibleItems(), 0); // Cannot be set to something negative => old value
+    obj1.setMaxVisibleItems(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.maxVisibleItems());
+
+    // int QComboBox::maxCount()
+    // void QComboBox::setMaxCount(int)
+    obj1.setMaxCount(0);
+    QCOMPARE(0, obj1.maxCount());
+#ifndef QT_DEBUG
+    QTest::ignoreMessage(QtWarningMsg, "QComboBox::setMaxCount: Invalid count (-2147483648) must be >= 0");
+    obj1.setMaxCount(INT_MIN);
+    QCOMPARE(0, obj1.maxCount()); // Setting a value below 0 makes no sense, and shouldn't be allowed
+#endif
+    obj1.setMaxCount(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.maxCount());
+
+    // bool QComboBox::autoCompletion()
+    // void QComboBox::setAutoCompletion(bool)
+    obj1.setAutoCompletion(false);
+    QCOMPARE(false, obj1.autoCompletion());
+    obj1.setAutoCompletion(true);
+    QCOMPARE(true, obj1.autoCompletion());
+
+    // bool QComboBox::duplicatesEnabled()
+    // void QComboBox::setDuplicatesEnabled(bool)
+    obj1.setDuplicatesEnabled(false);
+    QCOMPARE(false, obj1.duplicatesEnabled());
+    obj1.setDuplicatesEnabled(true);
+    QCOMPARE(true, obj1.duplicatesEnabled());
+
+    // InsertPolicy QComboBox::insertPolicy()
+    // void QComboBox::setInsertPolicy(InsertPolicy)
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::NoInsert));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::NoInsert), obj1.insertPolicy());
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::InsertAtTop));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::InsertAtTop), obj1.insertPolicy());
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::InsertAtCurrent));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::InsertAtCurrent), obj1.insertPolicy());
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::InsertAtBottom));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::InsertAtBottom), obj1.insertPolicy());
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::InsertAfterCurrent));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::InsertAfterCurrent), obj1.insertPolicy());
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::InsertBeforeCurrent));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::InsertBeforeCurrent), obj1.insertPolicy());
+    obj1.setInsertPolicy(QComboBox::InsertPolicy(QComboBox::InsertAlphabetically));
+    QCOMPARE(QComboBox::InsertPolicy(QComboBox::InsertAlphabetically), obj1.insertPolicy());
+
+    // SizeAdjustPolicy QComboBox::sizeAdjustPolicy()
+    // void QComboBox::setSizeAdjustPolicy(SizeAdjustPolicy)
+    obj1.setSizeAdjustPolicy(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToContents));
+    QCOMPARE(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToContents), obj1.sizeAdjustPolicy());
+    obj1.setSizeAdjustPolicy(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToContentsOnFirstShow));
+    QCOMPARE(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToContentsOnFirstShow), obj1.sizeAdjustPolicy());
+    obj1.setSizeAdjustPolicy(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength));
+    QCOMPARE(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength), obj1.sizeAdjustPolicy());
+    obj1.setSizeAdjustPolicy(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon));
+    QCOMPARE(QComboBox::SizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon), obj1.sizeAdjustPolicy());
+
+    // int QComboBox::minimumContentsLength()
+    // void QComboBox::setMinimumContentsLength(int)
+    obj1.setMinimumContentsLength(0);
+    QCOMPARE(0, obj1.minimumContentsLength());
+    obj1.setMinimumContentsLength(100);
+    QCOMPARE(100, obj1.minimumContentsLength());
+    obj1.setMinimumContentsLength(INT_MIN);
+    QCOMPARE(100, obj1.minimumContentsLength()); // Cannot be set to something negative => old value
+    obj1.setMinimumContentsLength(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.minimumContentsLength());
+
+    // QLineEdit * QComboBox::lineEdit()
+    // void QComboBox::setLineEdit(QLineEdit *)
+    QLineEdit *var8 = new QLineEdit(0);
+    obj1.setLineEdit(var8);
+    QCOMPARE(var8, obj1.lineEdit());
+    QTest::ignoreMessage(QtWarningMsg, "QComboBox::setLineEdit: cannot set a 0 line edit");
+    obj1.setLineEdit((QLineEdit *)0);
+    QCOMPARE(var8, obj1.lineEdit());
+    // delete var8; // No delete, since QComboBox takes ownership
+
+    // const QValidator * QComboBox::validator()
+    // void QComboBox::setValidator(const QValidator *)
+    QIntValidator *var9 = new QIntValidator(0);
+    obj1.setValidator(var9);
+    QCOMPARE(obj1.validator(), (const QValidator *)var9);
+    obj1.setValidator((QValidator *)0);
+    QCOMPARE(obj1.validator(), (const QValidator *)0);
+    delete var9;
+
+    // QAbstractItemDelegate * QComboBox::itemDelegate()
+    // void QComboBox::setItemDelegate(QAbstractItemDelegate *)
+    MyAbstractItemDelegate *var10 = new MyAbstractItemDelegate;
+    obj1.setItemDelegate(var10);
+    QCOMPARE(obj1.itemDelegate(), (QAbstractItemDelegate *)var10);
+    QTest::ignoreMessage(QtWarningMsg, "QComboBox::setItemDelegate: cannot set a 0 delegate");
+    obj1.setItemDelegate((QAbstractItemDelegate *)0);
+    QCOMPARE(obj1.itemDelegate(), (QAbstractItemDelegate *)var10);
+    // delete var10; // No delete, since QComboBox takes ownership
+
+    // QAbstractItemModel * QComboBox::model()
+    // void QComboBox::setModel(QAbstractItemModel *)
+    MyAbstractItemModel *var11 = new MyAbstractItemModel;
+    obj1.setModel(var11);
+    QCOMPARE(obj1.model(), (QAbstractItemModel *)var11);
+    QTest::ignoreMessage(QtWarningMsg, "QComboBox::setModel: cannot set a 0 model");
+    obj1.setModel((QAbstractItemModel *)0);
+    QCOMPARE(obj1.model(), (QAbstractItemModel *)var11);
+    delete var11;
+    obj1.model();
+
+    // int QComboBox::modelColumn()
+    // void QComboBox::setModelColumn(int)
+    obj1.setModelColumn(0);
+    QCOMPARE(0, obj1.modelColumn());
+    obj1.setModelColumn(INT_MIN);
+//    QCOMPARE(0, obj1.modelColumn()); // Cannot be set to something negative => column 0
+    obj1.setModelColumn(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.modelColumn());
+    obj1.setModelColumn(0); // back to normal
+
+    // QAbstractItemView * QComboBox::view()
+    // void QComboBox::setView(QAbstractItemView *)
+    MyAbstractItemView *var13 = new MyAbstractItemView;
+    obj1.setView(var13);
+    QCOMPARE(obj1.view(), (QAbstractItemView *)var13);
+    QTest::ignoreMessage(QtWarningMsg, "QComboBox::setView: cannot set a 0 view");
+    obj1.setView((QAbstractItemView *)0);
+    QCOMPARE(obj1.view(), (QAbstractItemView *)var13);
+    delete var13;
+
+    // int QComboBox::currentIndex()
+    // void QComboBox::setCurrentIndex(int)
+    obj1.setEditable(false);
+    obj1.setCurrentIndex(0);
+    QCOMPARE(-1, obj1.currentIndex());
+    obj1.setCurrentIndex(INT_MIN);
+    QCOMPARE(-1, obj1.currentIndex());
+    obj1.setCurrentIndex(INT_MAX);
+    QCOMPARE(-1, obj1.currentIndex());
+    obj1.addItems(QStringList() << "1" << "2" << "3" << "4" << "5");
+    obj1.setCurrentIndex(0);
+    QCOMPARE(0, obj1.currentIndex()); // Valid
+    obj1.setCurrentIndex(INT_MIN);
+    QCOMPARE(-1, obj1.currentIndex()); // Invalid => -1
+    obj1.setCurrentIndex(4);
+    QCOMPARE(4, obj1.currentIndex()); // Valid
+    obj1.setCurrentIndex(INT_MAX);
+    QCOMPARE(-1, obj1.currentIndex()); // Invalid => -1
+}
+
+typedef QList<QVariant> VariantList;
+typedef QList<QIcon> IconList;
+
+Q_DECLARE_METATYPE(VariantList)
+Q_DECLARE_METATYPE(IconList)
+Q_DECLARE_METATYPE(QComboBox::InsertPolicy)
+
+tst_QComboBox::tst_QComboBox()
+{
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    parent = 0;
+}
+
+tst_QComboBox::~tst_QComboBox()
+{
+}
+
+
+void tst_QComboBox::initTestCase()
+{
+    // Create the test class
+    parent = new QWidget(0, Qt::Window);
+    parent->setObjectName("parent");
+    parent->resize(400, 400);
+    testWidget = new QComboBox(parent);
+    testWidget->setObjectName("testObject");
+    testWidget->setGeometry(0, 0, 100, 100);
+    editTextCount = 0;
+    editText.clear();
+    connect(testWidget, SIGNAL(editTextChanged(const QString&)),
+            this, SLOT(onEditTextChanged(const QString&)));
+    parent->show();
+}
+
+void tst_QComboBox::cleanupTestCase()
+{
+    delete parent;
+    parent = 0;
+}
+
+
+void tst_QComboBox::init()
+{
+    // all tests starts with a clean non-editable combobox
+    testWidget->setEditable(false);
+    testWidget->clear();
+#ifdef Q_OS_WINCE //disable magic for WindowsCE
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+void tst_QComboBox::cleanup()
+{
+    //nothing
+}
+
+
+void tst_QComboBox::setEditable()
+{
+    // make sure we have no lineedit
+    QVERIFY(!testWidget->lineEdit());
+    // test setEditable(true)
+    testWidget->setEditable(true);
+    QVERIFY(testWidget->lineEdit());
+    testWidget->addItem("foo");
+    QCOMPARE(testWidget->lineEdit()->text(), QString("foo"));
+    // test setEditable(false)
+
+    QLineEdit *lineEdit = testWidget->lineEdit();
+    // line edit is visible when combobox is editable
+    QVERIFY(lineEdit->isVisible());
+    testWidget->setEditable(false);
+    QVERIFY(!testWidget->lineEdit());
+    // line edit should have been explicitly hidden when editable was turned off
+    QVERIFY(!lineEdit->isVisible());
+}
+
+
+void tst_QComboBox::setPalette()
+{
+#ifdef Q_WS_MAC
+    if (qobject_cast<QMacStyle *>(testWidget->style())) {
+        QSKIP("This test doesn't make sense for pixmap-based styles", SkipAll);
+    }
+#endif
+    QPalette pal = testWidget->palette();
+    pal.setColor(QPalette::Base, Qt::red);
+    testWidget->setPalette(pal);
+    testWidget->setEditable(!testWidget->isEditable());
+
+    pal.setColor(QPalette::Base, Qt::blue);
+    testWidget->setPalette(pal);
+
+    const QObjectList comboChildren = testWidget->children();
+    for (int i = 0; i < comboChildren.size(); ++i) {
+        QObject *o = comboChildren.at(i);
+        if (o->isWidgetType()) {
+            QVERIFY(((QWidget*)o)->palette() == pal);
+        }
+    }
+
+    testWidget->setEditable(true);
+    pal.setColor(QPalette::Base, Qt::red);
+    //Setting it on the lineedit should be separate form the combo
+    testWidget->lineEdit()->setPalette(pal);
+    QVERIFY(testWidget->palette() != pal);
+    QVERIFY(testWidget->lineEdit()->palette() == pal);
+    pal.setColor(QPalette::Base, Qt::green);
+    //Setting it on the combo directly should override lineedit
+    testWidget->setPalette(pal);
+    QVERIFY(testWidget->palette() == pal);
+    QVERIFY(testWidget->lineEdit()->palette() == pal);
+}
+
+void tst_QComboBox::sizeAdjustPolicy()
+{
+    // test that adding new items will not change the sizehint for AdjustToContentsOnFirstShow
+    QVERIFY(!testWidget->count());
+    QVERIFY(testWidget->sizeAdjustPolicy() == QComboBox::AdjustToContentsOnFirstShow);
+    QVERIFY(testWidget->isVisible());
+    QSize firstShow = testWidget->sizeHint();
+    testWidget->addItem("normal item");
+    QCOMPARE(testWidget->sizeHint(), firstShow);
+
+    // check that with minimumContentsLength/AdjustToMinimumContentsLength sizehint changes
+    testWidget->setMinimumContentsLength(30);
+    QCOMPARE(testWidget->sizeHint(), firstShow);
+    testWidget->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
+    QSize minimumContentsLength = testWidget->sizeHint();
+    QVERIFY(minimumContentsLength.width() > firstShow.width());
+    testWidget->setMinimumContentsLength(60);
+    QVERIFY(minimumContentsLength.width() < testWidget->sizeHint().width());
+
+    // check that with minimumContentsLength/AdjustToMinimumContentsLengthWithIcon sizehint changes
+    testWidget->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
+    testWidget->setMinimumContentsLength(30);
+    minimumContentsLength = testWidget->sizeHint();
+    QVERIFY(minimumContentsLength.width() > firstShow.width());
+    testWidget->setMinimumContentsLength(60);
+    QVERIFY(minimumContentsLength.width() < testWidget->sizeHint().width());
+    minimumContentsLength = testWidget->sizeHint();
+    testWidget->setIconSize(QSize(128,128));
+    QVERIFY(minimumContentsLength.width() < testWidget->sizeHint().width());
+
+    // check AdjustToContents changes with content
+    testWidget->setSizeAdjustPolicy(QComboBox::AdjustToContents);
+    QSize content = testWidget->sizeHint();
+    testWidget->addItem("small");
+    QCOMPARE(testWidget->sizeHint(), content);
+    testWidget->addItem("looooooooooooooooooooooong item");
+    // minimumContentsLength() > sizeof("looooooooooooooooooooooong item"), so the sizeHint()
+    // stays the same
+    QCOMPARE(testWidget->sizeHint(), content);
+    // over 60 characters (cf. setMinimumContentsLength() call above)
+    testWidget->addItem("loooooooooooooooooooooooooooooooooooooooooooooo"
+                        "ooooooooooooooooooooooooooooooooooooooooooooooo"
+                        "ooooooooooooooooooooooooooooong item");
+    QVERIFY(testWidget->sizeHint().width() > content.width());
+
+    // check AdjustToContents also shrinks when item changes
+    content = testWidget->sizeHint();
+    for (int i=0; i<testWidget->count(); ++i)
+        testWidget->setItemText(i, "XXXXXXXXXX");
+    QVERIFY(testWidget->sizeHint().width() < content.width());
+
+    // check AdjustToContents shrinks when items are removed
+    content = testWidget->sizeHint();
+    while (testWidget->count())
+        testWidget->removeItem(0);
+    QCOMPARE(testWidget->sizeHint(), content);
+    testWidget->setMinimumContentsLength(0);
+    QVERIFY(testWidget->sizeHint().width() < content.width());
+}
+
+void tst_QComboBox::clear()
+{
+    // first non editable combobox
+    testWidget->addItem("foo");
+    testWidget->addItem("bar");
+    QVERIFY(testWidget->count() > 0);
+    QCOMPARE(testWidget->currentIndex(), 0);
+
+    testWidget->clear();
+    QCOMPARE(testWidget->count(), 0);
+    QCOMPARE(testWidget->currentIndex(), -1);
+    QVERIFY(testWidget->currentText().isEmpty());
+
+    // then editable combobox
+    testWidget->clear();
+    testWidget->setEditable(true);
+    testWidget->addItem("foo");
+    testWidget->addItem("bar");
+    QVERIFY(testWidget->count() > 0);
+    QCOMPARE(testWidget->currentIndex(), 0);
+    QVERIFY(testWidget->lineEdit());
+    QVERIFY(!testWidget->lineEdit()->text().isEmpty());
+    testWidget->clear();
+    QCOMPARE(testWidget->count(), 0);
+    QCOMPARE(testWidget->currentIndex(), -1);
+    QVERIFY(testWidget->currentText().isEmpty());
+    QVERIFY(testWidget->lineEdit()->text().isEmpty());
+}
+
+void tst_QComboBox::insertPolicy_data()
+{
+    QTest::addColumn<QStringList>("initialEntries");
+    QTest::addColumn<QComboBox::InsertPolicy>("insertPolicy");
+    QTest::addColumn<int>("currentIndex");
+    QTest::addColumn<QString>("userInput");
+    QTest::addColumn<QStringList>("result");
+
+    /* Each insertPolicy should test at least:
+       no initial entries
+       one initial entry
+       five initial entries, current is first item
+       five initial entries, current is third item
+       five initial entries, current is last item
+    */
+
+    /* QComboBox::NoInsert - the string will not be inserted into the combobox.
+       QComboBox::InsertAtTop - insert the string as the first item in the combobox.
+       QComboBox::InsertAtCurrent - replace the previously selected item with the string the user has entered.
+       QComboBox::InsertAtBottom - insert the string as the last item in the combobox.
+       QComboBox::InsertAfterCurrent - insert the string after the previously selected item.
+       QComboBox::InsertBeforeCurrent - insert the string before the previously selected item.
+       QComboBox::InsertAlphabetically - insert the string at the alphabetic position.
+    */
+    QStringList initial;
+    QStringList oneEntry("One");
+    QStringList fiveEntries;
+    fiveEntries << "One" << "Two" << "Three" << "Four" << "Five";
+    QString input("insert");
+
+    {
+        QTest::newRow("NoInsert-NoInitial") << initial << QComboBox::NoInsert << 0 << input << initial;
+        QTest::newRow("NoInsert-OneInitial") << oneEntry << QComboBox::NoInsert << 0 << input << oneEntry;
+        QTest::newRow("NoInsert-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::NoInsert << 0 << input << fiveEntries;
+        QTest::newRow("NoInsert-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::NoInsert << 2 << input << fiveEntries;
+        QTest::newRow("NoInsert-FiveInitial-LastCurrent") << fiveEntries << QComboBox::NoInsert << 4 << input << fiveEntries;
+    }
+
+    {
+        QStringList initialAtTop("insert");
+        QStringList oneAtTop;
+        oneAtTop << "insert" << "One";
+        QStringList fiveAtTop;
+        fiveAtTop << "insert" << "One" << "Two" << "Three" << "Four" << "Five";
+
+        QTest::newRow("AtTop-NoInitial") << initial << QComboBox::InsertAtTop << 0 << input << initialAtTop;
+        QTest::newRow("AtTop-OneInitial") << oneEntry << QComboBox::InsertAtTop << 0 << input << oneAtTop;
+        QTest::newRow("AtTop-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::InsertAtTop << 0 << input << fiveAtTop;
+        QTest::newRow("AtTop-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::InsertAtTop << 2 << input << fiveAtTop;
+        QTest::newRow("AtTop-FiveInitial-LastCurrent") << fiveEntries << QComboBox::InsertAtTop << 4 << input << fiveAtTop;
+    }
+
+    {
+        QStringList initialAtCurrent("insert");
+        QStringList oneAtCurrent("insert");
+        QStringList fiveAtCurrentFirst;
+        fiveAtCurrentFirst << "insert" << "Two" << "Three" << "Four" << "Five";
+        QStringList fiveAtCurrentThird;
+        fiveAtCurrentThird << "One" << "Two" << "insert" << "Four" << "Five";
+        QStringList fiveAtCurrentLast;
+        fiveAtCurrentLast << "One" << "Two" << "Three" << "Four" << "insert";
+
+        QTest::newRow("AtCurrent-NoInitial") << initial << QComboBox::InsertAtCurrent << 0 << input << initialAtCurrent;
+        QTest::newRow("AtCurrent-OneInitial") << oneEntry << QComboBox::InsertAtCurrent << 0 << input << oneAtCurrent;
+        QTest::newRow("AtCurrent-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::InsertAtCurrent << 0 << input << fiveAtCurrentFirst;
+        QTest::newRow("AtCurrent-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::InsertAtCurrent << 2 << input << fiveAtCurrentThird;
+        QTest::newRow("AtCurrent-FiveInitial-LastCurrent") << fiveEntries << QComboBox::InsertAtCurrent << 4 << input << fiveAtCurrentLast;
+    }
+
+    {
+        QStringList initialAtBottom("insert");
+        QStringList oneAtBottom;
+        oneAtBottom << "One" << "insert";
+        QStringList fiveAtBottom;
+        fiveAtBottom << "One" << "Two" << "Three" << "Four" << "Five" << "insert";
+
+        QTest::newRow("AtBottom-NoInitial") << initial << QComboBox::InsertAtBottom << 0 << input << initialAtBottom;
+        QTest::newRow("AtBottom-OneInitial") << oneEntry << QComboBox::InsertAtBottom << 0 << input << oneAtBottom;
+        QTest::newRow("AtBottom-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::InsertAtBottom << 0 << input << fiveAtBottom;
+        QTest::newRow("AtBottom-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::InsertAtBottom << 2 << input << fiveAtBottom;
+        QTest::newRow("AtBottom-FiveInitial-LastCurrent") << fiveEntries << QComboBox::InsertAtBottom << 4 << input << fiveAtBottom;
+    }
+
+    {
+        QStringList initialAfterCurrent("insert");
+        QStringList oneAfterCurrent;
+        oneAfterCurrent << "One" << "insert";
+        QStringList fiveAfterCurrentFirst;
+        fiveAfterCurrentFirst << "One" << "insert" << "Two" << "Three" << "Four" << "Five";
+        QStringList fiveAfterCurrentThird;
+        fiveAfterCurrentThird << "One" << "Two" << "Three" << "insert" << "Four" << "Five";
+        QStringList fiveAfterCurrentLast;
+        fiveAfterCurrentLast << "One" << "Two" << "Three" << "Four" << "Five" << "insert";
+
+        QTest::newRow("AfterCurrent-NoInitial") << initial << QComboBox::InsertAfterCurrent << 0 << input << initialAfterCurrent;
+        QTest::newRow("AfterCurrent-OneInitial") << oneEntry << QComboBox::InsertAfterCurrent << 0 << input << oneAfterCurrent;
+        QTest::newRow("AfterCurrent-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::InsertAfterCurrent << 0 << input << fiveAfterCurrentFirst;
+        QTest::newRow("AfterCurrent-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::InsertAfterCurrent << 2 << input << fiveAfterCurrentThird;
+        QTest::newRow("AfterCurrent-FiveInitial-LastCurrent") << fiveEntries << QComboBox::InsertAfterCurrent << 4 << input << fiveAfterCurrentLast;
+    }
+
+    {
+        QStringList initialBeforeCurrent("insert");
+        QStringList oneBeforeCurrent;
+        oneBeforeCurrent << "insert" << "One";
+        QStringList fiveBeforeCurrentFirst;
+        fiveBeforeCurrentFirst << "insert" << "One" << "Two" << "Three" << "Four" << "Five";
+        QStringList fiveBeforeCurrentThird;
+        fiveBeforeCurrentThird << "One" << "Two" << "insert" << "Three" << "Four" << "Five";
+        QStringList fiveBeforeCurrentLast;
+        fiveBeforeCurrentLast << "One" << "Two" << "Three" << "Four" << "insert" << "Five";
+
+        QTest::newRow("BeforeCurrent-NoInitial") << initial << QComboBox::InsertBeforeCurrent << 0 << input << initialBeforeCurrent;
+        QTest::newRow("BeforeCurrent-OneInitial") << oneEntry << QComboBox::InsertBeforeCurrent << 0 << input << oneBeforeCurrent;
+        QTest::newRow("BeforeCurrent-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::InsertBeforeCurrent << 0 << input << fiveBeforeCurrentFirst;
+        QTest::newRow("BeforeCurrent-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::InsertBeforeCurrent << 2 << input << fiveBeforeCurrentThird;
+        QTest::newRow("BeforeCurrent-FiveInitial-LastCurrent") << fiveEntries << QComboBox::InsertBeforeCurrent << 4 << input << fiveBeforeCurrentLast;
+    }
+
+    {
+        oneEntry.clear();
+        oneEntry << "foobar";
+        fiveEntries.clear();
+        fiveEntries << "bar" << "foo" << "initial" << "Item" << "stamp";
+
+        QStringList initialAlphabetically("insert");
+        QStringList oneAlphabetically;
+        oneAlphabetically << "foobar" << "insert";
+        QStringList fiveAlphabetically;
+        fiveAlphabetically << "bar" << "foo" << "initial" << "insert" << "Item" << "stamp";
+
+        QTest::newRow("Alphabetically-NoInitial") << initial << QComboBox::InsertAlphabetically << 0 << input << initialAlphabetically;
+        QTest::newRow("Alphabetically-OneInitial") << oneEntry << QComboBox::InsertAlphabetically << 0 << input << oneAlphabetically;
+        QTest::newRow("Alphabetically-FiveInitial-FirstCurrent") << fiveEntries << QComboBox::InsertAlphabetically << 0 << input << fiveAlphabetically;
+        QTest::newRow("Alphabetically-FiveInitial-ThirdCurrent") << fiveEntries << QComboBox::InsertAlphabetically << 2 << input << fiveAlphabetically;
+        QTest::newRow("Alphabetically-FiveInitial-LastCurrent") << fiveEntries << QComboBox::InsertAlphabetically << 4 << input << fiveAlphabetically;
+    }
+}
+
+void tst_QComboBox::insertPolicy()
+{
+    QFETCH(QStringList, initialEntries);
+    QFETCH(QComboBox::InsertPolicy, insertPolicy);
+    QFETCH(int, currentIndex);
+    QFETCH(QString, userInput);
+    QFETCH(QStringList, result);
+
+    testWidget->clear();
+    testWidget->setInsertPolicy(insertPolicy);
+    testWidget->addItems(initialEntries);
+    testWidget->setEditable(true);
+    if (initialEntries.count() > 0)
+        testWidget->setCurrentIndex(currentIndex);
+
+    // clear
+    QTest::mouseDClick(testWidget->lineEdit(), Qt::LeftButton);
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Delete);
+
+    QTest::keyClicks(testWidget->lineEdit(), userInput);
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Return);
+
+    // First check that there is the right number of entries, or
+    // we may unwittingly pass
+    QVERIFY((int)result.count() == testWidget->count());
+
+    // No need to compare if there are no strings to compare
+    if (result.count() > 0) {
+        for (int i=0; i<testWidget->count(); ++i) {
+            QCOMPARE(testWidget->itemText(i), result.at(i));
+        }
+    }
+}
+
+
+void tst_QComboBox::virtualAutocompletion()
+{
+    testWidget->clear();
+    testWidget->setAutoCompletion(true);
+    testWidget->addItem("Foo");
+    testWidget->addItem("Bar");
+    testWidget->addItem("Boat");
+    testWidget->addItem("Boost");
+    testWidget->clearEditText();
+
+    // We need to set the keyboard input interval to a higher value
+    // as the processEvent() call takes too much time, so it restarts
+    // the keyboard search then
+#if defined(QT_ARCH_ARM) || defined(QT_ARCH_MIPS) || defined(QT_ARCH_SYMBIAN)
+    int oldInterval = QApplication::keyboardInputInterval();
+    QApplication::setKeyboardInputInterval(1500);
+#endif
+
+    // NOTE:
+    // Cannot use keyClick for this test, as it simulates keyclicks too well
+    // The virtual keyboards we're trying to catch here, do not perform that
+    // well, and send a keypress & keyrelease right after each other.
+    // This provokes the actual error, as there's no events in between to do
+    // the text completion.
+    QKeyEvent kp1(QEvent::KeyPress, Qt::Key_B, 0, "b");
+    QKeyEvent kr1(QEvent::KeyRelease, Qt::Key_B, 0, "b");
+    QApplication::sendEvent(testWidget, &kp1);
+    QApplication::sendEvent(testWidget, &kr1);
+
+    qApp->processEvents(); // Process events to trigger autocompletion
+    QTRY_VERIFY(testWidget->currentIndex() == 1);
+
+#ifdef QTEST_RUNNING_USING_VALGRIND
+    QSKIP("App running with valgrind are not fast enough", SkipAll);
+#endif
+
+    QKeyEvent kp2(QEvent::KeyPress, Qt::Key_O, 0, "o");
+    QKeyEvent kr2(QEvent::KeyRelease, Qt::Key_O, 0, "o");
+
+    QApplication::sendEvent(testWidget, &kp2);
+    QApplication::sendEvent(testWidget, &kr2);
+
+    qApp->processEvents(); // Process events to trigger autocompletion
+    QTRY_COMPARE(testWidget->currentIndex(), 2);
+
+    QApplication::sendEvent(testWidget, &kp2);
+    QApplication::sendEvent(testWidget, &kr2);
+    qApp->processEvents(); // Process events to trigger autocompletion
+    QTRY_COMPARE(testWidget->currentIndex(), 3);
+#if defined(QT_ARCH_ARM) || defined(QT_ARCH_MIPS) || defined(QT_ARCH_SYMBIAN)
+    QApplication::setKeyboardInputInterval(oldInterval);
+#endif
+}
+
+void tst_QComboBox::autoCompletionCaseSensitivity()
+{
+    //we have put the focus because the completer
+    //is only used when the widget actually has the focus
+    testWidget->setFocus();
+    qApp->setActiveWindow(testWidget);
+    QTRY_COMPARE(qApp->focusWidget(), (QWidget *)testWidget);
+
+    testWidget->clear();
+    testWidget->setAutoCompletion(true);
+    testWidget->addItem("Cow");
+    testWidget->addItem("irrelevant1");
+    testWidget->addItem("aww");
+    testWidget->addItem("A*");
+    testWidget->addItem("irrelevant2");
+    testWidget->addItem("aBCDEF");
+    testWidget->addItem("irrelevant3");
+    testWidget->addItem("abcdef");
+    testWidget->addItem("abCdef");
+    testWidget->setEditable(true);
+
+    // case insensitive
+    testWidget->clearEditText();
+    QSignalSpy spyReturn(testWidget, SIGNAL(activated(int)));
+    testWidget->setAutoCompletionCaseSensitivity(Qt::CaseInsensitive);
+    QVERIFY(testWidget->autoCompletionCaseSensitivity() == Qt::CaseInsensitive);
+
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_A);
+    qApp->processEvents();
+    QCOMPARE(testWidget->currentText(), QString("aww"));
+    QCOMPARE(spyReturn.count(), 0);
+
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_B);
+    qApp->processEvents();
+    // autocompletions preserve userkey-case from 4.2
+    QCOMPARE(testWidget->currentText(), QString("abCDEF"));
+    QCOMPARE(spyReturn.count(), 0);
+
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
+    qApp->processEvents();
+    QCOMPARE(testWidget->currentText(), QString("aBCDEF")); // case restored to item's case
+    QCOMPARE(spyReturn.count(), 1);
+
+    testWidget->clearEditText();
+    QTest::keyClick(testWidget->lineEdit(), 'c');
+    QCOMPARE(testWidget->currentText(), QString("cow"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
+    QCOMPARE(testWidget->currentText(), QString("Cow")); // case restored to item's case
+
+    testWidget->clearEditText();
+    QTest::keyClick(testWidget->lineEdit(), 'a');
+    QTest::keyClick(testWidget->lineEdit(), '*');
+    QCOMPARE(testWidget->currentText(), QString("a*"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
+    QCOMPARE(testWidget->currentText(), QString("A*"));
+
+    // case sensitive
+    testWidget->clearEditText();
+    testWidget->setAutoCompletionCaseSensitivity(Qt::CaseSensitive);
+    QVERIFY(testWidget->autoCompletionCaseSensitivity() == Qt::CaseSensitive);
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_A);
+    qApp->processEvents();
+    QCOMPARE(testWidget->currentText(), QString("aww"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_B);
+    qApp->processEvents();
+    QCOMPARE(testWidget->currentText(), QString("abcdef"));
+
+    testWidget->setCurrentIndex(0); // to reset the completion's "start"
+    testWidget->clearEditText();
+    QTest::keyClick(testWidget->lineEdit(), 'a');
+    QTest::keyClick(testWidget->lineEdit(), 'b');
+    QCOMPARE(testWidget->currentText(), QString("abcdef"));
+    QTest::keyClick(testWidget->lineEdit(), 'C');
+    qApp->processEvents();
+    QCOMPARE(testWidget->currentText(), QString("abCdef"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
+    qApp->processEvents();
+    QCOMPARE(testWidget->currentText(), QString("abCdef")); // case restored to item's case
+
+    testWidget->clearEditText();
+    QTest::keyClick(testWidget->lineEdit(), 'c');
+    QCOMPARE(testWidget->currentText(), QString("c"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Backspace);
+    QTest::keyClick(testWidget->lineEdit(), 'C');
+    QCOMPARE(testWidget->currentText(), QString("Cow"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
+    QCOMPARE(testWidget->currentText(), QString("Cow"));
+
+    testWidget->clearEditText();
+    QTest::keyClick(testWidget->lineEdit(), 'a');
+    QTest::keyClick(testWidget->lineEdit(), '*');
+    QCOMPARE(testWidget->currentText(), QString("a*"));
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
+    QCOMPARE(testWidget->currentText(), QString("a*")); // A* not matched
+}
+
+void tst_QComboBox::hide()
+{
+    testWidget->addItem("foo");
+    testWidget->showPopup();
+    //allow combobox effect to complete
+    QTRY_VERIFY(testWidget->view());
+    QTRY_VERIFY(testWidget->view()->isVisible());
+    testWidget->hidePopup();
+    //allow combobox effect to complete
+    QTRY_VERIFY(!testWidget->view()->isVisible());
+    testWidget->hide();
+    QVERIFY(!testWidget->isVisible());
+}
+
+
+
+void tst_QComboBox::currentIndex_data()
+{
+    QTest::addColumn<QStringList>("initialItems");
+    QTest::addColumn<int>("setCurrentIndex");
+    QTest::addColumn<int>("removeIndex");
+    QTest::addColumn<int>("insertIndex");
+    QTest::addColumn<QString>("insertText");
+    QTest::addColumn<int>("expectedCurrentIndex");
+    QTest::addColumn<QString>("expectedCurrentText");
+    QTest::addColumn<int>("expectedSignalCount");
+
+    QStringList initialItems;
+    int setCurrentIndex;
+    int removeIndex;
+    int insertIndex;
+    QString insertText;
+    int expectedCurrentIndex;
+    QString expectedCurrentText;
+    int expectedSignalCount;
+
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar";
+        setCurrentIndex = -2;
+        removeIndex = -1;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = 0;
+        expectedCurrentText = "foo";
+        expectedSignalCount = 1;
+        QTest::newRow("first added item is set to current if there is no current")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar";
+        setCurrentIndex = 1;
+        removeIndex = -1;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = 1;
+        expectedCurrentText = "bar";
+        expectedSignalCount = 2;
+        QTest::newRow("check that setting the index works")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar";
+        setCurrentIndex = -1; // will invalidate the currentIndex
+        removeIndex = -1;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = -1;
+        expectedCurrentText = "";
+        expectedSignalCount = 2;
+        QTest::newRow("check that isetting the index to -1 works")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo";
+        setCurrentIndex = 0;
+        removeIndex = 0;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = -1;
+        expectedCurrentText = "";
+        expectedSignalCount = 2;
+        QTest::newRow("check that current index is invalid when removing the only item")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar";
+        setCurrentIndex = 1;
+        removeIndex = 0;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = 0;
+        expectedCurrentText = "bar";
+        expectedSignalCount = 3;
+        QTest::newRow("check that the current index follows the item when removing an item above")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar" << "baz";
+        setCurrentIndex = 1;
+        removeIndex = 1;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = 1;
+        expectedCurrentText = "baz";
+        expectedSignalCount = 3;
+        QTest::newRow("check that the current index uses the next item if current is removed")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar" << "baz";
+        setCurrentIndex = 2;
+        removeIndex = 2;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = 1;
+        expectedCurrentText = "bar";
+        expectedSignalCount = 3;
+        QTest::newRow("check that the current index is moved to the one before if current is removed")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar" << "baz";
+        setCurrentIndex = 1;
+        removeIndex = 2;
+        insertIndex = -1;
+        insertText = "";
+        expectedCurrentIndex = 1;
+        expectedCurrentText = "bar";
+        expectedSignalCount = 2;
+        QTest::newRow("check that the current index is unchanged if you remove an item after")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo" << "bar";
+        setCurrentIndex = 1;
+        removeIndex = -1;
+        insertIndex = 0;
+        insertText = "baz";
+        expectedCurrentIndex = 2;
+        expectedCurrentText = "bar";
+        expectedSignalCount = 3;
+        QTest::newRow("check that the current index follows the item if you insert before current")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo";
+        setCurrentIndex = 0;
+        removeIndex = -1;
+        insertIndex = 0;
+        insertText = "bar";
+        expectedCurrentIndex = 1;
+        expectedCurrentText = "foo";
+        expectedSignalCount = 2;
+        QTest::newRow("check that the current index follows the item if you insert on the current")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+    {
+        initialItems.clear();
+        initialItems << "foo";
+        setCurrentIndex = 0;
+        removeIndex = -1;
+        insertIndex = 1;
+        insertText = "bar";
+        expectedCurrentIndex = 0;
+        expectedCurrentText = "foo";
+        expectedSignalCount = 1;
+        QTest::newRow("check that the current index stays the same if you insert after the current")
+            << initialItems << setCurrentIndex << removeIndex
+            << insertIndex << insertText << expectedCurrentIndex << expectedCurrentText
+            << expectedSignalCount;
+    }
+}
+
+void tst_QComboBox::currentIndex()
+{
+    QFETCH(QStringList, initialItems);
+    QFETCH(int, setCurrentIndex);
+    QFETCH(int, removeIndex);
+    QFETCH(int, insertIndex);
+    QFETCH(QString, insertText);
+    QFETCH(int, expectedCurrentIndex);
+    QFETCH(QString, expectedCurrentText);
+    QFETCH(int, expectedSignalCount);
+
+    // test both editable/non-editable combobox
+    for (int edit = 0; edit < 2; ++edit) {
+        testWidget->clear();
+        testWidget->setEditable(edit ? true : false);
+        if (edit)
+            QVERIFY(testWidget->lineEdit());
+
+        // verify it is empty, has no current index and no current text
+        QCOMPARE(testWidget->count(), 0);
+        QCOMPARE(testWidget->currentIndex(), -1);
+        QVERIFY(testWidget->currentText().isEmpty());
+
+        // spy on currentIndexChanged
+        QSignalSpy indexChangedInt(testWidget, SIGNAL(currentIndexChanged(int)));
+        QSignalSpy indexChangedString(testWidget, SIGNAL(currentIndexChanged(const QString&)));
+
+        // stuff items into it
+        foreach(QString text, initialItems) {
+            testWidget->addItem(text);
+        }
+        QCOMPARE(testWidget->count(), initialItems.count());
+
+        // set current index, remove and/or insert
+        if (setCurrentIndex >= -1) {
+            testWidget->setCurrentIndex(setCurrentIndex);
+            QCOMPARE(testWidget->currentIndex(), setCurrentIndex);
+        }
+
+        if (removeIndex >= 0)
+            testWidget->removeItem(removeIndex);
+        if (insertIndex >= 0)
+            testWidget->insertItem(insertIndex, insertText);
+
+        // compare with expected index and text
+        QCOMPARE(testWidget->currentIndex(), expectedCurrentIndex);
+        QCOMPARE(testWidget->currentText(), expectedCurrentText);
+
+        // check that signal count is correct
+        QCOMPARE(indexChangedInt.count(), expectedSignalCount);
+        QCOMPARE(indexChangedString.count(), expectedSignalCount);
+
+        // compare with last sent signal values
+        if (indexChangedInt.count())
+            QCOMPARE(indexChangedInt.at(indexChangedInt.count() - 1).at(0).toInt(),
+                    testWidget->currentIndex());
+        if (indexChangedString.count())
+            QCOMPARE(indexChangedString.at(indexChangedString.count() - 1).at(0).toString(),
+                     testWidget->currentText());
+
+        if (edit) {
+            testWidget->setCurrentIndex(-1);
+            testWidget->setInsertPolicy(QComboBox::InsertAtBottom);
+            QTest::keyPress(testWidget, 'a');
+            QTest::keyPress(testWidget, 'b');
+            QCOMPARE(testWidget->currentText(), QString("ab"));
+            QCOMPARE(testWidget->currentIndex(), -1);
+            int numItems = testWidget->count();
+            QTest::keyPress(testWidget, Qt::Key_Return);
+            QCOMPARE(testWidget->count(), numItems + 1);
+            QCOMPARE(testWidget->currentIndex(), numItems);
+            testWidget->setCurrentIndex(-1);
+            QTest::keyPress(testWidget, 'a');
+            QTest::keyPress(testWidget, 'b');
+            QCOMPARE(testWidget->currentIndex(), -1);
+        }
+    }
+}
+
+void tst_QComboBox::insertItems_data()
+{
+    QTest::addColumn<QStringList>("initialItems");
+    QTest::addColumn<QStringList>("insertedItems");
+    QTest::addColumn<int>("insertIndex");
+    QTest::addColumn<int>("expectedIndex");
+
+    QStringList initialItems;
+    QStringList insertedItems;
+
+    initialItems << "foo" << "bar";
+    insertedItems << "mongo";
+
+    QTest::newRow("prepend") << initialItems << insertedItems << 0 << 0;
+    QTest::newRow("prepend with negative value") << initialItems << insertedItems << -1 << 0;
+    QTest::newRow("append") << initialItems << insertedItems << initialItems.count() << initialItems.count();
+    QTest::newRow("append with too high value") << initialItems << insertedItems << 999 << initialItems.count();
+    QTest::newRow("insert") << initialItems << insertedItems << 1 << 1;
+}
+
+void tst_QComboBox::insertItems()
+{
+    QFETCH(QStringList, initialItems);
+    QFETCH(QStringList, insertedItems);
+    QFETCH(int, insertIndex);
+    QFETCH(int, expectedIndex);
+
+    testWidget->insertItems(0, initialItems);
+    QCOMPARE(testWidget->count(), initialItems.count());
+
+    testWidget->insertItems(insertIndex, insertedItems);
+
+    QCOMPARE(testWidget->count(), initialItems.count() + insertedItems.count());
+    for (int i=0; i<insertedItems.count(); ++i)
+        QCOMPARE(testWidget->itemText(expectedIndex + i), insertedItems.at(i));
+}
+
+void tst_QComboBox::insertItem_data()
+{
+    QTest::addColumn<QStringList>("initialItems");
+    QTest::addColumn<int>("insertIndex");
+    QTest::addColumn<QString>("itemLabel");
+    QTest::addColumn<int>("expectedIndex");
+    QTest::addColumn<bool>("testQt3Support");
+    QTest::addColumn<bool>("editable");
+
+    QStringList initialItems;
+    initialItems << "foo" << "bar";
+    for(int e = 0 ; e<2 ; e++) {
+        bool editable = (e==0);
+        QTest::newRow("Insert less then 0") << initialItems << -1 << "inserted" << 0 << false << editable;
+        QTest::newRow("Insert at 0") << initialItems << 0 << "inserted" << 0 << false << editable;
+        QTest::newRow("Insert beyond count") << initialItems << 3 << "inserted" << 2 << false << editable;
+        QTest::newRow("Insert at count") << initialItems << 2 << "inserted" << 2 << false << editable;
+        QTest::newRow("Insert in the middle") << initialItems << 1 << "inserted" << 1 << false << editable;
+#if defined(QT3_SUPPORT)
+        QTest::newRow("Qt3Support: Insert less then 0") << initialItems << -1 << "inserted" << 2 << true << editable;
+#endif
+    }
+}
+
+void tst_QComboBox::insertItem()
+{
+    QFETCH(QStringList, initialItems);
+    QFETCH(int, insertIndex);
+    QFETCH(QString, itemLabel);
+    QFETCH(int, expectedIndex);
+    QFETCH(bool, testQt3Support);
+    QFETCH(bool, editable);
+
+    testWidget->insertItems(0, initialItems);
+    QCOMPARE(testWidget->count(), initialItems.count());
+
+    testWidget->setEditable(true);
+    if (editable)
+        testWidget->setEditText("FOO");
+#if defined (QT3_SUPPORT)
+    if (testQt3Support)
+        testWidget->insertItem(itemLabel, insertIndex);
+    else
+        testWidget->insertItem(insertIndex, itemLabel);
+#else
+    Q_UNUSED(testQt3Support);
+    testWidget->insertItem(insertIndex, itemLabel);
+#endif
+
+
+    QCOMPARE(testWidget->count(), initialItems.count() + 1);
+    QCOMPARE(testWidget->itemText(expectedIndex), itemLabel);
+
+    if (editable)
+        QCOMPARE(testWidget->currentText(), QString("FOO"));
+}
+
+void tst_QComboBox::insertOnCurrentIndex()
+{
+    testWidget->setEditable(true);
+    testWidget->addItem("first item");
+    testWidget->setCurrentIndex(0);
+    testWidget->insertItem(0, "second item");
+    QCOMPARE(testWidget->lineEdit()->text(), QString::fromAscii("first item"));
+}
+
+void tst_QComboBox::textpixmapdata_data()
+{
+    QTest::addColumn<QStringList>("text");
+    QTest::addColumn<IconList>("icons");
+    QTest::addColumn<VariantList>("variant");
+
+    QStringList text;
+    IconList icon;
+    VariantList variant;
+
+    {
+        text.clear(); icon.clear(); variant.clear();
+        text << "foo" << "bar";
+        icon << QIcon() << QIcon();
+        variant << QVariant() << QVariant();
+        QTest::newRow("just text") << text << icon << variant;
+    }
+    {
+        text.clear(); icon.clear(); variant.clear();
+        text << QString() << QString();
+        icon << QIcon(QPixmap("qtlogo.png")) << QIcon(QPixmap("qtlogoinverted.png"));
+        variant << QVariant() << QVariant();
+        QTest::newRow("just icons") << text << icon << variant;
+    }
+    {
+        text.clear(); icon.clear(); variant.clear();
+        text << QString() << QString();
+        icon << QIcon() << QIcon();
+        variant << 12 << "bingo";
+        QTest::newRow("just user data") << text << icon << variant;
+    }
+    {
+        text.clear(); icon.clear(); variant.clear();
+        text << "foo" << "bar";
+        icon << QIcon(QPixmap("qtlogo.png")) << QIcon(QPixmap("qtlogoinverted.png"));
+        variant << 12 << "bingo";
+        QTest::newRow("text, icons and user data") << text << icon << variant;
+    }
+}
+
+void tst_QComboBox::textpixmapdata()
+{
+    QFETCH(QStringList, text);
+    QFETCH(IconList, icons);
+    QFETCH(VariantList, variant);
+
+    QVERIFY(text.count() == icons.count() && text.count() == variant.count());
+
+    for (int i = 0; i<text.count(); ++i) {
+        testWidget->insertItem(i, text.at(i));
+        testWidget->setItemIcon(i, icons.at(i));
+        testWidget->setItemData(i, variant.at(i), Qt::UserRole);
+    }
+
+    QCOMPARE(testWidget->count(), text.count());
+
+    for (int i = 0; i<text.count(); ++i) {
+        QIcon icon = testWidget->itemIcon(i);
+        QVERIFY(icon.serialNumber() == icons.at(i).serialNumber());
+        QPixmap original = icons.at(i).pixmap(1024);
+        QPixmap pixmap = icon.pixmap(1024);
+        QVERIFY(pixmap.toImage() == original.toImage());
+    }
+
+    for (int i = 0; i<text.count(); ++i) {
+        QCOMPARE(testWidget->itemText(i), text.at(i));
+        // ### we should test icons/pixmap as well, but I need to fix the api mismatch first
+        QCOMPARE(testWidget->itemData(i, Qt::UserRole), variant.at(i));
+    }
+}
+
+void tst_QComboBox::setCurrentIndex()
+{
+    QCOMPARE(testWidget->count(), 0);
+    testWidget->addItem("foo");
+    testWidget->addItem("bar");
+    QCOMPARE(testWidget->count(), 2);
+
+    QCOMPARE(testWidget->currentIndex(), 0);
+    testWidget->setCurrentIndex(0);
+    QCOMPARE(testWidget->currentText(), QString("foo"));
+
+    testWidget->setCurrentIndex(1);
+    QCOMPARE(testWidget->currentText(), QString("bar"));
+
+    testWidget->setCurrentIndex(0);
+    QCOMPARE(testWidget->currentText(), QString("foo"));
+}
+
+void tst_QComboBox::editTextChanged()
+{
+    QCOMPARE(testWidget->count(), 0);
+    testWidget->addItem("foo");
+    testWidget->addItem("bar");
+    QCOMPARE(testWidget->count(), 2);
+
+    // first we test non editable
+    testWidget->setEditable(false);
+    QCOMPARE(testWidget->isEditable(), false);
+
+    // no signal should be sent when current is set to the same
+    QCOMPARE(testWidget->currentIndex(), 0);
+    editTextCount = 0;
+    editText.clear();
+    testWidget->setCurrentIndex(0);
+    QCOMPARE(testWidget->currentIndex(), 0);
+    QCOMPARE(editTextCount, 0);
+    QCOMPARE(editText.isEmpty(), true);
+
+    // no signal should be sent when changing to other index because we are not editable
+    QCOMPARE(testWidget->currentIndex(), 0);
+    editTextCount = 0;
+    editText.clear();
+    testWidget->setCurrentIndex(1);
+    QCOMPARE(testWidget->currentIndex(), 1);
+    QCOMPARE(editTextCount, 0);
+    QCOMPARE(editText.isEmpty(), true);
+
+    // now set to editable and reset current index
+    testWidget->setEditable(true);
+    QCOMPARE(testWidget->isEditable(), true);
+    testWidget->setCurrentIndex(0);
+
+    // no signal should be sent when current is set to the same
+    QCOMPARE(testWidget->currentIndex(), 0);
+    editTextCount = 0;
+    editText.clear();
+    testWidget->setCurrentIndex(0);
+    QCOMPARE(testWidget->currentIndex(), 0);
+    QCOMPARE(editTextCount, 0);
+    QCOMPARE(editText.isEmpty(), true);
+
+    // signal should be sent when changing to other index
+    QCOMPARE(testWidget->currentIndex(), 0);
+    editTextCount = 0;
+    editText.clear();
+    testWidget->setCurrentIndex(1);
+    QCOMPARE(testWidget->currentIndex(), 1);
+    QCOMPARE(editTextCount, 1);
+    QCOMPARE(editText, QString("bar"));
+
+    // insert some keys and notice they are all signaled
+    editTextCount = 0;
+    editText.clear();
+    QTest::keyClicks(testWidget, "bingo");
+    QCOMPARE(editTextCount, 5);
+    QCOMPARE(editText, QString("barbingo"));
+}
+
+void tst_QComboBox::onEditTextChanged(const QString &text)
+{
+    editTextCount++;
+    editText = text;
+}
+
+void tst_QComboBox::setModel()
+{
+    QComboBox box;
+    QCOMPARE(box.currentIndex(), -1);
+    box.addItems((QStringList() << "foo" << "bar"));
+    QCOMPARE(box.currentIndex(), 0);
+    box.setCurrentIndex(1);
+    QCOMPARE(box.currentIndex(), 1);
+
+    // check that currentIndex is set to invalid
+    QAbstractItemModel *oldModel = box.model();
+    box.setModel(new QStandardItemModel(&box));
+    QCOMPARE(box.currentIndex(), -1);
+    QVERIFY(box.model() != oldModel);
+
+    // check that currentIndex is set to first item
+    oldModel = box.model();
+    box.setModel(new QStandardItemModel(2,1, &box));
+    QCOMPARE(box.currentIndex(), 0);
+    QVERIFY(box.model() != oldModel);
+}
+
+void tst_QComboBox::modelDeleted()
+{
+    QComboBox box;
+    QStandardItemModel *model = new QStandardItemModel;
+    box.setModel(model);
+    QCOMPARE(box.model(), static_cast<QAbstractItemModel *>(model));
+    delete model;
+    QVERIFY(box.model());
+    QCOMPARE(box.findText("bubu"), -1);
+
+    delete box.model();
+    QVERIFY(box.model());
+    delete box.model();
+    QVERIFY(box.model());
+}
+
+void tst_QComboBox::setMaxCount()
+{
+    QStringList items;
+    items << "1" << "2" << "3" << "4" << "5";
+
+    QComboBox box;
+    box.addItems(items);
+    QCOMPARE(box.count(), 5);
+
+    box.setMaxCount(4);
+    QCOMPARE(box.count(), 4);
+    QCOMPARE(box.itemText(0), QString("1"));
+    QCOMPARE(box.itemText(1), QString("2"));
+    QCOMPARE(box.itemText(2), QString("3"));
+    QCOMPARE(box.itemText(3), QString("4"));
+
+    // appending should do nothing
+    box.addItem("foo");
+    QCOMPARE(box.count(), 4);
+    QCOMPARE(box.findText("foo"), -1);
+
+    // inserting one item at top should remove the last
+    box.insertItem(0, "0");
+    QCOMPARE(box.count(), 4);
+    QCOMPARE(box.itemText(0), QString("0"));
+    QCOMPARE(box.itemText(1), QString("1"));
+    QCOMPARE(box.itemText(2), QString("2"));
+    QCOMPARE(box.itemText(3), QString("3"));
+
+    // insert 5 items in a box with maxCount 4
+    box.insertItems(0, items);
+    QCOMPARE(box.count(), 4);
+    QCOMPARE(box.itemText(0), QString("1"));
+    QCOMPARE(box.itemText(1), QString("2"));
+    QCOMPARE(box.itemText(2), QString("3"));
+    QCOMPARE(box.itemText(3), QString("4"));
+
+    // insert 5 items at pos 2. Make sure only two get inserted
+    QSignalSpy spy(box.model(), SIGNAL(rowsInserted(QModelIndex,int,int)));
+    box.insertItems(2, items);
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(1).toInt(), 2);
+    QCOMPARE(spy.at(0).at(2).toInt(), 3);
+
+    QCOMPARE(box.count(), 4);
+    QCOMPARE(box.itemText(0), QString("1"));
+    QCOMPARE(box.itemText(1), QString("2"));
+    QCOMPARE(box.itemText(2), QString("1"));
+    QCOMPARE(box.itemText(3), QString("2"));
+
+    box.insertItems(0, QStringList());
+    QCOMPARE(box.count(), 4);
+
+    box.setMaxCount(0);
+    QCOMPARE(box.count(), 0);
+    box.addItem("foo");
+    QCOMPARE(box.count(), 0);
+    box.addItems(items);
+    QCOMPARE(box.count(), 0);
+}
+
+void tst_QComboBox::convenienceViews()
+{
+    // QListWidget
+    QComboBox listCombo;
+    QListWidget *list = new QListWidget();
+    listCombo.setModel(list->model());
+    listCombo.setView(list);
+    // add items
+    list->addItem("list0");
+    listCombo.addItem("list1");
+    QCOMPARE(listCombo.count(), 2);
+    QCOMPARE(listCombo.itemText(0), QString("list0"));
+    QCOMPARE(listCombo.itemText(1), QString("list1"));
+
+    // QTreeWidget
+    QComboBox treeCombo;
+    QTreeWidget *tree = new QTreeWidget();
+    tree->setColumnCount(1);
+    tree->header()->hide();
+    treeCombo.setModel(tree->model());
+    treeCombo.setView(tree);
+    // add items
+    tree->addTopLevelItem(new QTreeWidgetItem(QStringList("tree0")));
+    treeCombo.addItem("tree1");
+    QCOMPARE(treeCombo.count(), 2);
+    QCOMPARE(treeCombo.itemText(0), QString("tree0"));
+    QCOMPARE(treeCombo.itemText(1), QString("tree1"));
+
+    // QTableWidget
+    QComboBox tableCombo;
+    QTableWidget *table = new QTableWidget(0,1);
+    table->verticalHeader()->hide();
+    table->horizontalHeader()->hide();
+    tableCombo.setModel(table->model());
+    tableCombo.setView(table);
+    // add items
+    table->setRowCount(table->rowCount() + 1);
+    table->setItem(0, table->rowCount() - 1, new QTableWidgetItem("table0"));
+    tableCombo.addItem("table1");
+    QCOMPARE(tableCombo.count(), 2);
+    QCOMPARE(tableCombo.itemText(0), QString("table0"));
+    QCOMPARE(tableCombo.itemText(1), QString("table1"));
+}
+
+class ReturnClass : public QWidget
+{
+    Q_OBJECT
+public:
+    ReturnClass(QWidget *parent = 0)
+        : QWidget(parent), received(false)
+    {
+        QComboBox *box = new QComboBox(this);
+        box->setEditable(true);
+        edit = box->lineEdit();
+        box->setGeometry(rect());
+    }
+
+    void keyPressEvent(QKeyEvent *e)
+    {
+        received = (e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter);
+    }
+
+    QLineEdit *edit;
+
+    bool received;
+
+};
+
+
+
+void tst_QComboBox::ensureReturnIsIgnored()
+{
+    ReturnClass r;
+    r.show();
+
+    QTest::keyClick(r.edit, Qt::Key_Return);
+    QVERIFY(r.received);
+    r.received = false;
+    QTest::keyClick(r.edit, Qt::Key_Enter);
+    QVERIFY(r.received);
+}
+
+
+void tst_QComboBox::findText_data()
+{
+    QTest::addColumn<QStringList>("items");
+    QTest::addColumn<int>("matchflags");
+    QTest::addColumn<QString>("search");
+    QTest::addColumn<int>("result");
+
+    QStringList list;
+    list << "One" << "Two" << "Three" << "Four" << "Five" << "Six" << "one";
+    QTest::newRow("CaseSensitive_1") << list << (int)(Qt::MatchExactly|Qt::MatchCaseSensitive)
+                                     << QString("Two") << 1;
+    QTest::newRow("CaseSensitive_2") << list << (int)(Qt::MatchExactly|Qt::MatchCaseSensitive)
+                                     << QString("two") << -1;
+    QTest::newRow("CaseSensitive_3") << list << (int)(Qt::MatchExactly|Qt::MatchCaseSensitive)
+                                     << QString("One") << 0;
+    QTest::newRow("CaseSensitive_4") << list << (int)(Qt::MatchExactly|Qt::MatchCaseSensitive)
+                                     << QString("one") << 6;
+    QTest::newRow("CaseInsensitive_1") << list << (int)(Qt::MatchExactly) << QString("Two") << 1;
+    QTest::newRow("CaseInsensitive_2") << list << (int)(Qt::MatchExactly) << QString("two") << -1;
+    QTest::newRow("CaseInsensitive_3") << list << (int)(Qt::MatchExactly) << QString("One") << 0;
+    QTest::newRow("CaseInsensitive_4") << list << (int)(Qt::MatchExactly) << QString("one") << 6;
+}
+void tst_QComboBox::findText()
+{
+    QFETCH(QStringList, items);
+    QFETCH(int, matchflags);
+    QFETCH(QString, search);
+    QFETCH(int, result);
+
+    testWidget->clear();
+    testWidget->addItems(items);
+
+    QCOMPARE(testWidget->findText(search, (Qt::MatchFlags)matchflags), result);
+}
+
+typedef QList<int> IntList;
+typedef QList<Qt::Key> KeyList;
+Q_DECLARE_METATYPE(IntList)
+Q_DECLARE_METATYPE(KeyList)
+
+void tst_QComboBox::flaggedItems_data()
+{
+    QTest::addColumn<QStringList>("itemList");
+    QTest::addColumn<IntList>("deselectFlagList");
+    QTest::addColumn<IntList>("disableFlagList");
+    QTest::addColumn<KeyList>("keyMovementList");
+    QTest::addColumn<bool>("editable");
+    QTest::addColumn<int>("expectedIndex");
+
+    for (int editable=0;editable<2;editable++) {
+        QString testCase = editable ? "editable:" : "non-editable:";
+        QStringList itemList;
+        itemList << "One" << "Two" << "Three" << "Four" << "Five" << "Six" << "Seven" << "Eight";
+        IntList deselectFlagList;
+        IntList disableFlagList;
+        KeyList keyMovementList;
+
+        keyMovementList << Qt::Key_Down << Qt::Key_Down << Qt::Key_Down << Qt::Key_Down;
+        QTest::newRow(testCase.toAscii() + "normal") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 4;
+
+        deselectFlagList.clear();
+        disableFlagList.clear();
+        deselectFlagList << 1 << 3;
+        QTest::newRow(testCase.toAscii() + "non-selectable") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 4;
+
+        deselectFlagList.clear();
+        disableFlagList.clear();
+        disableFlagList << 2;
+        QTest::newRow(testCase.toAscii() + "disabled") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 5;
+
+        deselectFlagList.clear();
+        disableFlagList.clear();
+        deselectFlagList << 1 << 3;
+        disableFlagList << 2 << 3;
+        QTest::newRow(testCase.toAscii() + "mixed") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 6;
+        deselectFlagList.clear();
+        disableFlagList.clear();
+        disableFlagList << 0 << 1 << 2 << 3 << 4 << 5 << 6;
+        QTest::newRow(testCase.toAscii() + "nearly-empty") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 7;
+
+        deselectFlagList.clear();
+        disableFlagList.clear();
+        disableFlagList << 0 << 1 << 2 << 3 << 5 << 6 << 7;
+        keyMovementList.clear();
+        QTest::newRow(testCase.toAscii() + "only one enabled") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 4;
+
+        if (!editable) {
+            deselectFlagList.clear();
+            disableFlagList.clear();
+            keyMovementList.clear();
+            disableFlagList << 0 << 2 << 3;
+            keyMovementList << Qt::Key_Down << Qt::Key_Home;
+            QTest::newRow(testCase.toAscii() + "home-disabled") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 1;
+
+            keyMovementList.clear();
+            keyMovementList << Qt::Key_End;
+            QTest::newRow(testCase.toAscii() + "end-key") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 7;
+
+            disableFlagList.clear();
+            disableFlagList << 1 ;
+            keyMovementList << Qt::Key_T;
+            QTest::newRow(testCase.toAscii() + "keyboard-search") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 2;
+
+            itemList << "nine" << "ten";
+            keyMovementList << Qt::Key_T;
+            QTest::newRow(testCase.toAscii() + "search same start letter") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 9;
+
+            keyMovementList.clear();
+            keyMovementList << Qt::Key_T << Qt::Key_H;
+            QTest::newRow(testCase.toAscii() + "keyboard search item") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 2;
+
+            disableFlagList.clear();
+            disableFlagList << 1 << 3 << 5 << 7 << 9;
+            keyMovementList.clear();
+            keyMovementList << Qt::Key_End << Qt::Key_Up << Qt::Key_Up << Qt::Key_PageDown << Qt::Key_PageUp << Qt::Key_PageUp << Qt::Key_Down;
+            QTest::newRow(testCase.toAscii() + "all key combinations") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 4;
+        } else {
+            deselectFlagList.clear();
+            disableFlagList.clear();
+            disableFlagList << 1;
+            keyMovementList.clear();
+            keyMovementList << Qt::Key_T << Qt::Key_Enter;
+            QTest::newRow(testCase.toAscii() + "disabled") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 2;
+            QTest::newRow(testCase.toAscii() + "broken autocompletion") << itemList << deselectFlagList << disableFlagList << keyMovementList << bool(editable) << 2;
+        }
+    }
+}
+
+void tst_QComboBox::flaggedItems()
+{
+    QFETCH(QStringList, itemList);
+    QFETCH(IntList, deselectFlagList);
+    QFETCH(IntList, disableFlagList);
+    QFETCH(KeyList, keyMovementList);
+    QFETCH(bool, editable);
+    QFETCH(int, expectedIndex);
+
+    QComboBox comboBox;
+    QListWidget listWidget;
+    listWidget.addItems(itemList);
+
+    comboBox.setEditable(editable);
+    foreach (int index, deselectFlagList)
+        listWidget.item(index)->setFlags(listWidget.item(index)->flags() & ~Qt::ItemIsSelectable);
+
+    foreach (int index, disableFlagList)
+        listWidget.item(index)->setFlags(listWidget.item(index)->flags() & ~Qt::ItemIsEnabled);
+
+    comboBox.setModel(listWidget.model());
+    comboBox.setView(&listWidget);
+    comboBox.show();
+    QApplication::setActiveWindow(&comboBox);
+    comboBox.activateWindow();
+    comboBox.setFocus();
+    QTRY_VERIFY(comboBox.isVisible());
+    QTRY_VERIFY(comboBox.hasFocus());
+
+    if (editable)
+        comboBox.lineEdit()->selectAll();
+
+    QSignalSpy indexChangedInt(&comboBox, SIGNAL(currentIndexChanged(int)));
+    for (int i = 0; i < keyMovementList.count(); ++i) {
+        Qt::Key key = keyMovementList[i];
+        QTest::keyClick(&comboBox, key);
+        if (indexChangedInt.count() != i + 1) {
+            QTest::qWait(400);
+        }
+    }
+
+    QCOMPARE(comboBox.currentIndex() , expectedIndex);
+}
+
+void tst_QComboBox::pixmapIcon()
+{
+    QComboBox box;
+    QStandardItemModel *model = new QStandardItemModel(2, 1, &box);
+
+    QPixmap pix(10, 10);
+    pix.fill(Qt::red);
+    model->setData(model->index(0, 0), "Element 1");
+    model->setData(model->index(0, 0), pix, Qt::DecorationRole);
+
+    QIcon icon(pix);
+    model->setData(model->index(1, 0), "Element 2");
+    model->setData(model->index(1, 0), icon, Qt::DecorationRole);
+
+    box.setModel(model);
+
+    QCOMPARE( box.itemIcon(0).isNull(), false );
+    QCOMPARE( box.itemIcon(1).isNull(), false );
+}
+
+// defined to be 120 by the wheel mouse vendors according to the docs
+#define WHEEL_DELTA 120
+
+void tst_QComboBox::mouseWheel_data()
+{
+    QTest::addColumn<IntList>("disabledItems");
+    QTest::addColumn<int>("startIndex");
+    QTest::addColumn<int>("wheelDirection");
+    QTest::addColumn<int>("expectedIndex");
+
+    IntList disabled;
+    disabled << 0 << 1 << 2 << 4;
+    int start = 3;
+    int wheel = 1;
+    int expected = 3;
+    QTest::newRow("upper locked") << disabled << start << wheel << expected;
+
+    wheel = -1;
+    expected = 5;
+    QTest::newRow("jump over") << disabled << start << wheel << expected;
+
+    disabled.clear();
+    disabled << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9;
+    start = 0;
+    wheel = -1;
+    expected = 0;
+    QTest::newRow("single Item enabled") << disabled << start << wheel << expected;
+}
+
+void tst_QComboBox::mouseWheel()
+{
+    QFETCH(IntList, disabledItems);
+    QFETCH(int, startIndex);
+    QFETCH(int, wheelDirection);
+    QFETCH(int, expectedIndex);
+
+    QCoreApplication *applicationInstance = QCoreApplication::instance();
+    QVERIFY(applicationInstance != 0);
+
+    QComboBox box;
+    QStringList list;
+    list << "one" << "two" << "three" << "four" << "five" << "six" << "seven" << "eight" << "nine" << "ten";
+
+    QListWidget listWidget;
+    listWidget.addItems(list);
+
+    foreach (int index, disabledItems)
+        listWidget.item(index)->setFlags(listWidget.item(index)->flags() & ~Qt::ItemIsEnabled);
+
+    box.setModel(listWidget.model());
+    box.setView(&listWidget);
+    for (int i=0; i < 2; ++i) {
+        box.setEditable(i==0?false:true);
+        box.setCurrentIndex(startIndex);
+
+        QWheelEvent event = QWheelEvent(box.rect().bottomRight() , WHEEL_DELTA * wheelDirection, Qt::NoButton, Qt::NoModifier);
+        QVERIFY(applicationInstance->sendEvent(&box,&event));
+
+        QCOMPARE(box.currentIndex(), expectedIndex);
+    }
+}
+
+void tst_QComboBox::layoutDirection()
+{
+    QComboBox box;
+    Qt::LayoutDirection dir;
+    QLineEdit *lineEdit;
+
+    // RTL
+    box.setLayoutDirection(Qt::RightToLeft);
+    QStyleOptionComboBox opt;
+    opt.direction = Qt::RightToLeft;
+    dir = (Qt::LayoutDirection)box.style()->styleHint(QStyle::SH_ComboBox_LayoutDirection, &opt, &box);
+
+    QCOMPARE(box.view()->layoutDirection(), dir);
+    box.setEditable(true);
+    QCOMPARE(box.lineEdit()->layoutDirection(), dir);
+    lineEdit = new QLineEdit;
+    QCOMPARE(lineEdit->layoutDirection(), qApp->layoutDirection());
+    box.setLineEdit(lineEdit);
+    QCOMPARE(lineEdit->layoutDirection(), dir);
+
+    // LTR
+    box.setLayoutDirection(Qt::LeftToRight);
+    qApp->setLayoutDirection(Qt::RightToLeft);
+
+    opt.direction = Qt::LeftToRight;
+    dir = (Qt::LayoutDirection)box.style()->styleHint(QStyle::SH_ComboBox_LayoutDirection, &opt, &box);
+
+    QCOMPARE(box.view()->layoutDirection(), dir);
+    box.setEditable(true);
+    QCOMPARE(box.lineEdit()->layoutDirection(), dir);
+    lineEdit = new QLineEdit;
+    QCOMPARE(lineEdit->layoutDirection(), qApp->layoutDirection());
+    box.setLineEdit(lineEdit);
+    QCOMPARE(lineEdit->layoutDirection(), dir);
+
+}
+
+void tst_QComboBox::itemListPosition()
+{
+    //tests that the list is not out of the screen boundaries
+
+    //put the QApplication layout back
+    QApplication::setLayoutDirection(Qt::LeftToRight);
+
+    //we test QFontComboBox because it has the specific behaviour to set a fixed size
+    //to the list view
+    QWidget topLevel;
+    QFontComboBox combo(&topLevel);
+
+    //the code to get the avaialbe screen space is copied from QComboBox code
+    const int scrNumber = QApplication::desktop()->screenNumber(&combo);
+    QRect screen;
+#ifdef Q_WS_WIN
+    screen = QApplication::desktop()->screenGeometry(scrNumber);
+#elif defined Q_WS_X11
+    if (X11->desktopEnvironment == DE_KDE)
+        screen = QApplication::desktop()->screenGeometry(scrNumber);
+    else
+        screen = QApplication::desktop()->availableGeometry(scrNumber);
+#else
+    screen = QApplication::desktop()->availableGeometry(scrNumber);
+#endif
+
+    combo.move(screen.width()-combo.sizeHint().width(), 0); //puts the combo to the top-right corner
+
+    topLevel.show();
+    //wait because the window manager can move the window if there is a right panel
+    QTRY_VERIFY(combo.isVisible());
+    combo.showPopup();
+    QTRY_VERIFY(combo.view());
+    QTRY_VERIFY(combo.view()->isVisible());
+
+#if defined(Q_WS_S60)
+    // Assuming that QtS60 style is used, here. But other ones would certainly also fail
+    QEXPECT_FAIL("", "QtS60Style does not yet position the combobox popup correctly", Continue);
+#endif
+    QVERIFY( combo.view()->window()->x() + combo.view()->window()->width() <= screen.x() + screen.width() );
+
+}
+
+void tst_QComboBox::separatorItem_data()
+{
+    QTest::addColumn<QStringList>("items");
+    QTest::addColumn<IntList>("separators");
+
+    QTest::newRow("test") << (QStringList() << "one" << "two" << "three" << "other...")
+                          << (IntList() << 4);
+}
+
+void tst_QComboBox::separatorItem()
+{
+    QFETCH(QStringList, items);
+    QFETCH(IntList, separators);
+
+    QComboBox box;
+    box.addItems(items);
+    foreach(int index, separators)
+        box.insertSeparator(index);
+    QCOMPARE(box.count(), (items.count() + separators.count()));
+    for (int i = 0, s = 0; i < box.count(); ++i) {
+        if (i == separators.at(s)) {
+            QCOMPARE(box.itemText(i), QString());
+            ++s;
+        } else {
+            QCOMPARE(box.itemText(i), items.at(i - s));
+        }
+    }
+}
+
+void tst_QComboBox::task190351_layout()
+{
+#ifndef QT_NO_STYLE_CLEANLOOKS
+    const QString oldStyle = QApplication::style()->objectName();
+    QApplication::setStyle(new QCleanlooksStyle);
+
+    QComboBox listCombo;
+    QListWidget *list = new QListWidget();
+    listCombo.setModel(list->model());
+    listCombo.setView(list);
+    for(int i = 1; i < 150; i++)
+        list->addItem(QLatin1String("list") + QString::number(i));
+
+    listCombo.show();
+    QTest::qWaitForWindowShown(&listCombo);
+    QTRY_VERIFY(listCombo.isVisible());
+    listCombo.setCurrentIndex(70);
+    listCombo.showPopup();
+    QTRY_VERIFY(listCombo.view());
+    QTest::qWaitForWindowShown(listCombo.view());
+    QTRY_VERIFY(listCombo.view()->isVisible());
+    QApplication::processEvents();
+
+#ifdef QT_BUILD_INTERNAL
+    QFrame *container = qFindChild<QComboBoxPrivateContainer *>(&listCombo);
+    QVERIFY(container);
+    QCOMPARE(static_cast<QAbstractItemView *>(list), qFindChild<QAbstractItemView *>(container));
+    QWidget *top = qFindChild<QComboBoxPrivateScroller *>(container);
+    QVERIFY(top);
+    QVERIFY(top->isVisible());
+    QCOMPARE(top->mapToGlobal(QPoint(0, top->height())).y(), list->mapToGlobal(QPoint()).y());
+#endif
+
+    QApplication::setStyle(oldStyle);
+#else
+    QSKIP("Qt configured without cleanlooks style", SkipAll);
+#endif
+}
+
+class task166349_ComboBox : public QComboBox
+{
+    Q_OBJECT
+public:
+    task166349_ComboBox(QWidget *parent = 0) : QComboBox(parent)
+    {
+        QStringList list;
+        list << "one" << "two";
+        connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(onCurrentIndexChanged(int)));
+        addItems(list);
+    }
+public slots:
+    void onCurrentIndexChanged(int index)
+    {
+        setEditable(index % 2 == 1);
+    }
+};
+
+void tst_QComboBox::task166349_setEditableOnReturn()
+{
+    task166349_ComboBox comboBox;
+    QTest::keyClick(&comboBox, Qt::Key_Down);
+    QTest::keyClick(&comboBox, Qt::Key_1);
+    QTest::keyClick(&comboBox, Qt::Key_Enter);
+    QCOMPARE(QLatin1String("two1"), comboBox.itemText(comboBox.count() - 1));
+}
+
+void tst_QComboBox::task191329_size()
+{
+#ifndef QT_NO_STYLE_CLEANLOOKS
+    const QString oldStyle = QApplication::style()->objectName();
+    QApplication::setStyle(new QCleanlooksStyle);
+
+    QComboBox tableCombo;
+    int rows;
+    if (QApplication::desktop()->screenGeometry().height() < 480)
+        rows = 8;
+    else
+        rows = 15;
+
+    QStandardItemModel model(rows, 2);
+    for (int row = 0; row < model.rowCount(); ++row) {
+        for (int column = 0; column < model.columnCount(); ++column) {
+            QStandardItem *item = new QStandardItem(QString("row %0, column %1").arg(row).arg(column));
+            model.setItem(row, column, item);
+        }
+    }
+    QTableView *table = new QTableView();
+    table->verticalHeader()->hide();
+    table->horizontalHeader()->hide();
+    tableCombo.setView(table);
+    tableCombo.setModel(&model);
+
+    tableCombo.show();
+    QTRY_VERIFY(tableCombo.isVisible());
+    tableCombo.showPopup();
+    QTRY_VERIFY(tableCombo.view());
+    QTRY_VERIFY(tableCombo.view()->isVisible());
+
+#ifdef QT_BUILD_INTERNAL
+    QFrame *container = qFindChild<QComboBoxPrivateContainer *>(&tableCombo);
+    QVERIFY(container);
+    QCOMPARE(static_cast<QAbstractItemView *>(table), qFindChild<QAbstractItemView *>(container));
+    foreach (QWidget *button, qFindChildren<QComboBoxPrivateScroller *>(container)) {
+        //the popup should be large enough to contains everithing so the top and left button are hidden
+        QVERIFY(!button->isVisible());
+    }
+#endif
+
+    QApplication::setStyle(oldStyle);
+#else
+    QSKIP("Qt configured without cleanlooks style", SkipAll);
+#endif
+}
+
+void tst_QComboBox::task190205_setModelAdjustToContents()
+{
+    QStringList initialContent;
+    QStringList finalContent;
+    initialContent << "foo" << "bar";
+    finalContent << "bar" << "foooooooobar";
+
+    QComboBox box;
+    box.setSizeAdjustPolicy(QComboBox::AdjustToContents);
+    box.addItems(initialContent);
+    box.show();
+
+    //wait needed in order to get the combo initial size
+    QTRY_VERIFY(box.isVisible());
+
+    box.setModel(new QStringListModel(finalContent));
+
+    QComboBox correctBox;
+    correctBox.addItems(finalContent);
+    correctBox.show();
+
+    QCoreApplication::processEvents();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&box);
+    qt_x11_wait_for_window_manager(&correctBox);
+#endif
+
+    // box should be resized to the same size as correctBox
+    QTRY_COMPARE(box.size(), correctBox.size());
+}
+
+void tst_QComboBox::task248169_popupWithMinimalSize()
+{
+    QStringList initialContent;
+    initialContent << "foo" << "bar" << "foobar";
+
+    QComboBox comboBox;
+    comboBox.addItems(initialContent);
+    QDesktopWidget desktop;
+    QRect desktopSize = desktop.availableGeometry();
+    comboBox.view()->setMinimumWidth(desktopSize.width() / 2);
+
+    comboBox.setGeometry(desktopSize.width() - (desktopSize.width() / 4), (desktopSize.width() / 4), (desktopSize.width() / 2), (desktopSize.width() / 4));
+
+    comboBox.show();
+    QTest::qWaitForWindowShown(&comboBox);
+    QTRY_VERIFY(comboBox.isVisible());
+    comboBox.showPopup();
+    QTRY_VERIFY(comboBox.view());
+    QTest::qWaitForWindowShown(comboBox.view());
+    QTRY_VERIFY(comboBox.view()->isVisible());
+
+#ifdef QT_BUILD_INTERNAL
+    QFrame *container = qFindChild<QComboBoxPrivateContainer *>(&comboBox);
+    QVERIFY(container);
+    QTRY_VERIFY(desktop.screenGeometry(container).contains(container->geometry()));
+#endif
+}
+
+void tst_QComboBox::task247863_keyBoardSelection()
+{
+  QComboBox combo;
+  combo.setEditable(false);
+  combo.addItem( QLatin1String("111"));
+  combo.addItem( QLatin1String("222"));
+  combo.show();
+  QApplication::setActiveWindow(&combo);
+  QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&combo));
+
+  QSignalSpy spy(&combo, SIGNAL(activated(const QString &)));
+  qApp->setEffectEnabled(Qt::UI_AnimateCombo, false);
+  QTest::keyClick(&combo, Qt::Key_Space);
+  qApp->setEffectEnabled(Qt::UI_AnimateCombo, true);
+  QTest::keyClick(0, Qt::Key_Down);
+  QTest::keyClick(0, Qt::Key_Enter);
+  QCOMPARE(combo.currentText(), QLatin1String("222"));
+  QCOMPARE(spy.count(), 1);
+}
+
+void tst_QComboBox::task220195_keyBoardSelection2()
+{
+    QComboBox combo;
+    combo.setEditable(false);
+    combo.addItem( QLatin1String("foo1"));
+    combo.addItem( QLatin1String("foo2"));
+    combo.addItem( QLatin1String("foo3"));
+    combo.show();
+    QApplication::setActiveWindow(&combo);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&combo));
+
+    combo.setCurrentIndex(-1);
+    QVERIFY(combo.currentText().isNull());
+
+    QTest::keyClick(&combo, 'f');
+    QCOMPARE(combo.currentText(), QLatin1String("foo1"));
+    QTest::qWait(QApplication::keyboardInputInterval() + 30);
+    QTest::keyClick(&combo, 'f');
+    QCOMPARE(combo.currentText(), QLatin1String("foo2"));
+    QTest::qWait(QApplication::keyboardInputInterval() + 30);
+    QTest::keyClick(&combo, 'f');
+    QCOMPARE(combo.currentText(), QLatin1String("foo3"));
+    QTest::qWait(QApplication::keyboardInputInterval() + 30);
+    QTest::keyClick(&combo, 'f');
+    QCOMPARE(combo.currentText(), QLatin1String("foo1"));
+    QTest::qWait(QApplication::keyboardInputInterval() + 30);
+
+    combo.setCurrentIndex(1);
+    QCOMPARE(combo.currentText(), QLatin1String("foo2"));
+    QTest::keyClick(&combo, 'f');
+    QCOMPARE(combo.currentText(), QLatin1String("foo3"));
+}
+
+
+void tst_QComboBox::setModelColumn()
+{
+    QStandardItemModel model(5,3);
+    model.setItem(0,0, new QStandardItem("0"));
+    model.setItem(1,0, new QStandardItem("1"));
+    model.setItem(2,0, new QStandardItem("2"));
+    model.setItem(3,0, new QStandardItem("3"));
+    model.setItem(4,0, new QStandardItem("4"));
+    model.setItem(0,1, new QStandardItem("zero"));
+    model.setItem(1,1, new QStandardItem("un"));
+    model.setItem(2,1, new QStandardItem("deux"));
+    model.setItem(3,1, new QStandardItem("trois"));
+    model.setItem(4,1, new QStandardItem("quatre"));
+    model.setItem(0,2, new QStandardItem("a"));
+    model.setItem(1,2, new QStandardItem("b"));
+    model.setItem(2,2, new QStandardItem("c"));
+    model.setItem(3,2, new QStandardItem("d"));
+    model.setItem(4,2, new QStandardItem("e"));
+
+    QComboBox box;
+    box.setModel(&model);
+    QCOMPARE(box.currentText(), QString("0"));
+    box.setModelColumn(1);
+    QCOMPARE(box.currentText(), QString("zero"));
+}
+
+void tst_QComboBox::noScrollbar_data()
+{
+    QTest::addColumn<QString>("stylesheet");
+
+    QTest::newRow("normal") << QString();
+    QTest::newRow("border") << QString::fromLatin1("QAbstractItemView { border: 12px solid blue;}");
+    QTest::newRow("margin") << QString::fromLatin1("QAbstractItemView { margin: 12px 15px 13px 10px; }");
+    QTest::newRow("padding") << QString::fromLatin1("QAbstractItemView { padding: 12px 15px 13px 10px;}");
+    QTest::newRow("everything") << QString::fromLatin1("QAbstractItemView {  border: 12px  solid blue; "
+                                                       " padding: 12px 15px 13px 10px; margin: 12px 15px 13px 10px;  }");
+    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; } " );
+}
+
+void tst_QComboBox::noScrollbar()
+{
+    QStringList initialContent;
+    initialContent << "foo" << "bar" << "foobar" << "moo";
+    QFETCH(QString, stylesheet);
+    QString oldCss = qApp->styleSheet();
+    qApp->setStyleSheet(stylesheet);
+
+    {
+        QWidget topLevel;
+        QComboBox comboBox(&topLevel);
+        comboBox.addItems(initialContent);
+        topLevel.show();
+        comboBox.resize(200, comboBox.height());
+        QTRY_VERIFY(comboBox.isVisible());
+        comboBox.showPopup();
+        QTRY_VERIFY(comboBox.view());
+        QTRY_VERIFY(comboBox.view()->isVisible());
+
+        QVERIFY(!comboBox.view()->horizontalScrollBar()->isVisible());
+        QVERIFY(!comboBox.view()->verticalScrollBar()->isVisible());
+    }
+
+    {
+        QTableWidget *table = new QTableWidget(2,2);
+        QComboBox comboBox;
+        comboBox.setModel(table->model());
+        comboBox.setView(table);
+        comboBox.show();
+        QTRY_VERIFY(comboBox.isVisible());
+        comboBox.resize(200, comboBox.height());
+        comboBox.showPopup();
+        QTRY_VERIFY(comboBox.view());
+        QTRY_VERIFY(comboBox.view()->isVisible());
+
+        QVERIFY(!comboBox.view()->horizontalScrollBar()->isVisible());
+        QVERIFY(!comboBox.view()->verticalScrollBar()->isVisible());
+    }
+
+    qApp->setStyleSheet(oldCss);
+}
+
+void tst_QComboBox::setItemDelegate()
+{
+    QComboBox comboBox;
+    QStyledItemDelegate *itemDelegate = new QStyledItemDelegate;
+    comboBox.setItemDelegate(itemDelegate);
+    // the cast is a workaround for the XLC and Metrowerks compilers
+    QCOMPARE(static_cast<QStyledItemDelegate *>(comboBox.itemDelegate()), itemDelegate);
+}
+
+void tst_QComboBox::task253944_itemDelegateIsReset()
+{
+    QComboBox comboBox;
+    QStyledItemDelegate *itemDelegate = new QStyledItemDelegate;
+    comboBox.setItemDelegate(itemDelegate);
+
+    // the casts are workarounds for the XLC and Metrowerks compilers
+
+    comboBox.setEditable(true);
+    QCOMPARE(static_cast<QStyledItemDelegate *>(comboBox.itemDelegate()), itemDelegate);
+
+    comboBox.setStyleSheet("QComboBox { border: 1px solid gray; }");
+    QCOMPARE(static_cast<QStyledItemDelegate *>(comboBox.itemDelegate()), itemDelegate);
+}
+
+
+void tst_QComboBox::subControlRectsWithOffset_data()
+{
+    QTest::addColumn<bool>("editable");
+
+    QTest::newRow("editable = true") << true;
+    QTest::newRow("editable = false") << false;
+}
+
+void tst_QComboBox::subControlRectsWithOffset()
+{
+    // The sub control rect relative position should not depends
+    // on the position of the combobox
+
+    class FriendlyCombo : public QComboBox {
+    public:
+        void styleOption(QStyleOptionComboBox *optCombo) {
+            initStyleOption(optCombo);
+        }
+    } combo;
+    QStyleOptionComboBox optCombo;
+    combo.styleOption(&optCombo);
+
+
+    const QRect rectAtOrigin(0, 0, 80, 30);
+    const QPoint offset(25, 50);
+    const QRect rectWithOffset = rectAtOrigin.translated(offset);
+
+    QStyle *style = combo.style();
+
+    QFETCH(bool, editable);
+    optCombo.editable = editable;
+
+    optCombo.rect = rectAtOrigin;
+    QRect editFieldRect = style->subControlRect(QStyle::CC_ComboBox, &optCombo, QStyle::SC_ComboBoxEditField, 0);
+    QRect arrowRect = style->subControlRect(QStyle::CC_ComboBox, &optCombo, QStyle::SC_ComboBoxArrow, 0);
+    QRect listboxRect = style->subControlRect(QStyle::CC_ComboBox, &optCombo, QStyle::SC_ComboBoxListBoxPopup, 0);
+
+    optCombo.rect = rectWithOffset;
+    QRect editFieldRectWithOffset = style->subControlRect(QStyle::CC_ComboBox, &optCombo, QStyle::SC_ComboBoxEditField, 0);
+    QRect arrowRectWithOffset = style->subControlRect(QStyle::CC_ComboBox, &optCombo, QStyle::SC_ComboBoxArrow, 0);
+    QRect listboxRectWithOffset = style->subControlRect(QStyle::CC_ComboBox, &optCombo, QStyle::SC_ComboBoxListBoxPopup, 0);
+
+    QCOMPARE(editFieldRect, editFieldRectWithOffset.translated(-offset));
+    QCOMPARE(arrowRect, arrowRectWithOffset.translated(-offset));
+    QCOMPARE(listboxRect, listboxRectWithOffset.translated(-offset));
+
+}
+
+void tst_QComboBox::task260974_menuItemRectangleForComboBoxPopup()
+{
+#ifdef QT_NO_STYLE_WINDOWS
+    QSKIP("test depends on windows style", QTest::SkipAll);
+#else
+    class TestStyle: public QWindowsStyle
+    {
+    public:
+        int styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *ret) const
+        {
+            if (hint == SH_ComboBox_Popup) return 1;
+            else return QCommonStyle::styleHint(hint, option, widget, ret);
+        }
+
+        void drawControl(ControlElement element, const QStyleOption *option, QPainter *, const QWidget *) const
+        {
+            if (element == CE_MenuItem)
+                discoveredRect = option->rect;
+        }
+
+        mutable QRect discoveredRect;
+    } style;
+
+
+    {
+        QComboBox comboBox;
+        comboBox.setStyle(&style);
+        comboBox.addItem("Item 1");
+
+        comboBox.show();
+        QTRY_VERIFY(comboBox.isVisible());
+        comboBox.showPopup();
+        QTRY_VERIFY(comboBox.view());
+        QTRY_VERIFY(comboBox.view()->isVisible());
+
+        QTRY_VERIFY(style.discoveredRect.width() <= comboBox.width());
+    }
+#endif
+}
+
+void tst_QComboBox::removeItem()
+{
+    QComboBox cb;
+    cb.removeItem(-1);
+    cb.removeItem(1);
+    cb.removeItem(0);
+    QCOMPARE(cb.count(), 0);
+
+    cb.addItem("foo");
+    cb.removeItem(-1);
+    QCOMPARE(cb.count(), 1);
+    cb.removeItem(1);
+    QCOMPARE(cb.count(), 1);
+    cb.removeItem(0);
+    QCOMPARE(cb.count(), 0);
+}
+
+void tst_QComboBox::resetModel()
+{
+    class StringListModel : public QStringListModel
+    {
+    public:
+        StringListModel(const QStringList &list) : QStringListModel(list)
+        {
+        }
+
+        void reset()
+        {
+            QStringListModel::reset();
+        }
+    };
+    QComboBox cb;
+    StringListModel model( QStringList() << "1" << "2");
+    QSignalSpy spy(&cb, SIGNAL(currentIndexChanged(int)));
+    QCOMPARE(spy.count(), 0);
+    QCOMPARE(cb.currentIndex(), -1); //no selection
+
+    cb.setModel(&model);
+
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(cb.currentIndex(), 0); //first item selected
+
+    model.reset();
+    QCOMPARE(spy.count(), 2);
+    QCOMPARE(cb.currentIndex(), -1); //no selection
+
+}
+
+void tst_QComboBox::keyBoardNavigationWithMouse()
+{
+    QComboBox combo;
+    combo.setEditable(false);
+    for (int i = 0; i < 80; i++)
+        combo.addItem( QString::number(i));
+    combo.show();
+    QApplication::setActiveWindow(&combo);
+    QTest::qWaitForWindowShown(&combo);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&combo));
+
+    QCOMPARE(combo.currentText(), QLatin1String("0"));
+
+    combo.setFocus();
+    QTRY_VERIFY(combo.hasFocus());
+
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Space);
+    QTest::qWait(30);
+    QTRY_VERIFY(combo.view());
+    QTRY_VERIFY(combo.view()->isVisible());
+    QTest::qWait(130);
+
+    QCOMPARE(combo.currentText(), QLatin1String("0"));
+
+#ifdef Q_OS_WINCE
+    QSKIP("When calling cursor function, Windows CE responds with: This function is not supported on this system.", SkipAll);
+#endif
+
+    QCursor::setPos(combo.view()->mapToGlobal(combo.view()->rect().center()));
+    QTest::qWait(200);
+
+#define GET_SELECTION(SEL) \
+    QCOMPARE(combo.view()->selectionModel()->selection().count(), 1); \
+    QCOMPARE(combo.view()->selectionModel()->selection().indexes().count(), 1); \
+    SEL = combo.view()->selectionModel()->selection().indexes().first().row()
+
+    int selection;
+    GET_SELECTION(selection);
+
+    //since we moved the mouse is in the middle it should even be around 5;
+    QVERIFY(selection > 3);
+
+    static const int final = 40;
+    for (int i = selection + 1;  i <= final; i++)
+    {
+        QTest::keyClick(combo.view(), Qt::Key_Down);
+        QTest::qWait(20);
+        GET_SELECTION(selection);
+        QCOMPARE(selection, i);
+    }
+
+    QTest::keyClick(combo.view(), Qt::Key_Enter);
+    QTRY_COMPARE(combo.currentText(), QString::number(final));
+}
+
+void tst_QComboBox::task_QTBUG_1071_changingFocusEmitsActivated()
+{
+    QWidget w;
+    QVBoxLayout layout(&w);
+    QComboBox cb;
+    cb.setEditable(true);
+    QSignalSpy spy(&cb, SIGNAL(activated(int)));
+    cb.addItem("0");
+    cb.addItem("1");
+    cb.addItem("2");
+    QLineEdit edit;
+    layout.addWidget(&cb);
+    layout.addWidget(&edit);
+
+    w.show();
+    QApplication::setActiveWindow(&w);
+    QTest::qWaitForWindowShown(&w);
+    cb.clearEditText();
+    cb.setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(cb.hasFocus());
+    QTest::keyClick(0, '1');
+    QCOMPARE(spy.count(), 0);
+    edit.setFocus();
+    QTRY_VERIFY(edit.hasFocus());
+    QTRY_COMPARE(spy.count(), 1);
+}
+
+void tst_QComboBox::maxVisibleItems()
+{
+    QComboBox comboBox;
+    QCOMPARE(comboBox.maxVisibleItems(), 10); //default value.
+
+    QStringList content;
+    for(int i = 1; i < 50; i++)
+        content += QString::number(i);
+
+    comboBox.addItems(content);
+    comboBox.show();
+    comboBox.resize(200, comboBox.height());
+    QTRY_VERIFY(comboBox.isVisible());
+
+    comboBox.setMaxVisibleItems(5);
+    QCOMPARE(comboBox.maxVisibleItems(), 5);
+
+    comboBox.showPopup();
+    QTRY_VERIFY(comboBox.view());
+    QTRY_VERIFY(comboBox.view()->isVisible());
+
+    QAbstractItemView *v = comboBox.view();
+    int itemHeight = v->visualRect(v->model()->index(0,0)).height();
+    QListView *lv = qobject_cast<QListView*>(v);
+    if (lv)
+        itemHeight += lv->spacing();
+    QStyleOptionComboBox opt;
+    opt.initFrom(&comboBox);
+    if (!comboBox.style()->styleHint(QStyle::SH_ComboBox_Popup, &opt))
+        QCOMPARE(v->viewport()->height(), itemHeight * comboBox.maxVisibleItems());
+}
+
+void tst_QComboBox::task_QTBUG_10491_currentIndexAndModelColumn()
+{
+    QComboBox comboBox;
+
+    QStandardItemModel model(4, 4, &comboBox);
+    for (int i = 0; i < 4; i++){
+        model.setItem(i, 0, new QStandardItem(QString("Employee Nr %1").arg(i)));
+        model.setItem(i, 1, new QStandardItem(QString("Street Nr %1").arg(i)));
+        model.setItem(i, 2, new QStandardItem(QString("Town Nr %1").arg(i)));
+        model.setItem(i, 3, new QStandardItem(QString("Phone Nr %1").arg(i)));
+    }
+    comboBox.setModel(&model);
+    comboBox.setModelColumn(0);
+
+    QComboBoxPrivate *d = static_cast<QComboBoxPrivate *>(QComboBoxPrivate::get(&comboBox));
+    d->setCurrentIndex(model.index(2, 2));
+    QCOMPARE(QModelIndex(d->currentIndex), model.index(2, comboBox.modelColumn()));
+}
+
+QTEST_MAIN(tst_QComboBox)
+#include "tst_qcombobox.moc"