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

**

** 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 <q3combobox.h>

#include <q3listbox.h>

#include <qlineedit.h>

#include <QValidator>

class tst_Q3ComboBox : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void q3combobox_data();

    void q3combobox();

    void autoCompletion_data();

    void autoCompletion();

    void autoResize_data();

    void autoResize();

    void changeItem_data();

    void changeItem();

    void clear_data();

    void clear();

    void clearEdit_data();

    void clearEdit();

    void count_data();

    void count();

    void currentItem_data();

    void currentItem();

    void currentText_data();

    void currentText();

    void duplicatesEnabled_data();

    void duplicatesEnabled();

    void editable_data();

    void editable();

    void insertItem_data();

    void insertItem();

    void insertStringList_data();

    void insertStringList();

    void insertStrList_data();

    void insertStrList();

    void maxCount_data();

    void maxCount();

    void pixmap();

    void removeItem_data();

    void removeItem();

    void setValidator();

    void keyPressEvent_data();

    void keyPressEvent();

    void wheelEvent_data();

    void wheelEvent();

    void task231724_clear();

};

// Subclass that exposes the protected functions.

class SubQ3ComboBox : public Q3ComboBox

{

public:

    void call_activated(int index)

        { return SubQ3ComboBox::activated(index); }

    void call_activated(QString const& str)

        { return SubQ3ComboBox::activated(str); }

    void call_focusInEvent(QFocusEvent* e)

        { return SubQ3ComboBox::focusInEvent(e); }

    void call_focusOutEvent(QFocusEvent* e)

        { return SubQ3ComboBox::focusOutEvent(e); }

    void call_highlighted(QString const& str)

        { return SubQ3ComboBox::highlighted(str); }

    void call_highlighted(int index)

        { return SubQ3ComboBox::highlighted(index); }

    void call_keyPressEvent(QKeyEvent* e)

        { return SubQ3ComboBox::keyPressEvent(e); }

    void call_mouseDoubleClickEvent(QMouseEvent* e)

        { return SubQ3ComboBox::mouseDoubleClickEvent(e); }

    void call_mouseMoveEvent(QMouseEvent* e)

        { return SubQ3ComboBox::mouseMoveEvent(e); }

    void call_mousePressEvent(QMouseEvent* e)

        { return SubQ3ComboBox::mousePressEvent(e); }

    void call_mouseReleaseEvent(QMouseEvent* e)

        { return SubQ3ComboBox::mouseReleaseEvent(e); }

    void call_paintEvent(QPaintEvent* e)

        { return SubQ3ComboBox::paintEvent(e); }

    void call_resizeEvent(QResizeEvent* e)

        { return SubQ3ComboBox::resizeEvent(e); }

    void call_styleChange(QStyle& style)

        { return SubQ3ComboBox::styleChange(style); }

    void call_textChanged(QString const& str)

        { return SubQ3ComboBox::textChanged(str); }

    void call_updateMask()

        { return SubQ3ComboBox::updateMask(); }

    void call_wheelEvent(QWheelEvent* e)

        { return SubQ3ComboBox::wheelEvent(e); }

};

// This will be called before the first test function is executed.

// It is only called once.

void tst_Q3ComboBox::initTestCase()

{

}

// This will be called after the last test function is executed.

// It is only called once.

void tst_Q3ComboBox::cleanupTestCase()

{

}

// This will be called before each test function is executed.

void tst_Q3ComboBox::init()

{

}

// This will be called after every test function.

void tst_Q3ComboBox::cleanup()

{

}

void tst_Q3ComboBox::q3combobox_data()

{

}

void tst_Q3ComboBox::q3combobox()

{

    SubQ3ComboBox box;

    box.autoCompletion();

    box.autoResize();

    box.changeItem(QString(), 0);

    box.changeItem(QPixmap(), 0);

    box.changeItem(QPixmap(), QString(), 0);

    box.clear();

    box.clearEdit();

    box.clearValidator();

    box.count();

    box.currentItem();

    box.currentText();

    box.duplicatesEnabled();

    box.editable();

    box.hide();

    box.insertionPolicy();

    box.insertItem(QString());

    box.insertItem(QPixmap(), -1);

    box.insertItem(QPixmap(), QString(), -1);

    box.insertStringList(QStringList());

    static const char* items[] = { "red", "green", "blue", 0 };

    box.insertStrList(items);

    box.lineEdit();

    box.listBox();

    box.maxCount();

    box.pixmap(0);

    box.popup();

    box.removeItem(0);

    box.setAutoCompletion(false);

    box.setAutoResize(false);

    box.setCurrentItem(0);

    box.setCurrentText(QString());

    box.setDuplicatesEnabled(true);

    box.setEditable(false);

    box.setEditText(false);

    box.setEnabled(false);

    box.setFont(QFont());

    box.setInsertionPolicy(Q3ComboBox::NoInsertion);

    box.setLineEdit(0);

    //box.setListBox(0);

    box.setMaxCount(0);

    box.setPalette(QPalette());

    box.setSizeLimit(0);

    box.setValidator(0);

    box.sizeHint();

    box.sizeLimit();

    box.text(0);

    box.validator();

    box.call_activated(0);

    box.call_activated(QString());

    box.call_highlighted(0);

    box.call_highlighted(QString());

    box.call_textChanged(QString());

    box.call_updateMask();

}

void tst_Q3ComboBox::autoCompletion_data()

{

    QTest::addColumn<bool>("autoCompletion");

    QTest::newRow("false") << false;

    QTest::newRow("true") << true;

}

// public bool autoCompletion() const

void tst_Q3ComboBox::autoCompletion()

{

    QFETCH(bool, autoCompletion);

    SubQ3ComboBox box;

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    box.setAutoCompletion(autoCompletion);

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), 0);

    QCOMPARE(spy3.count(), 0);

    QCOMPARE(spy4.count(), 0);

    QCOMPARE(box.autoCompletion(), autoCompletion);

}

void tst_Q3ComboBox::autoResize_data()

{

    QTest::addColumn<bool>("autoResize");

    QTest::newRow("false") << false;

    QTest::newRow("true") << true;

}

// public bool autoResize() const

void tst_Q3ComboBox::autoResize()

{

    QFETCH(bool, autoResize);

    SubQ3ComboBox box;

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    QSize oldSize = box.size();

    box.setAutoResize(autoResize);

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), 0);

    QCOMPARE(spy3.count(), 0);

    QCOMPARE(spy4.count(), 0);

    QCOMPARE(box.autoResize(), autoResize);

    if (autoResize)

        QVERIFY(oldSize != box.size());

    else

        QCOMPARE(oldSize, box.size());

}

void tst_Q3ComboBox::changeItem_data()

{

    QTest::addColumn<QPixmap>("pixmap");

    QTest::addColumn<QString>("text");

    QTest::addColumn<int>("index");

    QTest::newRow("null") << QPixmap() << QString("foo") << 0;

}

// public void changeItem(QPixmap const& pixmap, QString const& text, int index)

void tst_Q3ComboBox::changeItem()

{

    QFETCH(QPixmap, pixmap);

    QFETCH(QString, text);

    QFETCH(int, index);

    SubQ3ComboBox box;

    box.insertItem("stub");

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    box.changeItem(pixmap, text, index);

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), box.listBox() ? 1 : 0);

    QCOMPARE(spy3.count(), box.listBox() ? 1 : 0);

    QCOMPARE(spy4.count(), 0);

    QCOMPARE(box.text(index), text);

    if (pixmap.isNull()) {

        QVERIFY(!box.pixmap(index) || box.pixmap(index)->isNull());

    } else {

        QCOMPARE(*box.pixmap(index), pixmap);

    }

}

void tst_Q3ComboBox::clear_data()

{

    QTest::addColumn<QStringList>("list");

    QTest::newRow("null") << QStringList();

    QTest::newRow("1") << (QStringList() << "x");

    QTest::newRow("2") << (QStringList() << "x" << "y");

    QTest::newRow("3") << (QStringList() << "x" << "y" << "z");

}

// public void clear()

void tst_Q3ComboBox::clear()

{

    QFETCH(QStringList, list);

    SubQ3ComboBox box;

    box.insertStringList(list);

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    box.clear();

    QCOMPARE(box.count(), 0);

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), 0);

    QCOMPARE(spy3.count(), 0);

    QCOMPARE(spy4.count(), 0);

}

void tst_Q3ComboBox::clearEdit_data()

{

    QTest::addColumn<bool>("editable");

    QTest::addColumn<QStringList>("list");

    QTest::newRow("non-editable") << false << QStringList();

    QTest::newRow("editable-empty") << true << QStringList();

    QTest::newRow("editable-3") << true << (QStringList() << "x" << "y" << "z");

}

// public void clearEdit()

void tst_Q3ComboBox::clearEdit()

{

    QFETCH(QStringList, list);

    QFETCH(bool, editable);

    SubQ3ComboBox box;

    box.setEditable(editable);

    box.insertStringList(list);

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    box.clearEdit();

    QCOMPARE(box.count(), list.count());

    for (int i = 0; i < list.count(); ++i)

        QCOMPARE(box.text(i), list.at(i));

    if (editable) {

        QVERIFY(box.lineEdit());

        QVERIFY(box.lineEdit()->text().isEmpty());

    }

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), 0);

    QCOMPARE(spy3.count(), 0);

    QCOMPARE(spy4.count(), (editable && !list.isEmpty())? 1 : 0);

}

void tst_Q3ComboBox::count_data()

{

    QTest::addColumn<bool>("useListBox");

    QTest::addColumn<QStringList>("list");

    QTest::newRow("popup-empty") << false << QStringList();

    QTest::newRow("popup-3") << false << (QStringList() << "x" << "y" << "z");

    QTest::newRow("listbox-empty") << true << QStringList();

    QTest::newRow("listbox-3") << true << (QStringList() << "x" << "y" << "z");

}

// public int count() const

void tst_Q3ComboBox::count()

{

    QFETCH(bool, useListBox);

    QFETCH(QStringList, list);

    SubQ3ComboBox box;

    box.insertStringList(list);

    Q3ListBox *listBox = new Q3ListBox(&box);

    if (useListBox) {

        box.setListBox(listBox);

        QCOMPARE(box.listBox(), listBox);

        QCOMPARE(box.count(), 0);

        listBox->insertStringList(list);

        QCOMPARE(box.count(), list.count());

    }

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    QCOMPARE(box.count(), list.count());

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), 0);

    QCOMPARE(spy3.count(), 0);

    QCOMPARE(spy4.count(), 0);

}

void tst_Q3ComboBox::currentItem_data()

{

    QTest::addColumn<QStringList>("list");

    QTest::addColumn<int>("setCurrentItem");

    QTest::addColumn<int>("currentItem");

    QTest::addColumn<bool>("signal");

    QStringList list = (QStringList() << "x" << "y" << "z");

    QTest::newRow("3 0,0") << list << 0 << 0 << false;

    QTest::newRow("3 1,1") << list << 1 << 1 << true;

    QTest::newRow("3 2,2") << list << 2 << 2 << true;

    QTest::newRow("3 3,0") << list << 3 << 0 << false;

    QTest::newRow("- 1,0") << QStringList() << 1 << 0 << false;

}

// public int currentItem() const

void tst_Q3ComboBox::currentItem()

{

    QFETCH(QStringList, list);

    QFETCH(int, setCurrentItem);

    QFETCH(int, currentItem);

    QFETCH(bool, signal);

    SubQ3ComboBox box;

    box.insertStringList(list);

    QSignalSpy spy0(&box, SIGNAL(activated(int)));

    QSignalSpy spy1(&box, SIGNAL(activated(QString)));

    QSignalSpy spy2(&box, SIGNAL(highlighted(int)));

    QSignalSpy spy3(&box, SIGNAL(highlighted(QString)));

    QSignalSpy spy4(&box, SIGNAL(textChanged(QString)));

    box.setCurrentItem(setCurrentItem);

    QCOMPARE(box.currentItem(), currentItem);

    QCOMPARE(spy0.count(), 0);

    QCOMPARE(spy1.count(), 0);

    QCOMPARE(spy2.count(), signal ? 1 : 0);

    QCOMPARE(spy3.count(), signal ? 1 : 0);

    QCOMPARE(spy4.count(), 0);

}

void tst_Q3ComboBox::currentText_data()

{

    QTest::addColumn<QStringList>("list");

    QTest::addColumn<int>("currentItem");

    QTest::addColumn<QString>("currentText");

    QTest::addColumn<int>("expectedCurrentItem");

    QTest::addColumn<bool>("signal");

    QTest::newRow("null") << QStringList() << 0 << QString("foo") << 0 << false;

    QStringList list = (QStringList() << "x" << "y" << "z");

    QTest::newRow("3,0") << list << 0 << QString("x") << 0 << false;

    QTest::newRow("3,1") << list << 0 << QString("y") << 1 << true;

    QTest::newRow("3,2") << list << 0 << QString("z") << 2 << true;

}

// public QString currentText() const

void tst_Q3ComboBox::currentText()

{

    QFETCH(QStringList, list);

    QFETCH(int, currentItem);

    QFETCH(QString, currentText);

    QFETCH(int, expectedCurrentItem);

    QFETCH(bool, signal);

    SubQ3ComboBox box;

    QVERIFY(box.currentText().isEmpty());