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

**

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

#include <limits.h>

#include <float.h>

#include <qspinbox.h>

#include <qlocale.h>

#include <qlayout.h>

#include <qlineedit.h>

#include <qdebug.h>

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

//TESTED_CLASS=

//TESTED_FILES=gui/widgets/qspinbox.h gui/widgets/qspinbox.cpp gui/widgets/qabstractspinbox.cpp gui/widgets/qabstractspinbox_p.h gui/widgets/qabstractspinbox.h

class DoubleSpinBox : public QDoubleSpinBox

{

    Q_OBJECT

public:

    DoubleSpinBox(QWidget *parent = 0)

        : QDoubleSpinBox(parent)

    { /*connect(this, SIGNAL(valueChanged(double)), this, SLOT(foo(double)));*/ }

    QString textFromValue(double v) const

    {

        return QDoubleSpinBox::textFromValue(v);

    }

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

    {

        return QDoubleSpinBox::validate(text, pos);

    }

    double valueFromText(const QString &text) const

    {

        return QDoubleSpinBox::valueFromText(text);

    }

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

public slots:

    void foo(double vla)

    {

        qDebug() << vla;

    }

};

class tst_QDoubleSpinBox : public QObject

{

    Q_OBJECT

public:

    tst_QDoubleSpinBox();

    virtual ~tst_QDoubleSpinBox();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

private slots:

    void germanTest();

    void task54433();

    void setValue_data();

    void setValue();

    void setPrefixSuffix_data();

    void setPrefixSuffix();

    void setTracking_data();

    void setTracking();

    void setWrapping_data();

    void setWrapping();

    void setSpecialValueText_data();

    void setSpecialValueText();

    void setSingleStep_data();

    void setSingleStep();

    void setMinMax_data();

    void setMinMax();

    void setDecimals_data();

    void setDecimals();

    void doubleDot();

    void undoRedo();

    void valueFromTextAndValidate_data();

    void valueFromTextAndValidate();

    void setReadOnly();

    void editingFinished();

    void removeAll();

    void task199226_stateAfterEnter();

    void task224497_fltMax();

    void task221221();

    void task255471_decimalsValidation();

    void taskQTBUG_5008_textFromValueAndValidate();

    void taskQTBUG_6670_selectAllWithPrefix();

    void taskQTBUG_6496_fiddlingWithPrecision();

public slots:

    void valueChangedHelper(const QString &);

    void valueChangedHelper(double);

private:

    QStringList actualTexts;

    QList<double> actualValues;

    QWidget *testFocusWidget;

};

typedef QList<double> DoubleList;

Q_DECLARE_METATYPE(DoubleList)

tst_QDoubleSpinBox::tst_QDoubleSpinBox()

{

}

tst_QDoubleSpinBox::~tst_QDoubleSpinBox()

{

}

void tst_QDoubleSpinBox::initTestCase()

{

    testFocusWidget = new QWidget(0);

    testFocusWidget->resize(200, 100);

    testFocusWidget->show();

}

void tst_QDoubleSpinBox::cleanupTestCase()

{

    delete testFocusWidget;

    testFocusWidget = 0;

}

void tst_QDoubleSpinBox::init()

{

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

}

void tst_QDoubleSpinBox::setValue_data()

{

    QTest::addColumn<double>("val");

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

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

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

    QTest::newRow("data3") << -DBL_MAX;

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

}

void tst_QDoubleSpinBox::setValue()

{

    QFETCH(double, val);

    QDoubleSpinBox spin(0);

    spin.setRange(-DBL_MAX, DBL_MAX);

    spin.setValue(val);

    QCOMPARE(spin.value(), val);

}

void tst_QDoubleSpinBox::setPrefixSuffix_data()

{

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

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

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

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

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

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

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

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

    QTest::newRow("data1") << QString() << "cm" << 10.5 << 2 << "10.50cm" << "10.50" << false;

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

    QTest::newRow("data3") << "length: " << "cm" << 10.5 << 3 << "length: 10.500cm" << "10.500" << false;

    QTest::newRow("data4") << QString() << QString() << 10.5 << 1 << "10.5" << "10.5" << true;

    QTest::newRow("data5") << QString() << "cm" << 10.5 << 2 << "10.50cm" << "10.50" << true;

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

    QTest::newRow("data7") << "length: " << "cm" << 10.5 << 3 << "length: 10.500cm" << "10.500" << true;

}

void tst_QDoubleSpinBox::setPrefixSuffix()

{

    QFETCH(QString, prefix);

    QFETCH(QString, suffix);

    QFETCH(double, value);

    QFETCH(int, decimals);

    QFETCH(QString, expectedText);

    QFETCH(QString, expectedCleanText);

    QFETCH(bool, show);

    QDoubleSpinBox spin(0);

    spin.setDecimals(decimals);

    spin.setPrefix(prefix);

    spin.setSuffix(suffix);

    spin.setValue(value);

    if (show)

        spin.show();

    QCOMPARE(spin.text(), expectedText);

    QCOMPARE(spin.cleanText(), expectedCleanText);

}

void tst_QDoubleSpinBox::valueChangedHelper(const QString &text)

{

    actualTexts << text;

}

void tst_QDoubleSpinBox::valueChangedHelper(double value)

{

    actualValues << value;

}

void tst_QDoubleSpinBox::setTracking_data()

{

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

    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(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick('7');

    keys.addKeyClick('.');

    keys.addKeyClick('9');

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick('2');

    keys.addKeyClick(Qt::Key_Enter);

    keys.addKeyClick(Qt::Key_Enter);

    keys.addKeyClick(Qt::Key_Enter);

    texts1 << "7" << "7.9" << "7." << "7.2" << "7.200" << "7.200" << "7.200";

    texts2 << "7.200";

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

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

}

void tst_QDoubleSpinBox::setTracking()

{

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

    actualTexts.clear();

    QFETCH(int, decimals);

    QFETCH(QTestEventList, keys);

    QFETCH(QStringList, texts);

    QFETCH(bool, tracking);

    QDoubleSpinBox spin(0);

    spin.setKeyboardTracking(tracking);

    spin.setDecimals(decimals);

    spin.show();

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

    keys.simulate(&spin);

    QCOMPARE(actualTexts, texts);

}

void tst_QDoubleSpinBox::setWrapping_data()

{

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

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

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

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

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

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

    QTestEventList keys;

    DoubleList values;

    keys.addKeyClick(Qt::Key_Up);

    values << 10;

    keys.addKeyClick(Qt::Key_Up);

    QTest::newRow("data0") << false << 0.0 << 10.0 << 9.0 << 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.0 << 10.0 << 9.0 << keys << values;

    keys.clear();

    values.clear();

#ifdef Q_WS_MAC

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

#else

    keys.addKeyClick(Qt::Key_End);

#endif

    keys.addKeyClick(Qt::Key_Backspace);

    keys.addKeyClick('1');

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_PageDown);

    values << 9.01 << 8.01 << 7.01 << 0.0;

    QTest::newRow("data2") << false << 0.0 << 10.0 << 9.0 << keys << values;

    keys.clear();

    values.clear();

#ifdef Q_WS_MAC

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

#else

    keys.addKeyClick(Qt::Key_Home);

#endif

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick(Qt::Key_Delete);

    keys.addKeyClick('1');

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Down);

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

    QTest::newRow("data3") << true << 0.0 << 10.0 << 9.0 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_PageDown);

    keys.addKeyClick(Qt::Key_Down);

    values << 0;

    QTest::newRow("data4") << false << 0.0 << 10.0 << 6.0 << keys << values;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_PageDown);

    keys.addKeyClick(Qt::Key_Down);

    values << 0 << 10;

    QTest::newRow("data5") << true << 0.0 << 10.0 << 6.0 << 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.0 << 10.0 << 6.0 << keys << values;

}

void tst_QDoubleSpinBox::setWrapping()

{

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

    QFETCH(bool, wrapping);

    QFETCH(double, minimum);

    QFETCH(double, maximum);

    QFETCH(double, startValue);

    QFETCH(QTestEventList, keys);

    QFETCH(DoubleList, expected);

    QDoubleSpinBox spin(0);

    spin.setMinimum(minimum);

    spin.setMaximum(maximum);

    spin.setValue(startValue);

    spin.setWrapping(wrapping);

    spin.show();

    actualValues.clear();

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

    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_QDoubleSpinBox::setSpecialValueText_data()

{

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

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

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

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

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

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

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

    QTest::newRow("data0") << QString() << 0.0 << 10.0 << 1.0 << 4 << "1.0000" << false;

    QTest::newRow("data1") << QString() << 0.0 << 10.0 << 1.0 << 4 << "1.0000" << true;

    QTest::newRow("data2") << "foo" << 0.0 << 10.0 << 0.0 << 2 << "foo" << false;

    QTest::newRow("data3") << "foo" << 0.0 << 10.0 << 0.0 << 2 << "foo" << true;

}

void tst_QDoubleSpinBox::setSpecialValueText()

{

    QFETCH(QString, specialValueText);

    QFETCH(double, minimum);

    QFETCH(double, maximum);

    QFETCH(double, value);

    QFETCH(int, decimals);

    QFETCH(QString, expected);

    QFETCH(bool, show);

    QDoubleSpinBox spin(0);

    spin.setSpecialValueText(specialValueText);

    spin.setMinimum(minimum);

    spin.setMaximum(maximum);

    spin.setValue(value);

    spin.setDecimals(decimals);

    if (show)

        spin.show();

    QCOMPARE(spin.text(), expected);

}

void tst_QDoubleSpinBox::setSingleStep_data()

{

    QTest::addColumn<double>("singleStep");

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

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

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

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

    QTestEventList keys;

    DoubleList values;

    keys.addKeyClick(Qt::Key_Up);

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Up);

    values << 11 << 10 << 11;

    QTest::newRow("data0") << 1.0 << 10.0 << keys << values << false;

    QTest::newRow("data1") << 1.0 << 10.0 << keys << values << true;

    keys.clear();

    values.clear();

    keys.addKeyClick(Qt::Key_Up);

    keys.addKeyClick(Qt::Key_Down);

    keys.addKeyClick(Qt::Key_Up);

    values << 12.5 << 10.0 << 12.5;

    QTest::newRow("data2") << 2.5 << 10.0 << keys << values << false;

    QTest::newRow("data3") << 2.5 << 10.0 << keys << values << true;

}

void tst_QDoubleSpinBox::setSingleStep()

{

    QFETCH(double, singleStep);

    QFETCH(double, startValue);

    QFETCH(QTestEventList, keys);

    QFETCH(DoubleList, expected);

    QFETCH(bool, show);

    QDoubleSpinBox spin(0);

    actualValues.clear();

    spin.setSingleStep(singleStep);

    spin.setValue(startValue);

    if (show)

        spin.show();

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

    QCOMPARE(actualValues.size(), 0);

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

    }

}