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

**

** 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 <QAbstractSlider>

#include <QScrollBar>

#include <QSlider>

#include <QStyle>

#include <QStyleOption>

#include <QTime>

#include <QDebug>

// defined to be 120 by the wheel mouse vendors according to the docs

#define WHEEL_DELTA 120

class Slider : public QAbstractSlider

{

    public:

        using QAbstractSlider::setRepeatAction;

        using QAbstractSlider::repeatAction;

};

class tst_QAbstractSlider: public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

    void actionTriggered(int action);

    void rangeChanged(int min, int max);

    void valueChanged(int value);

    void sliderMoved(int value);

private slots:

    void triggerAction_data();

    void triggerAction();

    void minimum_maximum_data();

    void minimum_maximum();

    void keyPressed_data();

    void keyPressed();

    void wheelEvent_data();

    void wheelEvent();

    void sliderPressedReleased_data();

    void sliderPressedReleased();

    void setOrientation();

    void sliderMoved_data();

    void sliderMoved();

    void rangeChanged_data();

    void rangeChanged();

    void setSliderPosition_data();

    void setSliderPosition();

    void setValue_data();

    void setValue();

    void setRepeatAction();

private:

    void waitUntilTimeElapsed(const QTime& t, int ms);

    Slider *slider;

    int previousAction;

    int reportedMinimum;

    int reportedMaximum;

    int reportedValue;

    int reportedSliderPosition;

    qint64 timeStamp;

    qint64 actionTriggeredTimeStamp;

    qint64 valueChangedTimeStamp;

    qint64 rangeChangedTimeStamp;

    qint64 sliderMovedTimeStamp;

};

Q_DECLARE_METATYPE(QList<Qt::Key>)

Q_DECLARE_METATYPE(QPoint)

void tst_QAbstractSlider::initTestCase()

{

    slider = new Slider;

    slider->setObjectName("testWidget");

    slider->resize(100,100);

    slider->show();

    previousAction = QAbstractSlider::SliderNoAction;

    timeStamp = 0;

    connect(slider,SIGNAL(actionTriggered(int)),this,SLOT(actionTriggered(int)));

    connect(slider,SIGNAL(rangeChanged(int,int)),this,SLOT(rangeChanged(int,int)));

    connect(slider,SIGNAL(valueChanged(int)),this,SLOT(valueChanged(int)));

    connect(slider,SIGNAL(sliderMoved(int)),this,SLOT(sliderMoved(int)));

}

void tst_QAbstractSlider::cleanupTestCase()

{

    delete slider;

}

void tst_QAbstractSlider::actionTriggered(int action)

{

    previousAction = action;

    actionTriggeredTimeStamp = timeStamp++;

}

void tst_QAbstractSlider::rangeChanged(int min,int max)

{

    reportedMinimum = min;

    reportedMaximum = max;

    rangeChangedTimeStamp = timeStamp++;

}

void tst_QAbstractSlider::valueChanged(int value)

{

    reportedValue = value;

    valueChangedTimeStamp = timeStamp++;

}

void tst_QAbstractSlider::sliderMoved(int value)

{

    reportedSliderPosition = value;

    sliderMovedTimeStamp = timeStamp++;

}

void tst_QAbstractSlider::triggerAction_data()

{

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

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

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

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

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

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

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

    QTest::newRow("No action") << int(QAbstractSlider::SliderNoAction) // sliderAction

                            << 1000                                 // max

                            << 900                                  // min

                            << 987                                  // initial position

                            << 237                                  // single step size

                            << 234                                  // page step size

                            << 987;                                 // expected position after

    QTest::newRow("Move action") << int(QAbstractSlider::SliderMove) // sliderAction

                              << 1000                                 // max

                              << 900                                  // min

                              << 988                                  // initial position

                              << 237                                  // single step size

                              << 234                                  // page step size

                              << 988;                                 // expected position after

    QTest::newRow("Empty step add") << int(QAbstractSlider::SliderSingleStepAdd) // sliderAction

                                 << 1000                                      // max

                                 << 900                                       // min

                                 << 988                                       // initial position

                                 << 0                                         // single step size

                                 << 234                                       // page step size

                                 << 988;                                      // expected position after

     QTest::newRow("Empty step sub") << int(QAbstractSlider::SliderSingleStepSub) // sliderAction

                                 << 1000                                       // max

                                 << 900                                        // min

                                 << 987                                        // initial position

                                 << 0                                          // single step size

                                 << 234                                        // page step size

                                 << 987;                                       // expected position after

    QTest::newRow("Empty page add") << int(QAbstractSlider::SliderPageStepAdd) // sliderAction

                                 << 1000                                    // max

                                 << 900                                     // min

                                 << 988                                     // initial position

                                 << 234                                     // single step size

                                 << 0                                       // page step size

                                 << 988;                                    // expected position after

     QTest::newRow("Empty page sub") << int(QAbstractSlider::SliderPageStepSub) // sliderAction

                                 << 1000                                     // max

                                 << 900                                      // min

                                 << 987                                      // initial position

                                 << 234                                      // single step size

                                 << 0                                        // page step size

                                 << 987;                                     // expected position after

    QTest::newRow("Legal step add") << int(QAbstractSlider::SliderSingleStepAdd) // sliderAction

                                 << 1000                                      // max

                                 << 900                                       // min

                                 << 988                                       // initial position

                                 << 5                                         // single step size

                                 << 234                                       // page step size

                                 << 993;                                      // expected position after

     QTest::newRow("Legal step sub") << int(QAbstractSlider::SliderSingleStepSub) // sliderAction

                                 << 1000                                       // max

                                 << 900                                        // min

                                 << 987                                        // initial position

                                 << 5                                          // single step size

                                 << 234                                        // page step size

                                 << 982;                                       // expected position after

    QTest::newRow("Legal page add") << int(QAbstractSlider::SliderPageStepAdd) // sliderAction

                                 << 1000                                    // max

                                 << 900                                     // min

                                 << 988                                     // initial position

                                 << 234                                     // single step size

                                 << 5                                       // page step size

                                 << 993;                                    // expected position after

     QTest::newRow("Legal page sub") << int(QAbstractSlider::SliderPageStepSub) // sliderAction

                                 << 1000                                     // max

                                 << 900                                      // min

                                 << 987                                      // initial position

                                 << 234                                      // single step size

                                 << 5                                        // page step size

                                 << 982;                                     // expected position after

    QTest::newRow("Illegal step add") << int(QAbstractSlider::SliderSingleStepAdd) // sliderAction

                                   << 1000                                      // max

                                   << 900                                       // min

                                   << 988                                       // initial position

                                   << 500                                       // single step size

                                   << 234                                       // page step size

                                   << 1000;                                     // expected position after

     QTest::newRow("Illegal step sub") << int(QAbstractSlider::SliderSingleStepSub) // sliderAction

                                    << 1000                                      // max

                                    << 900                                       // min

                                    << 987                                       // initial position

                                    << 500                                       // single step size

                                    << 234                                       // page step size

                                    << 900;                                      // expected position after

    QTest::newRow("Illegal page add") << int(QAbstractSlider::SliderPageStepAdd) // sliderAction

                                   << 1000                                    // max

                                   << 900                                     // min

                                   << 988                                     // initial position

                                   << 234                                     // single step size

                                   << 500                                     // page step size

                                   << 1000;                                   // expected position after

     QTest::newRow("Illegal page sub") << int(QAbstractSlider::SliderPageStepSub) // sliderAction

                                    << 1000                                    // max

                                    << 900                                     // min

                                    << 987                                     // initial position

                                    << 234                                     // single step size

                                    << 500                                     // page step size

                                    << 900;                                    // expected position after

    // Negative steps will also be abs()'d so, check that case.

    QTest::newRow("Negative step add") << int(QAbstractSlider::SliderSingleStepAdd) // sliderAction

                                    << 1000                                      // max

                                    << 900                                       // min

                                    << 988                                       // initial position

                                    << -1                                        // single step size

                                    << 234                                       // page step size

                                    << 989;                                      // expected position after

     QTest::newRow("Negative step sub") << int(QAbstractSlider::SliderSingleStepSub) // sliderAction

                                     << 1000                                      // max

                                     << 900                                       // min

                                     << 987                                       // initial position

                                     << -1                                        // single step size

                                     << 234                                       // page step size

                                     << 986;                                      // expected position after

    QTest::newRow("Negative page add") << int(QAbstractSlider::SliderPageStepAdd) // sliderAction

                                    << 1000                                    // max

                                    << 900                                     // min

                                    << 988                                     // initial position

                                    << 234                                     // single step size

                                    << -1                                      // page step size

                                    << 989;                                    // expected position after

     QTest::newRow("Negative page sub") << int(QAbstractSlider::SliderPageStepSub) // sliderAction

                                     << 1000                                    // max

                                     << 900                                     // min

                                     << 987                                     // initial position

                                     << 234                                     // single step size

                                     << -1                                      // page step size

                                     << 986;                                    // expected position after

    QTest::newRow("Illegal negative step add") << int(QAbstractSlider::SliderSingleStepAdd) // sliderAction

                                            << 1000                                      // max

                                            << 900                                       // min

                                            << 988                                       // initial position

                                            << -500                                      // single step size

                                            << 234                                       // page step size

                                            << 1000;                                      // expected position after

    QTest::newRow("Illegal negative step sub") << int(QAbstractSlider::SliderSingleStepSub) // sliderAction

                                            << 1000                                      // max

                                            << 900                                       // min

                                            << 988                                       // initial position

                                            << -500                                      // single step size

                                            << 234                                       // page step size

                                            << 900;                                     // expected position after

    QTest::newRow("Illegal negative page add") << int(QAbstractSlider::SliderPageStepAdd) // sliderAction

                                            << 1000                                    // max

                                            << 900                                     // min

                                            << 988                                     // initial position

                                            << 234                                     // single step size

                                            << -500                                    // page step size

                                            << 1000;                                    // expected position after

    QTest::newRow("Illegal negative page sub") << int(QAbstractSlider::SliderPageStepSub) // sliderAction

                                            << 1000                                    // max

                                            << 900                                     // min

                                            << 988                                     // initial position

                                            << 245                                     // single step size

                                            << -500                                    // page step size

                                            << 900;                                   // expected position after

    QTest::newRow("Slider to minimum") << int(QAbstractSlider::SliderToMinimum)   // sliderAction

                                    << 1000                                    // max

                                    << 900                                     // min

                                    << 988                                     // initial position

                                    << 245                                     // single step size

                                    << 1                                       // page step size

                                    << 900;                                    // expected position after

    QTest::newRow("Slider to maximum") << int(QAbstractSlider::SliderToMaximum)   // sliderAction

                                    << 1000                                    // max

                                    << 900                                     // min

                                    << 988                                     // initial position

                                    << 245                                     // single step size

                                    << 1                                       // page step size

                                    << 1000;                                   // expected position after

}

void tst_QAbstractSlider::triggerAction()

{

    QFETCH(int,sliderAction);

    QFETCH(int,maximum);

    QFETCH(int,minimum);

    QFETCH(int,initialSliderPosition);

    QFETCH(int,singleStep);

    QFETCH(int,pageStep);

    QFETCH(int,expectedSliderPosition);

    slider->setTracking(true);

    slider->setRange(minimum,maximum);

    slider->setSingleStep(singleStep);

    slider->setPageStep(pageStep);

    QCOMPARE(slider->singleStep(), qAbs(singleStep));

    QCOMPARE(slider->pageStep(), qAbs(pageStep));

    int oldPosition = slider->sliderPosition();

    slider->setSliderPosition(initialSliderPosition);

    QVERIFY( (oldPosition == initialSliderPosition && previousAction == int(QAbstractSlider::SliderNoAction)) ||

            (oldPosition != initialSliderPosition && previousAction == int(QAbstractSlider::SliderMove)));

    previousAction = int(QAbstractSlider::SliderNoAction);

    QAbstractSlider::SliderAction *action = reinterpret_cast<QAbstractSlider::SliderAction*>(&sliderAction);

    QVERIFY(action != 0);

    slider->triggerAction(*action);

    QCOMPARE(previousAction,sliderAction); // previousAction set in the actionTriggered() slot

    QCOMPARE(slider->sliderPosition(),expectedSliderPosition);

    QCOMPARE(slider->value(),expectedSliderPosition);

    QCOMPARE(reportedValue,expectedSliderPosition);

    previousAction = int(QAbstractSlider::SliderNoAction);

    if (initialSliderPosition != expectedSliderPosition)

        QVERIFY(actionTriggeredTimeStamp < valueChangedTimeStamp);

}

void tst_QAbstractSlider::minimum_maximum_data()

{

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

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

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

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

    QTest::newRow("Normal range") << 100 << 200 << 100 << 200;

    QTest::newRow("Minimum higher") << 100 << 0 << 100 << 100;

    QTest::newRow("Negative minimum") << -100 << 100 << -100 << 100;

    QTest::newRow("Negative range") << -100 << -50 << -100 << -50;

}

void tst_QAbstractSlider::minimum_maximum()

{

    QFETCH(int, minimum);

    QFETCH(int, maximum);

    QFETCH(int, expectedMinimum);

    QFETCH(int, expectedMaximum);

    slider->setRange(minimum,maximum);

    QCOMPARE(slider->minimum(),expectedMinimum);

    QCOMPARE(slider->maximum(),expectedMaximum);

    QCOMPARE(reportedMinimum,expectedMinimum);

    QCOMPARE(reportedMaximum,expectedMaximum);

    slider->setRange(minimum,maximum);

    slider->setMaximum(slider->minimum() - 1);

    QCOMPARE(slider->maximum(),slider->minimum());

    QCOMPARE(reportedMinimum,slider->minimum());

    QCOMPARE(reportedMaximum,slider->maximum());

    slider->setRange(minimum,maximum);

    slider->setMinimum(slider->maximum() + 1);

    QCOMPARE(slider->minimum(),slider->maximum());

    QCOMPARE(reportedMinimum,slider->minimum());

    QCOMPARE(reportedMaximum,slider->maximum());

    slider->setRange(minimum,maximum);

    slider->setSliderPosition(slider->maximum() + 1);

    QCOMPARE(slider->sliderPosition(), slider->maximum());

    QCOMPARE(slider->value(), slider->maximum());

    QCOMPARE(reportedValue, slider->maximum());

    slider->setRange(minimum,maximum);

    slider->setSliderPosition(slider->minimum() - 1);

    QCOMPARE(slider->sliderPosition(), slider->minimum());

    QCOMPARE(slider->value(), slider->minimum());

    QCOMPARE(reportedValue, slider->minimum());

    slider->setRange(minimum,maximum);

    int oldPosition = slider->sliderPosition();

    slider->setMaximum(oldPosition - 1);

    QCOMPARE(slider->sliderPosition(),oldPosition - 1);

    slider->setRange(minimum,maximum);

    oldPosition = slider->sliderPosition();

    slider->setMinimum(oldPosition + 1);

    QCOMPARE(slider->sliderPosition(), oldPosition + 1);

}

void tst_QAbstractSlider::keyPressed_data()

{

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

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

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

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

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

    QTest::addColumn<QList<Qt::Key> >("keySequence");

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

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

    QTest::addColumn<int>("expectedSliderPositionHorizontalInverted"); // :)

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

    QList<Qt::Key> list;

    list << Qt::Key_Down;

    QTest::newRow("Step down once") << 10   // initial position

                                 << 0    // minimum

                                 << 100  // maximum

                                 << 3    // single step size

                                 << 0    // page step size

                                 << list // key sequence

                                 << 7   // result in case of horizontal slider

                                 << 7    // result in case of vertical slider

                                 << 13   // result in case of inverted horiz. slider

                                 << 13;   // result in case of inverted vertical slider

    list = QList<Qt::Key>();

    list << Qt::Key_Up;

    QTest::newRow("Step down once") << 10   // initial position

                                 << 0    // minimum

                                 << 100  // maximum

                                 << 3    // single step size

                                 << 0    // page step size

                                 << list // key sequence

                                 << 13   // result in case of horizontal slider

                                 << 13    // result in case of vertical slider

                                 << 7   // result in case of inverted horiz. slider

                                 << 7;   // result in case of inverted vertical slider

    list = QList<Qt::Key>();

    list << Qt::Key_Left;

    QTest::newRow("Step left once") << 10   // initial position

                                 << 0    // minimum

                                 << 100  // maximum

                                 << 3    // single step size

                                 << 0    // page step size

                                 << list // key sequence

                                 << 7    // result in case of horizontal slider

                                 << 7   // result in case of vertical slider

                                 << 13   // result in case of inverted horiz. slider

                                 << 13;   // result in case of inverted vertical slider

    list = QList<Qt::Key>();

    list << Qt::Key_Right;

    QTest::newRow("Step right once") << 10   // initial position

                                  << 0    // minimum

                                  << 100  // maximum

                                  << 3    // single step size

                                  << 0    // page step size

                                  << list // key sequence

                                  << 13   // result in case of horizontal slider

                                  << 13   // result in case of vertical slider