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

**

** 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 <QtGui/QPushButton>

#include <QtGui/QStyle>

#include <QtGui/QLayout>

#include <QtGui/QDialog>

#include <QtGui/QAction>

#include <qdialogbuttonbox.h>

#include <limits.h>

//TESTED_CLASS=

//TESTED_FILES=

Q_DECLARE_METATYPE(QList<int>)

Q_DECLARE_METATYPE(QDialogButtonBox::ButtonRole)

Q_DECLARE_METATYPE(QDialogButtonBox::StandardButton)

Q_DECLARE_METATYPE(QDialogButtonBox::StandardButtons)

Q_DECLARE_METATYPE(QAbstractButton*)

class tst_QDialogButtonBox : public QObject

{

    Q_OBJECT

public:

    tst_QDialogButtonBox();

    ~tst_QDialogButtonBox();

public slots:

    void buttonClicked1(QAbstractButton *);

    void acceptClicked();

    void rejectClicked();

    void helpRequestedClicked();

private slots:

    void standardButtons();

    void testConstructor1();

    void testConstrurtor2();

    void testConstrurtor2_data();

    void testConstructor3();

    void testConstructor3_data();

    void setOrientation_data();

    void setOrientation();

    void addButton1_data();

    void addButton1();

    void addButton2_data();

    void addButton2();

    void addButton3_data();

    void addButton3();

    void clear_data();

    void clear();

    void removeButton_data();

    void removeButton();

    void buttonRole_data();

    void buttonRole();

    void setStandardButtons_data();

    void setStandardButtons();

    void layoutReuse();

    // Skip these tests, buttons is used in every test thus far.

//    void buttons_data();

//    void buttons();

    void testDelete();

    void testRemove();

    void testMultipleAdd();

    void testStandardButtonMapping_data();

    void testStandardButtonMapping();

    void testSignals_data();

    void testSignals();

    void testSignalOrder();

    void testDefaultButton_data();

    void testDefaultButton();

    void testS60SoftKeys();

#ifdef QT_SOFTKEYS_ENABLED

    void testSoftKeyReparenting();

#endif

    void task191642_default();

private:

    qint64 timeStamp;

    qint64 buttonClicked1TimeStamp;

    qint64 acceptTimeStamp;

    qint64 rejectTimeStamp;

    qint64 helpRequestedTimeStamp;

};

tst_QDialogButtonBox::tst_QDialogButtonBox()

{

}

tst_QDialogButtonBox::~tst_QDialogButtonBox()

{

}

void tst_QDialogButtonBox::testConstructor1()

{

    QDialogButtonBox buttonbox;

    QCOMPARE(buttonbox.orientation(), Qt::Horizontal);

    QCOMPARE(buttonbox.buttons().count(), 0);

}

void tst_QDialogButtonBox::layoutReuse()

{

    QDialogButtonBox *box = new QDialogButtonBox(QDialogButtonBox::Ok);

    QPointer<QLayout> layout = box->layout();

    box->setCenterButtons(!box->centerButtons());

    QVERIFY(layout == box->layout());

    QEvent event(QEvent::StyleChange);

    QApplication::sendEvent(box, &event);

    QVERIFY(layout == box->layout());

    box->setOrientation(box->orientation() == Qt::Horizontal ? Qt::Vertical : Qt::Horizontal);

    QVERIFY(layout == 0);

    QVERIFY(layout != box->layout());

    delete box;

}

void tst_QDialogButtonBox::testConstrurtor2_data()

{

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

    QTest::newRow("horizontal") << int(Qt::Horizontal);

    QTest::newRow("vertical") << int(Qt::Vertical);

}

void tst_QDialogButtonBox::testConstrurtor2()

{

    QFETCH(int, orientation);

    Qt::Orientation orient = Qt::Orientation(orientation);

    QDialogButtonBox buttonBox(orient);

    QCOMPARE(buttonBox.orientation(), orient);

    QCOMPARE(buttonBox.buttons().count(), 0);

}

void tst_QDialogButtonBox::testConstructor3_data()

{

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

    QTest::addColumn<QDialogButtonBox::StandardButtons>("buttons");

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

    QTest::newRow("nothing") << int(Qt::Horizontal) << (QDialogButtonBox::StandardButtons)0 << 0;

    QTest::newRow("only 1") << int(Qt::Horizontal) << QDialogButtonBox::StandardButtons(QDialogButtonBox::Ok) << 1;

    QTest::newRow("only 1.. twice") << int(Qt::Horizontal)

                        << (QDialogButtonBox::Ok | QDialogButtonBox::Ok)

                        << 1;

    QTest::newRow("only 2") << int(Qt::Horizontal)

            << (QDialogButtonBox::Ok | QDialogButtonBox::Cancel)

            << 2;

    QTest::newRow("two different things") << int(Qt::Horizontal)

            << (QDialogButtonBox::Save | QDialogButtonBox::Close)

            << 2;

    QTest::newRow("three") << int(Qt::Horizontal)

            << (QDialogButtonBox::Ok

                    | QDialogButtonBox::Cancel

                    | QDialogButtonBox::Help)

            << 3;

    QTest::newRow("everything") << int(Qt::Vertical)

            << (QDialogButtonBox::StandardButtons)UINT_MAX

            << 18;

}

void tst_QDialogButtonBox::testConstructor3()

{

    QFETCH(int, orientation);

    QFETCH(QDialogButtonBox::StandardButtons, buttons);

    QDialogButtonBox buttonBox(buttons, (Qt::Orientation)orientation);

    QCOMPARE(int(buttonBox.orientation()), orientation);

    QTEST(buttonBox.buttons().count(), "buttonCount");

}

void tst_QDialogButtonBox::setOrientation_data()

{

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

    QTest::newRow("Horizontal") << int(Qt::Horizontal);

    QTest::newRow("Vertical") << int(Qt::Vertical);

}

void tst_QDialogButtonBox::setOrientation()

{

    QFETCH(int, orientation);

    QDialogButtonBox buttonBox;

    QCOMPARE(int(buttonBox.orientation()), int(Qt::Horizontal));

    buttonBox.setOrientation(Qt::Orientation(orientation));

    QCOMPARE(int(buttonBox.orientation()), orientation);

}

/*

void tst_QDialogButtonBox::setLayoutPolicy_data()

{

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

    QTest::newRow("win") << int(QDialogButtonBox::WinLayout);

    QTest::newRow("mac") << int(QDialogButtonBox::MacLayout);

    QTest::newRow("kde") << int(QDialogButtonBox::KdeLayout);

    QTest::newRow("gnome") << int(QDialogButtonBox::GnomeLayout);

}

void tst_QDialogButtonBox::setLayoutPolicy()

{

    QFETCH(int, layoutPolicy);

    QDialogButtonBox buttonBox;

    QCOMPARE(int(buttonBox.layoutPolicy()),

             int(buttonBox.style()->styleHint(QStyle::SH_DialogButtonLayout)));

    buttonBox.setLayoutPolicy(QDialogButtonBox::ButtonLayout(layoutPolicy));

    QCOMPARE(int(buttonBox.layoutPolicy()), layoutPolicy);

}

*/

void tst_QDialogButtonBox::addButton1_data()

{

    QTest::addColumn<QDialogButtonBox::ButtonRole>("role");

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

    QTest::newRow("InvalidRole") << QDialogButtonBox::InvalidRole << 0;

    QTest::newRow("AcceptRole") << QDialogButtonBox::AcceptRole << 1;

    QTest::newRow("RejectRole") << QDialogButtonBox::RejectRole << 1;

    QTest::newRow("DestructiveRole") << QDialogButtonBox::DestructiveRole << 1;

    QTest::newRow("ActionRole") << QDialogButtonBox::ActionRole << 1;

    QTest::newRow("HelpRole") << QDialogButtonBox::HelpRole << 1;

    QTest::newRow("WackyValue") << (QDialogButtonBox::ButtonRole)-1 << 0;

}

void tst_QDialogButtonBox::addButton1()

{

    QFETCH(QDialogButtonBox::ButtonRole, role);

    QDialogButtonBox buttonBox;

    QCOMPARE(buttonBox.buttons().count(), 0);

    QPushButton *button = new QPushButton();

    buttonBox.addButton(button, role);

    QTEST(buttonBox.buttons().count(), "totalCount");

    QList<QAbstractButton *> children = qFindChildren<QAbstractButton *>(&buttonBox);

    QTEST(children.count(), "totalCount");

    delete button;

}

void tst_QDialogButtonBox::addButton2_data()

{

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

    QTest::addColumn<QDialogButtonBox::ButtonRole>("role");

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

    QTest::newRow("InvalidRole") << QString("foo") << QDialogButtonBox::InvalidRole << 0;

    QTest::newRow("AcceptRole") << QString("foo") << QDialogButtonBox::AcceptRole << 1;

    QTest::newRow("RejectRole") << QString("foo") << QDialogButtonBox::RejectRole << 1;

    QTest::newRow("DestructiveRole") << QString("foo") << QDialogButtonBox::DestructiveRole << 1;

    QTest::newRow("ActionRole") << QString("foo") << QDialogButtonBox::ActionRole << 1;

    QTest::newRow("HelpRole") << QString("foo") << QDialogButtonBox::HelpRole << 1;

    QTest::newRow("WackyValue") << QString("foo") << (QDialogButtonBox::ButtonRole)-1 << 0;

}

void tst_QDialogButtonBox::addButton2()

{

    QFETCH(QString, text);

    QFETCH(QDialogButtonBox::ButtonRole, role);

    QDialogButtonBox buttonBox;

    QCOMPARE(buttonBox.buttons().count(), 0);

    buttonBox.addButton(text, role);

    QTEST(buttonBox.buttons().count(), "totalCount");

    QList<QAbstractButton *> children = qFindChildren<QAbstractButton *>(&buttonBox);

    QTEST(children.count(), "totalCount");

}

void tst_QDialogButtonBox::addButton3_data()

{

    QTest::addColumn<QDialogButtonBox::StandardButton>("button");

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

    QTest::newRow("Ok") << QDialogButtonBox::Ok << 1;

    QTest::newRow("Open") << QDialogButtonBox::Open << 1;

    QTest::newRow("Save") << QDialogButtonBox::Save << 1;

    QTest::newRow("Cancel") << QDialogButtonBox::Cancel << 1;

    QTest::newRow("Close") << QDialogButtonBox::Close << 1;

    QTest::newRow("Discard") << QDialogButtonBox::Discard << 1;

    QTest::newRow("Apply") << QDialogButtonBox::Apply << 1;

    QTest::newRow("Reset") << QDialogButtonBox::Reset << 1;

    QTest::newRow("Help") << QDialogButtonBox::Help << 1;

    QTest::newRow("noButton") << (QDialogButtonBox::StandardButton)0 << 0;

}

void tst_QDialogButtonBox::addButton3()

{

    QFETCH(QDialogButtonBox::StandardButton, button);

    QDialogButtonBox buttonBox;

    QCOMPARE(buttonBox.buttons().count(), 0);

    buttonBox.addButton(button);

    QTEST(buttonBox.buttons().count(), "totalCount");

    QList<QAbstractButton *> children = qFindChildren<QAbstractButton *>(&buttonBox);

    QTEST(children.count(), "totalCount");

}

void tst_QDialogButtonBox::clear_data()

{

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

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

    QTest::newRow("one") << 1;

    QTest::newRow("all") << int(QDialogButtonBox::NRoles);

}

void tst_QDialogButtonBox::clear()

{

    QFETCH(int, rolesToAdd);

    QDialogButtonBox buttonBox;

    for (int i = 1; i < rolesToAdd; ++i)

        buttonBox.addButton("Happy", QDialogButtonBox::ButtonRole(i));

    buttonBox.clear();

    QCOMPARE(buttonBox.buttons().count(), 0);

    QList<QAbstractButton *> children = qFindChildren<QAbstractButton *>(&buttonBox);

    QCOMPARE(children.count(), 0);

}

void tst_QDialogButtonBox::removeButton_data()

{

    QTest::addColumn<QDialogButtonBox::ButtonRole>("roleToAdd");

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

    QTest::newRow("no button added") << QDialogButtonBox::InvalidRole << 0;

    QTest::newRow("a button") << QDialogButtonBox::AcceptRole << 1;

}

void tst_QDialogButtonBox::removeButton()

{

    QFETCH(QDialogButtonBox::ButtonRole, roleToAdd);

    QDialogButtonBox buttonBox;

    QCOMPARE(buttonBox.buttons().count(), 0);

    QPushButton *button = new QPushButton("RemoveButton test");

    buttonBox.addButton(button, roleToAdd);

    QTEST(buttonBox.buttons().count(), "expectedCount");

    buttonBox.removeButton(button);

    QCOMPARE(buttonBox.buttons().count(), 0);

    delete button;

}

void tst_QDialogButtonBox::testDelete()

{

    QDialogButtonBox buttonBox;

    QCOMPARE(buttonBox.buttons().count(), 0);

    QPushButton *deleteMe = new QPushButton("Happy");

    buttonBox.addButton(deleteMe, QDialogButtonBox::HelpRole);

    QCOMPARE(buttonBox.buttons().count(), 1);

    QList<QAbstractButton *> children = qFindChildren<QAbstractButton *>(&buttonBox);

    QCOMPARE(children.count(), 1);

    delete deleteMe;

    children = qFindChildren<QAbstractButton *>(&buttonBox);

    QCOMPARE(children.count(), 0);

    QCOMPARE(buttonBox.buttons().count(), 0);

}

void tst_QDialogButtonBox::testMultipleAdd()

{

    // Add a button into the thing multiple times.

    QDialogButtonBox buttonBox;

    QCOMPARE(buttonBox.buttons().count(), 0);

    QPushButton *button = new QPushButton("Foo away");

    buttonBox.addButton(button, QDialogButtonBox::AcceptRole);

    QCOMPARE(buttonBox.buttons().count(), 1);

    QCOMPARE(buttonBox.buttonRole(button), QDialogButtonBox::AcceptRole);

    buttonBox.addButton(button, QDialogButtonBox::AcceptRole);

    QCOMPARE(buttonBox.buttons().count(), 1);

    QCOMPARE(buttonBox.buttonRole(button), QDialogButtonBox::AcceptRole);

    // Add it again with a different role

    buttonBox.addButton(button, QDialogButtonBox::RejectRole);

    QCOMPARE(buttonBox.buttons().count(), 1);

    QCOMPARE(buttonBox.buttonRole(button), QDialogButtonBox::RejectRole);

    // Add it as an "invalid" role

    buttonBox.addButton(button, QDialogButtonBox::InvalidRole);

    QCOMPARE(buttonBox.buttons().count(), 1);

    QCOMPARE(buttonBox.buttonRole(button), QDialogButtonBox::RejectRole);

}

void tst_QDialogButtonBox::buttonRole_data()

{

    QTest::addColumn<QDialogButtonBox::ButtonRole>("roleToAdd");

    QTest::addColumn<QDialogButtonBox::ButtonRole>("expectedRole");

    QTest::newRow("AcceptRole stuff") << QDialogButtonBox::AcceptRole

                                      << QDialogButtonBox::AcceptRole;

    QTest::newRow("Nothing") << QDialogButtonBox::InvalidRole << QDialogButtonBox::InvalidRole;

    QTest::newRow("bad stuff") << (QDialogButtonBox::ButtonRole)-1 << QDialogButtonBox::InvalidRole;

}

void tst_QDialogButtonBox::buttonRole()

{

    QFETCH(QDialogButtonBox::ButtonRole, roleToAdd);

    QDialogButtonBox buttonBox;

    QAbstractButton *button = buttonBox.addButton("Here's a button", roleToAdd);

    QTEST(buttonBox.buttonRole(button), "expectedRole");

}

void tst_QDialogButtonBox::testStandardButtonMapping_data()

{

    QTest::addColumn<QDialogButtonBox::StandardButton>("button");

    QTest::addColumn<QDialogButtonBox::ButtonRole>("expectedRole");

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

    int layoutPolicy = qApp->style()->styleHint(QStyle::SH_DialogButtonLayout);

    QTest::newRow("QDialogButtonBox::Ok") << QDialogButtonBox::Ok

                                          << QDialogButtonBox::AcceptRole

                                          << QDialogButtonBox::tr("OK");

    QTest::newRow("QDialogButtonBox::Open") << QDialogButtonBox::Open

                                            << QDialogButtonBox::AcceptRole

                                            << QDialogButtonBox::tr("Open");

    QTest::newRow("QDialogButtonBox::Save") << QDialogButtonBox::Save

                                            << QDialogButtonBox::AcceptRole

                                            << QDialogButtonBox::tr("Save");

    QTest::newRow("QDialogButtonBox::Cancel") << QDialogButtonBox::Cancel

                                              << QDialogButtonBox::RejectRole

                                              << QDialogButtonBox::tr("Cancel");

    QTest::newRow("QDialogButtonBox::Close") << QDialogButtonBox::Close

                                             << QDialogButtonBox::RejectRole

                                             << QDialogButtonBox::tr("Close");

    if (layoutPolicy == QDialogButtonBox::MacLayout) {

        QTest::newRow("QDialogButtonBox::Discard") << QDialogButtonBox::Discard

                                                    << QDialogButtonBox::DestructiveRole

                                                    << QDialogButtonBox::tr("Don't Save");

    } else if (layoutPolicy == QDialogButtonBox::GnomeLayout) {

        QTest::newRow("QDialogButtonBox::Discard")

            << QDialogButtonBox::Discard

            << QDialogButtonBox::DestructiveRole

            << QDialogButtonBox::tr("Close without Saving");

    } else {

        QTest::newRow("QDialogButtonBox::Discard") << QDialogButtonBox::Discard

                                                    << QDialogButtonBox::DestructiveRole

                                                    << QDialogButtonBox::tr("Discard");

    }

    QTest::newRow("QDialogButtonBox::Apply") << QDialogButtonBox::Apply

                                             << QDialogButtonBox::ApplyRole

                                             << QDialogButtonBox::tr("Apply");

    QTest::newRow("QDialogButtonBox::Reset") << QDialogButtonBox::Reset

                                             << QDialogButtonBox::ResetRole

                                             << QDialogButtonBox::tr("Reset");

    QTest::newRow("QDialogButtonBox::Help") << QDialogButtonBox::Help

                                            << QDialogButtonBox::HelpRole

                                            << QDialogButtonBox::tr("Help");

}

void tst_QDialogButtonBox::testStandardButtonMapping()

{

    QFETCH(QDialogButtonBox::StandardButton, button);

    QDialogButtonBox buttonBox;

    QAbstractButton *theButton = buttonBox.addButton(button);

    QTEST(buttonBox.buttonRole(theButton), "expectedRole");

    QString textWithoutMnemonic = theButton->text().remove("&");

    QTEST(textWithoutMnemonic, "expectedText");

}

void tst_QDialogButtonBox::testSignals_data()

{

    QTest::addColumn<QDialogButtonBox::ButtonRole>("buttonToClick");

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

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

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

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

    QTest::newRow("nothing") << QDialogButtonBox::InvalidRole << 0 << 0 << 0 << 0;

    QTest::newRow("accept") << QDialogButtonBox::AcceptRole << 1 << 1 << 0 << 0;

    QTest::newRow("reject") << QDialogButtonBox::RejectRole << 1 << 0 << 1 << 0;

    QTest::newRow("destructive") << QDialogButtonBox::DestructiveRole << 1 << 0 << 0 << 0;

    QTest::newRow("Action") << QDialogButtonBox::ActionRole << 1 << 0 << 0 << 0;

    QTest::newRow("Help") << QDialogButtonBox::HelpRole << 1 << 0 << 0 << 1;

}

void tst_QDialogButtonBox::testSignals()

{

    QFETCH(QDialogButtonBox::ButtonRole, buttonToClick);

    QDialogButtonBox buttonBox;

    qRegisterMetaType<QAbstractButton *>("QAbstractButton*");

    QSignalSpy clicked2(&buttonBox, SIGNAL(clicked(QAbstractButton*)));

    QSignalSpy accept(&buttonBox, SIGNAL(accepted()));

    QSignalSpy reject(&buttonBox, SIGNAL(rejected()));

    QSignalSpy helpRequested(&buttonBox, SIGNAL(helpRequested()));

    QPushButton *clickMe = 0;

    for (int i = QDialogButtonBox::AcceptRole; i < QDialogButtonBox::NRoles; ++i) {

        QPushButton *button = buttonBox.addButton(QString::number(i),