/*

    Copyright (C) 2008,2009 Nokia Corporation and/or its subsidiary(-ies)

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License

    along with this library; see the file COPYING.LIB.  If not, write to

    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    Boston, MA 02110-1301, USA.

*/

#include <QtTest/QtTest>

#include <qwebpage.h>

#include <qwebelement.h>

#include <qwidget.h>

#include <qwebview.h>

#include <qwebframe.h>

#include <qwebhistory.h>

#include <QAbstractItemView>

#include <QApplication>

#include <QComboBox>

#include <QPicture>

#include <QRegExp>

#include <QNetworkRequest>

#include <QNetworkReply>

#ifndef QT_NO_OPENSSL

#include <qsslerror.h>

#endif

#include "../util.h"

#if defined(Q_OS_SYMBIAN)

# define SRCDIR ""

#endif

//TESTED_CLASS=

//TESTED_FILES=

// Task 160192

/**

 * Starts an event loop that runs until the given signal is received.

 Optionally the event loop

 * can return earlier on a timeout.

 *

 * \return \p true if the requested signal was received

 *         \p false on timeout

 */

static bool waitForSignal(QObject* obj, const char* signal, int timeout = 0)

{

    QEventLoop loop;

    QObject::connect(obj, signal, &loop, SLOT(quit()));

    QTimer timer;

    QSignalSpy timeoutSpy(&timer, SIGNAL(timeout()));

    if (timeout > 0) {

        QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));

        timer.setSingleShot(true);

        timer.start(timeout);

    }

    loop.exec();

    return timeoutSpy.isEmpty();

}

/* Mostly a test for the JavaScript related parts of QWebFrame */

struct CustomType {

    QString string;

};

Q_DECLARE_METATYPE(CustomType)

Q_DECLARE_METATYPE(QBrush*)

Q_DECLARE_METATYPE(QObjectList)

Q_DECLARE_METATYPE(QList<int>)

Q_DECLARE_METATYPE(Qt::BrushStyle)

Q_DECLARE_METATYPE(QVariantList)

Q_DECLARE_METATYPE(QVariantMap)

class MyQObject : public QObject

{

    Q_OBJECT

    Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty)

    Q_PROPERTY(QVariant variantProperty READ variantProperty WRITE setVariantProperty)

    Q_PROPERTY(QVariantList variantListProperty READ variantListProperty WRITE setVariantListProperty)

    Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty)

    Q_PROPERTY(QStringList stringListProperty READ stringListProperty WRITE setStringListProperty)

    Q_PROPERTY(QByteArray byteArrayProperty READ byteArrayProperty WRITE setByteArrayProperty)

    Q_PROPERTY(QBrush brushProperty READ brushProperty WRITE setBrushProperty)

    Q_PROPERTY(double hiddenProperty READ hiddenProperty WRITE setHiddenProperty SCRIPTABLE false)

    Q_PROPERTY(int writeOnlyProperty WRITE setWriteOnlyProperty)

    Q_PROPERTY(int readOnlyProperty READ readOnlyProperty)

    Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)

    Q_PROPERTY(CustomType propWithCustomType READ propWithCustomType WRITE setPropWithCustomType)

    Q_ENUMS(Policy Strategy)

    Q_FLAGS(Ability)

public:

    enum Policy {

        FooPolicy = 0,

        BarPolicy,

        BazPolicy

    };

    enum Strategy {

        FooStrategy = 10,

        BarStrategy,

        BazStrategy

    };

    enum AbilityFlag {

        NoAbility  = 0x000,

        FooAbility = 0x001,

        BarAbility = 0x080,

        BazAbility = 0x200,

        AllAbility = FooAbility | BarAbility | BazAbility

    };

    Q_DECLARE_FLAGS(Ability, AbilityFlag)

    MyQObject(QObject* parent = 0)

        : QObject(parent),

            m_intValue(123),

            m_variantValue(QLatin1String("foo")),

            m_variantListValue(QVariantList() << QVariant(123) << QVariant(QLatin1String("foo"))),

            m_stringValue(QLatin1String("bar")),

            m_stringListValue(QStringList() << QLatin1String("zig") << QLatin1String("zag")),

            m_brushValue(QColor(10, 20, 30, 40)),

            m_hiddenValue(456.0),

            m_writeOnlyValue(789),

            m_readOnlyValue(987),

            m_qtFunctionInvoked(-1) { }

    ~MyQObject() { }

    int intProperty() const {

        return m_intValue;

    }

    void setIntProperty(int value) {

        m_intValue = value;

    }

    QVariant variantProperty() const {

        return m_variantValue;

    }

    void setVariantProperty(const QVariant &value) {

        m_variantValue = value;

    }

    QVariantList variantListProperty() const {

        return m_variantListValue;

    }

    void setVariantListProperty(const QVariantList &value) {

        m_variantListValue = value;

    }

    QString stringProperty() const {

        return m_stringValue;

    }

    void setStringProperty(const QString &value) {

        m_stringValue = value;

    }

    QStringList stringListProperty() const {

        return m_stringListValue;

    }

    void setStringListProperty(const QStringList &value) {

        m_stringListValue = value;

    }

    QByteArray byteArrayProperty() const {

        return m_byteArrayValue;

    }

    void setByteArrayProperty(const QByteArray &value) {

        m_byteArrayValue = value;

    }

    QBrush brushProperty() const {

        return m_brushValue;

    }

    Q_INVOKABLE void setBrushProperty(const QBrush &value) {

        m_brushValue = value;

    }

    double hiddenProperty() const {

        return m_hiddenValue;

    }

    void setHiddenProperty(double value) {

        m_hiddenValue = value;

    }

    int writeOnlyProperty() const {

        return m_writeOnlyValue;

    }

    void setWriteOnlyProperty(int value) {

        m_writeOnlyValue = value;

    }

    int readOnlyProperty() const {

        return m_readOnlyValue;

    }

    QKeySequence shortcut() const {

        return m_shortcut;

    }

    void setShortcut(const QKeySequence &seq) {

        m_shortcut = seq;

    }

    CustomType propWithCustomType() const {

        return m_customType;

    }

    void setPropWithCustomType(const CustomType &c) {

        m_customType = c;

    }

    int qtFunctionInvoked() const {

        return m_qtFunctionInvoked;

    }

    QVariantList qtFunctionActuals() const {

        return m_actuals;

    }

    void resetQtFunctionInvoked() {

        m_qtFunctionInvoked = -1;

        m_actuals.clear();

    }

    Q_INVOKABLE void myInvokable() {

        m_qtFunctionInvoked = 0;

    }

    Q_INVOKABLE void myInvokableWithIntArg(int arg) {

        m_qtFunctionInvoked = 1;

        m_actuals << arg;

    }

    Q_INVOKABLE void myInvokableWithLonglongArg(qlonglong arg) {

        m_qtFunctionInvoked = 2;

        m_actuals << arg;

    }

    Q_INVOKABLE void myInvokableWithFloatArg(float arg) {

        m_qtFunctionInvoked = 3;

        m_actuals << arg;

    }

    Q_INVOKABLE void myInvokableWithDoubleArg(double arg) {

        m_qtFunctionInvoked = 4;

        m_actuals << arg;

    }

    Q_INVOKABLE void myInvokableWithStringArg(const QString &arg) {

        m_qtFunctionInvoked = 5;

        m_actuals << arg;

    }

    Q_INVOKABLE void myInvokableWithIntArgs(int arg1, int arg2) {

        m_qtFunctionInvoked = 6;

        m_actuals << arg1 << arg2;

    }

    Q_INVOKABLE int myInvokableReturningInt() {

        m_qtFunctionInvoked = 7;

        return 123;

    }

    Q_INVOKABLE qlonglong myInvokableReturningLongLong() {

        m_qtFunctionInvoked = 39;

        return 456;

    }

    Q_INVOKABLE QString myInvokableReturningString() {

        m_qtFunctionInvoked = 8;

        return QLatin1String("ciao");

    }

    Q_INVOKABLE void myInvokableWithIntArg(int arg1, int arg2) { // overload

        m_qtFunctionInvoked = 9;

        m_actuals << arg1 << arg2;

    }

    Q_INVOKABLE void myInvokableWithEnumArg(Policy policy) {

        m_qtFunctionInvoked = 10;

        m_actuals << policy;

    }

    Q_INVOKABLE void myInvokableWithQualifiedEnumArg(MyQObject::Policy policy) {

        m_qtFunctionInvoked = 36;

        m_actuals << policy;

    }

    Q_INVOKABLE Policy myInvokableReturningEnum() {

        m_qtFunctionInvoked = 37;

        return BazPolicy;

    }

    Q_INVOKABLE MyQObject::Policy myInvokableReturningQualifiedEnum() {

        m_qtFunctionInvoked = 38;

        return BazPolicy;

    }

    Q_INVOKABLE QVector<int> myInvokableReturningVectorOfInt() {

        m_qtFunctionInvoked = 11;

        return QVector<int>();

    }

    Q_INVOKABLE void myInvokableWithVectorOfIntArg(const QVector<int> &) {

        m_qtFunctionInvoked = 12;

    }

    Q_INVOKABLE QObject* myInvokableReturningQObjectStar() {

        m_qtFunctionInvoked = 13;

        return this;

    }

    Q_INVOKABLE QObjectList myInvokableWithQObjectListArg(const QObjectList &lst) {

        m_qtFunctionInvoked = 14;

        m_actuals << qVariantFromValue(lst);

        return lst;

    }

    Q_INVOKABLE QVariant myInvokableWithVariantArg(const QVariant &v) {

        m_qtFunctionInvoked = 15;

        m_actuals << v;

        return v;

    }

    Q_INVOKABLE QVariantMap myInvokableWithVariantMapArg(const QVariantMap &vm) {

        m_qtFunctionInvoked = 16;

        m_actuals << vm;

        return vm;

    }

    Q_INVOKABLE QList<int> myInvokableWithListOfIntArg(const QList<int> &lst) {

        m_qtFunctionInvoked = 17;

        m_actuals << qVariantFromValue(lst);

        return lst;

    }

    Q_INVOKABLE QObject* myInvokableWithQObjectStarArg(QObject* obj) {

        m_qtFunctionInvoked = 18;

        m_actuals << qVariantFromValue(obj);

        return obj;

    }

    Q_INVOKABLE QBrush myInvokableWithQBrushArg(const QBrush &brush) {

        m_qtFunctionInvoked = 19;

        m_actuals << qVariantFromValue(brush);

        return brush;

    }

    Q_INVOKABLE void myInvokableWithBrushStyleArg(Qt::BrushStyle style) {

        m_qtFunctionInvoked = 43;

        m_actuals << qVariantFromValue(style);

    }

    Q_INVOKABLE void myInvokableWithVoidStarArg(void* arg) {

        m_qtFunctionInvoked = 44;

        m_actuals << qVariantFromValue(arg);

    }

    Q_INVOKABLE void myInvokableWithAmbiguousArg(int arg) {

        m_qtFunctionInvoked = 45;

        m_actuals << qVariantFromValue(arg);

    }

    Q_INVOKABLE void myInvokableWithAmbiguousArg(uint arg) {

        m_qtFunctionInvoked = 46;

        m_actuals << qVariantFromValue(arg);

    }

    Q_INVOKABLE void myInvokableWithDefaultArgs(int arg1, const QString &arg2 = "") {

        m_qtFunctionInvoked = 47;

        m_actuals << qVariantFromValue(arg1) << qVariantFromValue(arg2);

    }

    Q_INVOKABLE QObject& myInvokableReturningRef() {

        m_qtFunctionInvoked = 48;

        return *this;

    }

    Q_INVOKABLE const QObject& myInvokableReturningConstRef() const {

        const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 49;

        return *this;

    }

    Q_INVOKABLE void myInvokableWithPointArg(const QPoint &arg) {

        const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 50;

        m_actuals << qVariantFromValue(arg);

    }

    Q_INVOKABLE void myInvokableWithPointArg(const QPointF &arg) {

        const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 51;

        m_actuals << qVariantFromValue(arg);

    }

    Q_INVOKABLE void myInvokableWithBoolArg(bool arg) {

        m_qtFunctionInvoked = 52;

        m_actuals << arg;

    }

    void emitMySignal() {

        emit mySignal();

    }

    void emitMySignalWithIntArg(int arg) {

        emit mySignalWithIntArg(arg);

    }

    void emitMySignal2(bool arg) {

        emit mySignal2(arg);

    }

    void emitMySignal2() {

        emit mySignal2();

    }

    void emitMySignalWithDateTimeArg(QDateTime dt) {

        emit mySignalWithDateTimeArg(dt);

    }

    void emitMySignalWithRegexArg(QRegExp r) {

        emit mySignalWithRegexArg(r);

    }

public Q_SLOTS:

    void mySlot() {

        m_qtFunctionInvoked = 20;

    }

    void mySlotWithIntArg(int arg) {

        m_qtFunctionInvoked = 21;

        m_actuals << arg;

    }

    void mySlotWithDoubleArg(double arg) {

        m_qtFunctionInvoked = 22;

        m_actuals << arg;

    }

    void mySlotWithStringArg(const QString &arg) {

        m_qtFunctionInvoked = 23;

        m_actuals << arg;

    }

    void myOverloadedSlot() {

        m_qtFunctionInvoked = 24;

    }

    void myOverloadedSlot(QObject* arg) {

        m_qtFunctionInvoked = 41;

        m_actuals << qVariantFromValue(arg);

    }

    void myOverloadedSlot(bool arg) {

        m_qtFunctionInvoked = 25;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QStringList &arg) {

        m_qtFunctionInvoked = 42;

        m_actuals << arg;

    }

    void myOverloadedSlot(double arg) {

        m_qtFunctionInvoked = 26;

        m_actuals << arg;

    }

    void myOverloadedSlot(float arg) {

        m_qtFunctionInvoked = 27;

        m_actuals << arg;

    }

    void myOverloadedSlot(int arg) {

        m_qtFunctionInvoked = 28;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QString &arg) {

        m_qtFunctionInvoked = 29;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QColor &arg) {

        m_qtFunctionInvoked = 30;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QBrush &arg) {

        m_qtFunctionInvoked = 31;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QDateTime &arg) {

        m_qtFunctionInvoked = 32;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QDate &arg) {

        m_qtFunctionInvoked = 33;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QRegExp &arg) {

        m_qtFunctionInvoked = 34;

        m_actuals << arg;

    }

    void myOverloadedSlot(const QVariant &arg) {

        m_qtFunctionInvoked = 35;

        m_actuals << arg;

    }

    void qscript_call(int arg) {

        m_qtFunctionInvoked = 40;

        m_actuals << arg;

    }

protected Q_SLOTS:

    void myProtectedSlot() {

        m_qtFunctionInvoked = 36;

    }

private Q_SLOTS:

    void myPrivateSlot() { }

Q_SIGNALS:

    void mySignal();

    void mySignalWithIntArg(int arg);

    void mySignalWithDoubleArg(double arg);

    void mySignal2(bool arg = false);

    void mySignalWithDateTimeArg(QDateTime dt);

    void mySignalWithRegexArg(QRegExp r);

private:

    int m_intValue;

    QVariant m_variantValue;

    QVariantList m_variantListValue;

    QString m_stringValue;

    QStringList m_stringListValue;

    QByteArray m_byteArrayValue;

    QBrush m_brushValue;

    double m_hiddenValue;

    int m_writeOnlyValue;

    int m_readOnlyValue;

    QKeySequence m_shortcut;

    CustomType m_customType;

    int m_qtFunctionInvoked;

    QVariantList m_actuals;

};

class MyOtherQObject : public MyQObject

{

public:

    MyOtherQObject(QObject* parent = 0)

        : MyQObject(parent) { }

};

class MyEnumTestQObject : public QObject

{

    Q_OBJECT

    Q_PROPERTY(QString p1 READ p1)

    Q_PROPERTY(QString p2 READ p2)

    Q_PROPERTY(QString p3 READ p3 SCRIPTABLE false)

    Q_PROPERTY(QString p4 READ p4)

    Q_PROPERTY(QString p5 READ p5 SCRIPTABLE false)

    Q_PROPERTY(QString p6 READ p6)

public:

    MyEnumTestQObject(QObject* parent = 0)

        : QObject(parent) { }

    QString p1() const {