summaryrefslogtreecommitdiffstats
path: root/tests/auto/q3combobox
diff options
context:
space:
mode:
authorLars Knoll <lars.knoll@nokia.com>2009-03-23 09:34:13 (GMT)
committerSimon Hausmann <simon.hausmann@nokia.com>2009-03-23 09:34:13 (GMT)
commit67ad0519fd165acee4a4d2a94fa502e9e4847bd0 (patch)
tree1dbf50b3dff8d5ca7e9344733968c72704eb15ff /tests/auto/q3combobox
downloadQt-67ad0519fd165acee4a4d2a94fa502e9e4847bd0.zip
Qt-67ad0519fd165acee4a4d2a94fa502e9e4847bd0.tar.gz
Qt-67ad0519fd165acee4a4d2a94fa502e9e4847bd0.tar.bz2
Long live Qt!
Diffstat (limited to 'tests/auto/q3combobox')
-rw-r--r--tests/auto/q3combobox/.gitignore1
-rw-r--r--tests/auto/q3combobox/q3combobox.pro3
-rw-r--r--tests/auto/q3combobox/tst_q3combobox.cpp1041
3 files changed, 1045 insertions, 0 deletions
diff --git a/tests/auto/q3combobox/.gitignore b/tests/auto/q3combobox/.gitignore
new file mode 100644
index 0000000..e4d05c3
--- /dev/null
+++ b/tests/auto/q3combobox/.gitignore
@@ -0,0 +1 @@
+tst_q3combobox
diff --git a/tests/auto/q3combobox/q3combobox.pro b/tests/auto/q3combobox/q3combobox.pro
new file mode 100644
index 0000000..2391f6c
--- /dev/null
+++ b/tests/auto/q3combobox/q3combobox.pro
@@ -0,0 +1,3 @@
+load(qttest_p4)
+SOURCES += tst_q3combobox.cpp
+QT += qt3support
diff --git a/tests/auto/q3combobox/tst_q3combobox.cpp b/tests/auto/q3combobox/tst_q3combobox.cpp
new file mode 100644
index 0000000..f0a6b1c
--- /dev/null
+++ b/tests/auto/q3combobox/tst_q3combobox.cpp
@@ -0,0 +1,1041 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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());
+ box.insertStringList(list);
+ box.setCurrentItem(currentItem);
+
+ 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.setCurrentText(currentText);
+ if (list.isEmpty())
+ QVERIFY(box.currentText().isEmpty());
+ else {
+ QCOMPARE(box.currentText(), currentText);
+ QCOMPARE(box.currentItem(), expectedCurrentItem);
+ }
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), signal ? 1 : 0);
+ QCOMPARE(spy3.count(), signal ? 1 : 0);
+ QCOMPARE(spy4.count(), 0);
+}
+
+Q_DECLARE_METATYPE(Q3ComboBox::Policy)
+void tst_Q3ComboBox::duplicatesEnabled_data()
+{
+ QTest::addColumn<QStringList>("list");
+ QTest::addColumn<bool>("duplicatesEnabled");
+ QTest::addColumn<int>("count");
+ QTest::addColumn<QString>("string");
+ QTest::addColumn<int>("postCount");
+ QTest::addColumn<Q3ComboBox::Policy>("policy");
+ QTest::addColumn<bool>("activatedSignal");
+ QTest::addColumn<bool>("highlightedSignal");
+
+ QStringList list = (QStringList() << "x" << "y" << "z");
+
+ QTest::newRow("null") << QStringList() << false << 0 << QString() << 0 << Q3ComboBox::AtTop << false << false;
+ QTest::newRow("3, no-dup-3") << list << false << list.count() << QString() << list.count() << Q3ComboBox::AtTop << false << false;
+ QTest::newRow("3, dup-3") << list << true << list.count() << QString() << list.count() << Q3ComboBox::AtTop << false << false;
+ QStringList duplist = list;
+ duplist << list[0];
+
+ int c = duplist.count();
+ QTest::newRow("4, no-dup-wdup-4") << duplist << false << c << "x" << c << Q3ComboBox::AtTop << true << true;
+
+ QTest::newRow("4, dup-wdup-4 noIn") << duplist << true << c << "x" << c << Q3ComboBox::NoInsertion << true << false;
+ QTest::newRow("4, dup-wdup-4 atTop") << duplist << true << c << "x" << c + 1 << Q3ComboBox::AtTop << true << true;
+}
+
+// public bool duplicatesEnabled() const
+void tst_Q3ComboBox::duplicatesEnabled()
+{
+ QFETCH(QStringList, list);
+ QFETCH(bool, duplicatesEnabled);
+ QFETCH(int, count);
+ QFETCH(QString, string);
+ QFETCH(int, postCount);
+ QFETCH(Q3ComboBox::Policy, policy);
+ QFETCH(bool, activatedSignal);
+ QFETCH(bool, highlightedSignal);
+
+ SubQ3ComboBox box;
+ box.setEditable(true);
+ box.insertStringList(list);
+ box.setInsertionPolicy(policy);
+ box.setCurrentItem(1);
+ QCOMPARE(box.insertionPolicy(), policy);
+
+ 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.setDuplicatesEnabled(duplicatesEnabled);
+ QCOMPARE(box.duplicatesEnabled(), duplicatesEnabled);
+ QCOMPARE(box.count(), count);
+
+ box.setEditText(string);
+ QCOMPARE(box.lineEdit()->text(), string);
+ QTest::keyPress(box.lineEdit(), Qt::Key_Return);
+ QCOMPARE(box.count(), postCount);
+ if (postCount != list.count()) {
+ switch (policy) {
+ case Q3ComboBox::InsertBeforeCurrent:
+ QCOMPARE(box.text(0), string);
+ break;
+ case Q3ComboBox::InsertAtCurrent:
+ QCOMPARE(box.text(1), string);
+ break;
+ case Q3ComboBox::InsertAfterCurrent:
+ QCOMPARE(box.text(2), string);
+ break;
+ case Q3ComboBox::InsertAtTop:
+ QCOMPARE(box.text(0), string);
+ break;
+ case Q3ComboBox::InsertAtBottom:
+ QCOMPARE(box.text(box.count() - 1), string);
+ break;
+ case Q3ComboBox::NoInsert:
+ break;
+ }
+ }
+
+ //QCOMPARE(spy0.count(), activatedSignal ? 1 : 0);
+ //QCOMPARE(spy1.count(), activatedSignal ? 1 : 0);
+ QCOMPARE(spy2.count(), highlightedSignal ? 1 : 0);
+ QCOMPARE(spy3.count(), highlightedSignal ? 1 : 0);
+ QCOMPARE(spy4.count(), !list.isEmpty() ? 1 : 0);
+}
+
+void tst_Q3ComboBox::editable_data()
+{
+ QTest::addColumn<QStringList>("list");
+ QTest::addColumn<bool>("editable");
+ QTest::newRow("empty-noneditable") << QStringList() << false;
+ QTest::newRow("empty-editable") << QStringList() << true;
+}
+
+// public bool editable() const
+void tst_Q3ComboBox::editable()
+{
+ QFETCH(QStringList, list);
+ QFETCH(bool, editable);
+
+ 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.setEditable(editable);
+ QCOMPARE(box.editable(), editable);
+ if (box.editable()) {
+ QVERIFY(box.lineEdit());
+ if (!list.empty())
+ QCOMPARE(box.lineEdit()->text(), list[box.currentItem()]);
+
+ box.setEditable(false);
+ QVERIFY(!box.lineEdit());
+ }
+
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), 0);
+ QCOMPARE(spy3.count(), 0);
+ QCOMPARE(spy4.count(), 0);
+}
+
+void tst_Q3ComboBox::insertItem_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<QString>("string");
+ QTest::addColumn<int>("index");
+ QTest::addColumn<QStringList>("expected");
+ QTest::newRow("null") << QStringList() << QString() << 0 << (QStringList() << QString());
+ QTest::newRow("front") << (QStringList() << "x") << QString() << 0 << (QStringList() << QString() << "x");
+ QTest::newRow("back") << (QStringList() << "x") << QString() << 1 << (QStringList() << "x" << QString());
+}
+
+// public void insertItem(QPixmap const& pixmap, int index = -1)
+void tst_Q3ComboBox::insertItem()
+{
+ QFETCH(QStringList, init);
+ QFETCH(QString, string);
+ QFETCH(int, index);
+ QFETCH(QStringList, expected);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+
+ 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.insertItem(string, index);
+ for (int i = 0; i < expected.count(); ++i)
+ QCOMPARE(box.text(i), expected.at(i));
+
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), 0);
+ QCOMPARE(spy3.count(), 0);
+ QCOMPARE(spy4.count(), 0);
+}
+
+Q_DECLARE_METATYPE(QStringList)
+void tst_Q3ComboBox::insertStringList_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<QStringList>("stringlist");
+ QTest::addColumn<int>("index");
+ QTest::addColumn<QStringList>("expected");
+ QTest::newRow("null") << QStringList() << QStringList() << 0 << (QStringList() << QString());
+ QTest::newRow("front") << (QStringList() << "x") << (QStringList() << "y") << 0 << (QStringList() << "y" << "x");
+ QTest::newRow("back") << (QStringList() << "x") << (QStringList() << "y") << 1 << (QStringList() << "x" << "y");
+}
+
+// public void insertStringList(QStringList const& , int index = -1)
+void tst_Q3ComboBox::insertStringList()
+{
+ QFETCH(QStringList, init);
+ QFETCH(QStringList, stringlist);
+ QFETCH(int, index);
+ QFETCH(QStringList, expected);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+
+ 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.insertStringList(stringlist, index);
+ for (int i = 0; i < expected.count(); ++i)
+ QCOMPARE(box.text(i), expected.at(i));
+
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), 0);
+ QCOMPARE(spy3.count(), 0);
+ QCOMPARE(spy4.count(), 0);
+}
+
+void tst_Q3ComboBox::insertStrList_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<int>("index");
+ QTest::addColumn<QStringList>("expected");
+ QTest::newRow("front") << (QStringList() << "x") << 0 << (QStringList() << "y" << "x");
+ QTest::newRow("back") << (QStringList() << "x") << 1 << (QStringList() << "x" << "y");
+}
+
+// public void insertStrList(Q3StrList const* , int index = -1)
+void tst_Q3ComboBox::insertStrList()
+{
+ QFETCH(QStringList, init);
+ static const char* strings[] = { "y", 0 };
+ QFETCH(int, index);
+ QFETCH(QStringList, expected);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+
+ 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.insertStrList(strings, -1, index);
+ for (int i = 0; i < expected.count(); ++i)
+ QCOMPARE(box.text(i), expected.at(i));
+
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), 0);
+ QCOMPARE(spy3.count(), 0);
+ QCOMPARE(spy4.count(), 0);
+}
+
+void tst_Q3ComboBox::maxCount_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<int>("maxCount");
+ QTest::addColumn<QStringList>("expected");
+ QStringList empty;
+ QTest::newRow("remove-all-1") << (QStringList(empty) << "x") << 0 << (QStringList(empty));
+ QTest::newRow("remove-all-2") << (QStringList(empty) << "x" << "y") << 0 << (QStringList(empty));
+ QTest::newRow("remove-one") << (QStringList(empty) << "x" << "y") << 1 << (QStringList(empty) << "x");
+ QTest::newRow("remove-two") << (QStringList(empty) << "x" << "y" << "z") << 1 << (QStringList(empty) << "x");
+ QTest::newRow("do-nothing-1") << (QStringList(empty) << "x") << 1 << (QStringList(empty) << "x");
+ QTest::newRow("do-nothing-2") << (QStringList(empty) << "x") << 2 << (QStringList(empty) << "x");
+ QTest::newRow("do-nothing-3") << (QStringList(empty) << "x" << "y") << 2 << (QStringList(empty) << "x" << "y");
+}
+
+// public int maxCount() const
+void tst_Q3ComboBox::maxCount()
+{
+ QFETCH(QStringList, init);
+ QFETCH(int, maxCount);
+ QFETCH(QStringList, expected);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+
+ 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.setMaxCount(maxCount);
+ QCOMPARE(box.maxCount(), maxCount);
+ //QCOMPARE(box.count(), expected.count());
+ for (int i = 0; i < expected.count(); ++i)
+ QCOMPARE(box.text(i), expected.at(i));
+
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), 0);
+ QCOMPARE(spy3.count(), 0);
+ QCOMPARE(spy4.count(), 0);
+
+ //box.setEditable(true);
+ //box.lineEdit()->setText("foo");
+ //QTest::keyPress(box.lineEdit(), Qt::Key_Return);
+ //QVERIFY(box.count() <= maxCount);
+}
+
+// public QPixmap const* pixmap(int index) const
+void tst_Q3ComboBox::pixmap()
+{
+ SubQ3ComboBox box;
+ QCOMPARE(box.pixmap(0), static_cast<const QPixmap*>(0));
+ QPixmap pixmap(1, 1);
+ box.insertItem(pixmap, "foo", 0);
+ QVERIFY(box.pixmap(0) != 0);
+}
+
+void tst_Q3ComboBox::removeItem_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<int>("removeItem");
+ QTest::addColumn<QStringList>("expected");
+ QStringList empty;
+ QTest::newRow("remove-1") << (QStringList(empty) << "x") << 0 << (QStringList(empty));
+ QTest::newRow("remove-2") << (QStringList(empty) << "x" << "y") << 0 << (QStringList(empty) << "y");
+ QTest::newRow("remove-3") << (QStringList(empty) << "x" << "y") << 1 << (QStringList(empty) << "x");
+ QTest::newRow("remove-4") << (QStringList(empty) << "x" << "y" << "z") << 1 << (QStringList(empty) << "x" << "z");
+ QTest::newRow("do-nothing") << (QStringList(empty) << "x" << "y") << -2 << (QStringList(empty) << "x" << "y");
+}
+
+// public void removeItem(int index)
+void tst_Q3ComboBox::removeItem()
+{
+ QFETCH(QStringList, init);
+ QFETCH(int, removeItem);
+ QFETCH(QStringList, expected);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+
+ 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.removeItem(removeItem);
+ QCOMPARE(box.count(), expected.count());
+ for (int i = 0; i < expected.count(); ++i)
+ QCOMPARE(box.text(i), expected.at(i));
+
+ QCOMPARE(spy0.count(), 0);
+ QCOMPARE(spy1.count(), 0);
+ QCOMPARE(spy2.count(), 0);
+ QCOMPARE(spy3.count(), 0);
+ QCOMPARE(spy4.count(), 0);
+}
+
+// public void setValidator(QValidator const* )
+void tst_Q3ComboBox::setValidator()
+{
+ SubQ3ComboBox box;
+ const QValidator *v = new QRegExpValidator(&box);
+ box.setValidator(v);
+ QCOMPARE(box.validator(), static_cast<const QValidator*>(0));
+ box.setEditable(true);
+ box.setValidator(v);
+ QCOMPARE(box.validator(), v);
+}
+
+Q_DECLARE_METATYPE(Qt::Key)
+void tst_Q3ComboBox::keyPressEvent_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<int>("currentItem");
+ QTest::addColumn<Qt::Key>("key");
+ QTest::addColumn<int>("expectedCurrent");
+ QTest::newRow("go-nowhere-1") << (QStringList() << "x") << 0 << Qt::Key_Up << 0;
+ QTest::newRow("go-nowhere-1") << (QStringList() << "x") << 0 << Qt::Key_Down << 0;
+
+ QTest::newRow("move-1") << (QStringList() << "x" << "y") << 1 << Qt::Key_Up << 0;
+ QTest::newRow("move-2") << (QStringList() << "x" << "y") << 0 << Qt::Key_Down << 1;
+ QTest::newRow("move-3") << (QStringList() << "x" << "y") << 1 << Qt::Key_Home << 0;
+ QTest::newRow("move-4") << (QStringList() << "x" << "y") << 0 << Qt::Key_End << 1;
+
+ QTest::newRow("move-let-1") << (QStringList() << "x" << "y") << 0 << Qt::Key_X << 0;
+ QTest::newRow("move-let-2") << (QStringList() << "x" << "y") << 0 << Qt::Key_Y << 1;
+ QTest::newRow("move-let-3") << (QStringList() << "x" << "y") << 1 << Qt::Key_X << 0;
+ QTest::newRow("move-let-4") << (QStringList() << "x" << "y") << 1 << Qt::Key_Y << 1;
+}
+
+// protected void keyPressEvent(QKeyEvent* e)
+void tst_Q3ComboBox::keyPressEvent()
+{
+ QFETCH(QStringList, init);
+ QFETCH(int, currentItem);
+ QFETCH(Qt::Key, key);
+ QFETCH(int, expectedCurrent);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+ box.setCurrentItem(currentItem);
+
+ 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)));
+
+ QTest::keyPress(&box, key);
+ QCOMPARE(box.currentItem(), expectedCurrent);
+
+ // Signal behavior is inconsistent :( so only check that the two signals
+ // match if it ever emits, sometimes it does, sometimes it doesn't.
+ QCOMPARE(spy0.count(), spy1.count());
+
+ int spyCount = (currentItem == expectedCurrent) ? 0 : 1;
+ QCOMPARE(spy2.count(), spyCount);
+ QCOMPARE(spy3.count(), spyCount);
+ QCOMPARE(spy4.count(), 0);
+}
+
+void tst_Q3ComboBox::wheelEvent_data()
+{
+ QTest::addColumn<QStringList>("init");
+ QTest::addColumn<int>("currentItem");
+ QTest::addColumn<int>("delta");
+ QTest::addColumn<int>("expectedCurrent");
+ QTest::newRow("go-nowhere-1") << (QStringList() << "x") << 0 << 10 << 0;
+ QTest::newRow("go-nowhere-1") << (QStringList() << "x") << 0 << -10 << 0;
+
+ QTest::newRow("move-1") << (QStringList() << "x" << "y") << 1 << 10 << 0;
+ QTest::newRow("move-2") << (QStringList() << "x" << "y") << 0 << -10 << 1;
+}
+
+// protected void wheelEvent(QWheelEvent* e)
+void tst_Q3ComboBox::wheelEvent()
+{
+ QFETCH(QStringList, init);
+ QFETCH(int, currentItem);
+ QFETCH(int, delta);
+ QFETCH(int, expectedCurrent);
+
+ SubQ3ComboBox box;
+ box.insertStringList(init);
+ box.setCurrentItem(currentItem);
+
+ 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)));
+
+ QWheelEvent event(QPoint(0,0), delta, Qt::LeftButton, Qt::NoModifier);
+ box.call_wheelEvent(&event);
+ QCOMPARE(box.currentItem(), expectedCurrent);
+
+ int spyCount = (currentItem == expectedCurrent) ? 0 : 1;
+ QCOMPARE(spy0.count(), spyCount);
+ QCOMPARE(spy1.count(), spyCount);
+ QCOMPARE(spy2.count(), spyCount);
+ QCOMPARE(spy3.count(), spyCount);
+ QCOMPARE(spy4.count(), 0);
+}
+
+void tst_Q3ComboBox::task231724_clear()
+{
+ Q3ComboBox box;
+
+ for ( int i = 0; i <50; i++ ) {
+ box.insertItem(QString( "value %1" ).arg( i ));
+ }
+
+ box.show();
+ QTest::qWait(20);
+ QTest::mouseClick (&box, Qt::LeftButton);
+ QTest::qWait(500);
+ Q3ListBox *popup = box.findChild<Q3ListBox *>("in-combo");
+ QVERIFY(popup);
+ QVERIFY(popup->isVisible());
+ QVERIFY(!popup->testAttribute(Qt::WA_OutsideWSRange));
+ QTest::qWait(20);
+
+ box.clear();
+ for ( int i = 0; i <50; i++ ) {
+ box.insertItem(QString( "value %1" ).arg( i ));
+ }
+
+ QTest::qWait(20);
+ QTest::mouseClick (&box, Qt::LeftButton);
+ QTest::qWait(500);
+
+ popup = box.findChild<Q3ListBox *>("in-combo");
+ QVERIFY(popup);
+ QVERIFY(popup->isVisible());
+ QVERIFY(!popup->testAttribute(Qt::WA_OutsideWSRange));
+
+}
+
+QTEST_MAIN(tst_Q3ComboBox)
+#include "tst_q3combobox.moc"
+