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

**

** Copyright (C) 2010 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 <qdebug.h>

#include <qapplication.h>

#include <limits.h>

#ifdef Q_WS_X11

#include <unistd.h>

#endif

#include <qspinbox.h>

#include <qlocale.h>

#include <qlineedit.h>

#include <qlayout.h>

#include <QSpinBox>

#include <QWidget>

#include <QString>

#include <QValidator>

#include <QLineEdit>

#include <QObject>

#include <QStringList>

#include <QList>

#include <QLocale>

#include <QDoubleSpinBox>

#include <QVBoxLayout>

#include <QKeySequence>

#include <QStackedWidget>

#include <QDebug>

#include "../../shared/util.h"

//TESTED_CLASS=

//TESTED_FILES=

class SpinBox : public QSpinBox

{

public:

    SpinBox(QWidget *parent = 0)

        : QSpinBox(parent)

    {}

    QString textFromValue(int v) const

    {

        return QSpinBox::textFromValue(v);

    }

    QValidator::State validate(QString &text, int &pos) const

    {

        return QSpinBox::validate(text, pos);

    }

    int valueFromText(const QString &text) const

    {

        return QSpinBox::valueFromText(text);

    }

    QLineEdit *lineEdit() const { return QSpinBox::lineEdit(); }

};

class tst_QSpinBox : public QObject

{

    Q_OBJECT

public:

    tst_QSpinBox();

    virtual ~tst_QSpinBox();

public slots:

    void initTestCase();

    void init();

    void cleanupTestCase();

private slots:

    void getSetCheck();

    void setValue_data();

    void setValue();

    void setPrefixSuffix_data();

    void setPrefixSuffix();

    void setReadOnly();

    void setTracking_data();

    void setTracking();

    void locale_data();

    void locale();

    void setWrapping_data();

    void setWrapping();

    void setSpecialValueText_data();

    void setSpecialValueText();

    void setSingleStep_data();

    void setSingleStep();

    void setMinMax_data();

    void setMinMax();

    void editingFinished();

    void valueFromTextAndValidate_data();

    void valueFromTextAndValidate();

    void removeAll();

    void startWithDash();

    void undoRedo();

    void specialValue();

    void textFromValue();

    void sizeHint();

    void taskQTBUG_5008_textFromValueAndValidate();

public slots:

    void valueChangedHelper(const QString &);

    void valueChangedHelper(int);

private:

    QStringList actualTexts;

    QList<int> actualValues;

    QWidget *testFocusWidget;

};

typedef QList<int> IntList;

Q_DECLARE_METATYPE(IntList)

Q_DECLARE_METATYPE(QLocale)

// Testing get/set functions

void tst_QSpinBox::getSetCheck()

{

    QSpinBox obj1;

    // int QSpinBox::singleStep()

    // void QSpinBox::setSingleStep(int)

    obj1.setSingleStep(0);

    QCOMPARE(0, obj1.singleStep());

    obj1.setSingleStep(INT_MIN);

    QCOMPARE(0, obj1.singleStep()); // Can't have negative steps => keep old value

    obj1.setSingleStep(INT_MAX);

    QCOMPARE(INT_MAX, obj1.singleStep());

    // int QSpinBox::minimum()

    // void QSpinBox::setMinimum(int)

    obj1.setMinimum(0);

    QCOMPARE(0, obj1.minimum());

    obj1.setMinimum(INT_MIN);

    QCOMPARE(INT_MIN, obj1.minimum());

    obj1.setMinimum(INT_MAX);

    QCOMPARE(INT_MAX, obj1.minimum());

    // int QSpinBox::maximum()

    // void QSpinBox::setMaximum(int)

    obj1.setMaximum(0);

    QCOMPARE(0, obj1.maximum());

    obj1.setMaximum(INT_MIN);

    QCOMPARE(INT_MIN, obj1.maximum());

    obj1.setMaximum(INT_MAX);

    QCOMPARE(INT_MAX, obj1.maximum());

    // int QSpinBox::value()

    // void QSpinBox::setValue(int)

    obj1.setValue(0);

    QCOMPARE(0, obj1.value());

    obj1.setValue(INT_MIN);

    QCOMPARE(INT_MIN, obj1.value());

    obj1.setValue(INT_MAX);

    QCOMPARE(INT_MAX, obj1.value());

    QDoubleSpinBox obj2;

    // double QDoubleSpinBox::singleStep()

    // void QDoubleSpinBox::setSingleStep(double)

    obj2.setSingleStep(0.0);

    QCOMPARE(0.0, obj2.singleStep());

    obj2.setSingleStep(1.0);

    QCOMPARE(1.0, obj2.singleStep());

    // double QDoubleSpinBox::minimum()

    // void QDoubleSpinBox::setMinimum(double)

    obj2.setMinimum(1.0);

    QCOMPARE(1.0, obj2.minimum());

    obj2.setMinimum(0.0);

    QCOMPARE(0.0, obj2.minimum());

    obj2.setMinimum(-1.0);

    QCOMPARE(-1.0, obj2.minimum());

    // double QDoubleSpinBox::maximum()

    // void QDoubleSpinBox::setMaximum(double)

    obj2.setMaximum(-1.0);

    QCOMPARE(-1.0, obj2.maximum());

    obj2.setMaximum(0.0);

    QCOMPARE(0.0, obj2.maximum());

    obj2.setMaximum(1.0);

    QCOMPARE(1.0, obj2.maximum());

    // int QDoubleSpinBox::decimals()

    // void QDoubleSpinBox::setDecimals(int)

    obj2.setDecimals(0);

    QCOMPARE(0, obj2.decimals());

    obj2.setDecimals(INT_MIN);

    QCOMPARE(0, obj2.decimals()); // Range<0, 13>

    //obj2.setDecimals(INT_MAX);

    //QCOMPARE(13, obj2.decimals()); // Range<0, 13>

    obj2.setDecimals(128);

    QCOMPARE(obj2.decimals(), 128); // Range<0, 128>

    // double QDoubleSpinBox::value()

    // void QDoubleSpinBox::setValue(double)

    obj2.setValue(-1.0);

    QCOMPARE(-1.0, obj2.value());

    obj2.setValue(0.0);

    QCOMPARE(0.0, obj2.value());

    obj2.setValue(1.0);

    QCOMPARE(1.0, obj2.value());

    // Make sure we update line edit geometry when updating

    // buttons - see task 235747

    QRect oldEditGeometry = obj1.childrenRect();

    obj1.setButtonSymbols(QAbstractSpinBox::NoButtons);

    QVERIFY(obj1.childrenRect() != oldEditGeometry);

}

tst_QSpinBox::tst_QSpinBox()

{

}

tst_QSpinBox::~tst_QSpinBox()

{

}

void tst_QSpinBox::initTestCase()

{

    testFocusWidget = new QWidget(0);

    testFocusWidget->resize(200, 100);

    testFocusWidget->show();

}

void tst_QSpinBox::init()

{

    QLocale::setDefault(QLocale(QLocale::C));

}

void tst_QSpinBox::cleanupTestCase()

{

    delete testFocusWidget;

    testFocusWidget = 0;

}

void tst_QSpinBox::setValue_data()

{

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

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

    QTest::newRow("data0") << 0 << 0;

    QTest::newRow("data1") << 100 << 100;

    QTest::newRow("data2") << -100 << -100;

    QTest::newRow("data3") << INT_MIN << INT_MIN;

    QTest::newRow("data4") << INT_MAX << INT_MAX;

}

void tst_QSpinBox::setValue()

{

    QFETCH(int, set);

    QFETCH(int, expected);

    QSpinBox spin(0);

    spin.setRange(INT_MIN, INT_MAX);

    spin.setValue(set);

    QCOMPARE(spin.value(), expected);

}

void tst_QSpinBox::setPrefixSuffix_data()

{

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

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

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

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

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

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

    QTest::newRow("data0") << QString() << QString() << 10 << "10" << "10" << false;

    QTest::newRow("data1") << QString() << "cm" << 10 << "10cm" << "10" << false;

    QTest::newRow("data2") << "cm: " << QString() << 10 << "cm: 10" << "10" << false;

    QTest::newRow("data3") << "length: " << "cm" << 10 << "length: 10cm" << "10" << false;

    QTest::newRow("data4") << QString() << QString() << 10 << "10" << "10" << true;

    QTest::newRow("data5") << QString() << "cm" << 10 << "10cm" << "10" << true;

    QTest::newRow("data6") << "cm: " << QString() << 10 << "cm: 10" << "10" << true;

    QTest::newRow("data7") << "length: " << "cm" << 10 << "length: 10cm" << "10" << true;

}

void tst_QSpinBox::setPrefixSuffix()

{

    QFETCH(QString, prefix);

    QFETCH(QString, suffix);

    QFETCH(int, value);

    QFETCH(QString, expectedText);

    QFETCH(QString, expectedCleanText);

    QFETCH(bool, show);

    QSpinBox spin(0);

    spin.setPrefix(prefix);

    spin.setSuffix(suffix);

    spin.setValue(value);

    if (show)

        spin.show();

    QCOMPARE(spin.prefix(), prefix);

    QCOMPARE(spin.suffix(), suffix);

    QCOMPARE(spin.text(), expectedText);

    QCOMPARE(spin.cleanText(), expectedCleanText);

}

void tst_QSpinBox::valueChangedHelper(const QString &text)

{

    actualTexts << text;

}

void tst_QSpinBox::valueChangedHelper(int value)

{

    actualValues << value;

}

void tst_QSpinBox::setReadOnly()

{

    QSpinBox spin(0);

    spin.show();

    QTest::keyClick(&spin, Qt::Key_Up);

    QCOMPARE(spin.value(), 1);

    spin.setReadOnly(true);

    QTest::keyClick(&spin, Qt::Key_Up);

    QCOMPARE(spin.value(), 1);

    spin.stepBy(1);

    QCOMPARE(spin.value(), 2);

    spin.setReadOnly(false);

    QTest::keyClick(&spin, Qt::Key_Up);

    QCOMPARE(spin.value(), 3);

}

void tst_QSpinBox::setTracking_data()

{

    QTest::addColumn<QTestEventList>("keys");

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

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

    QTestEventList keys;

    QStringList texts1;

    QStringList texts2;

#ifdef Q_WS_MAC

    keys.addKeyClick(Qt::Key_Right, Qt::ControlModifier);

#else

    keys.addKeyClick(Qt::Key_End);

#endif

    keys.addKeyClick('7');

    keys.addKeyClick('9');

    keys.addKeyClick(Qt::Key_Enter);

    keys.addKeyClick(Qt::Key_Enter);

    keys.addKeyClick(Qt::Key_Enter);

    texts1 << "07" << "079" << "79" << "79" << "79";

    texts2 << "79";

    QTest::newRow("data1") << keys << texts1 << true;

    QTest::newRow("data2") << keys << texts2 << false;

}

void tst_QSpinBox::setTracking()

{

    actualTexts.clear();

    QFETCH(QTestEventList, keys);

    QFETCH(QStringList, texts);

    QFETCH(bool, tracking);

    QSpinBox spin(0);

    spin.setKeyboardTracking(tracking);

    spin.show();

    connect(&spin, SIGNAL(valueChanged(QString)), this, SLOT(valueChangedHelper(const QString &)));

    keys.simulate(&spin);

    QCOMPARE(actualTexts, texts);

}

void tst_QSpinBox::setWrapping_data()

{

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

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

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

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

    QTest::addColumn<QTestEventList>("keys");

    QTest::addColumn<IntList>("expected");

    QTestEventList keys;

    IntList values;

    keys.addKeyClick(Qt::Key_Up);

    values << 10;

    keys.addKeyClick(Qt::Key_Up);

    QTest::newRow("data0") << false << 0 << 10 << 9 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_Up);

    values << 10;

    keys.addKeyClick(Qt::Key_Up);

    values << 0;

    QTest::newRow("data1") << true << 0 << 10 << 9 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_Delete); // doesn't emit because lineedit is empty so intermediate

    keys.addKeyClick('1');

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Down);

    values << 1 << 0;

    QTest::newRow("data2") << false << 0 << 10 << 9 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick('1');

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Down);

    values << 1 << 0 << 10;

    QTest::newRow("data3") << true << 0 << 10 << 9 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_PageDown);

    keys.addKeyClick(Qt::Key_Down);

    values << 0;

    QTest::newRow("data4") << false << 0 << 10 << 6 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_PageDown);

    keys.addKeyClick(Qt::Key_Down);

    values << 0 << 10;

    QTest::newRow("data5") << true << 0 << 10 << 6 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_PageUp);

    keys.addKeyClick(Qt::Key_PageDown);

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Up);

    keys.addKeyClick(Qt::Key_PageDown);

    keys.addKeyClick(Qt::Key_PageDown);

    values << 10 << 0 << 10 << 0 << 10 << 0;

    QTest::newRow("data6") << true << 0 << 10 << 6 << keys << values;

}

void tst_QSpinBox::setWrapping()

{

    QFETCH(bool, wrapping);

    QFETCH(int, minimum);

    QFETCH(int, maximum);

    QFETCH(int, startValue);

    QFETCH(QTestEventList, keys);

    QFETCH(IntList, expected);

    QSpinBox spin(0);

    QVERIFY(!spin.wrapping());

    spin.setMinimum(minimum);

    spin.setMaximum(maximum);

    spin.setValue(startValue);

    spin.setWrapping(wrapping);

    spin.show();

    actualValues.clear();

    connect(&spin, SIGNAL(valueChanged(int)), this, SLOT(valueChangedHelper(int)));

    keys.simulate(&spin);

    QCOMPARE(actualValues.size(), expected.size());

    for (int i=0; i<qMin(actualValues.size(), expected.size()); ++i) {

        QCOMPARE(actualValues.at(i), expected.at(i));

    }

}

void tst_QSpinBox::setSpecialValueText_data()

{

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

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

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

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

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

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

    QTest::newRow("data0") << QString() << 0 << 10 << 1 << "1" << false;

    QTest::newRow("data1") << QString() << 0 << 10 << 1 << "1" << true;

    QTest::newRow("data2") << "foo" << 0 << 10 << 0 << "foo" << false;

    QTest::newRow("data3") << "foo" << 0 << 10 << 0 << "foo" << true;

}