/****************************************************************************

**

** Copyright (C) 2009 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>

#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();

protected slots:

    void onEditTextChanged( const QString &newString );

private:

    QComboBox *testWidget;

    QDialog *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 QDialog(0);

    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);

        }

    }

}

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);