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

**

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

#include <qscriptcontext.h>

#include <qscriptvalueiterator.h>

#include <qwidget.h>

#include <qpushbutton.h>

#include <qlineedit.h>

//TESTED_CLASS=

//TESTED_FILES=script/qscriptextqobject_p.h script/qscriptextqobject.cpp

struct CustomType

{

#if defined (Q_CC_NOKIAX86)

    // Compiler crash workaround

    CustomType() {}

#endif

    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(QDir)

static void dirFromScript(const QScriptValue &in, QDir &out)

{

    QScriptValue path = in.property("path");

    if (!path.isValid())

        in.engine()->currentContext()->throwError("No path");

    else

        out.setPath(path.toString());

}

namespace MyNS

{

    class A : public QObject

    {

        Q_OBJECT

    public:

        enum Type {

            Foo,

            Bar

        };

        Q_ENUMS(Type)

    public Q_SLOTS:

        int slotTakingScopedEnumArg(MyNS::A::Type t) {

            return t;

        }

    };

}

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_PROPERTY(Policy enumProperty READ enumProperty WRITE setEnumProperty)

    Q_PROPERTY(Ability flagsProperty READ flagsProperty WRITE setFlagsProperty)

    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_enumValue(BarPolicy),

          m_flagsValue(FooAbility),

          m_qtFunctionInvoked(-1)

        { }

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

    Policy enumProperty() const

        { return m_enumValue; }

    void setEnumProperty(Policy policy)

        { m_enumValue = policy; }

    Ability flagsProperty() const

        { return m_flagsValue; }

    void setFlagsProperty(Ability ability)

        { m_flagsValue = ability; }

    int qtFunctionInvoked() const

        { return m_qtFunctionInvoked; }

    QVariantList qtFunctionActuals() const

        { return m_actuals; }

    void resetQtFunctionInvoked()

        { m_qtFunctionInvoked = -1; m_actuals.clear(); }

    void clearConnectedSignal()

        { m_connectedSignal = QByteArray(); }

    void clearDisconnectedSignal()

        { m_disconnectedSignal = QByteArray(); }

    QByteArray connectedSignal() const

        { return m_connectedSignal; }

    QByteArray disconnectedSignal() const

        { return m_disconnectedSignal; }

    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 QVariant myInvokableReturningVariant()

        { m_qtFunctionInvoked = 60; return 123; }

    Q_INVOKABLE QScriptValue myInvokableReturningScriptValue()

        { m_qtFunctionInvoked = 61; return 456; }

    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::Strategy myInvokableReturningQualifiedEnum()

        { m_qtFunctionInvoked = 38; return BazStrategy; }

    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 myInvokableWithMyQObjectArg(MyQObject *arg)

        { m_qtFunctionInvoked = 52; m_actuals << qVariantFromValue((QObject*)arg); }

    Q_INVOKABLE MyQObject* myInvokableReturningMyQObject()

        { m_qtFunctionInvoked = 53; return this; }

    Q_INVOKABLE void myInvokableWithConstMyQObjectArg(const MyQObject *arg)

        { m_qtFunctionInvoked = 54; m_actuals << qVariantFromValue((QObject*)arg); }

    Q_INVOKABLE void myInvokableWithQDirArg(const QDir &arg)

        { m_qtFunctionInvoked = 55; m_actuals << qVariantFromValue(arg); }

    Q_INVOKABLE QScriptValue myInvokableWithScriptValueArg(const QScriptValue &arg)

        { m_qtFunctionInvoked = 56; return arg; }

    Q_INVOKABLE QObject* myInvokableReturningMyQObjectAsQObject()

        { m_qtFunctionInvoked = 57; return this; }

    Q_INVOKABLE Ability myInvokableWithFlagsArg(Ability arg)

        { m_qtFunctionInvoked = 58; m_actuals << int(arg); return arg; }

    Q_INVOKABLE MyQObject::Ability myInvokableWithQualifiedFlagsArg(MyQObject::Ability arg)

        { m_qtFunctionInvoked = 59; m_actuals << int(arg); return arg; }

    Q_INVOKABLE QObjectList findObjects() const

    {  return findChildren<QObject *>();  }

    Q_INVOKABLE QList<int> myInvokableNumbers() const

    {  return QList<int>() << 1 << 2 << 3; }

    void emitMySignal()

        { emit mySignal(); }

    void emitMySignalWithIntArg(int arg)

        { emit mySignalWithIntArg(arg); }

    void emitMySignal2(bool arg)

        { emit mySignal2(arg); }

    void emitMySignal2()

        { emit mySignal2(); }

    void emitMyOverloadedSignal(int arg)

        { emit myOverloadedSignal(arg); }

    void emitMyOverloadedSignal(const QString &arg)

        { emit myOverloadedSignal(arg); }

    void emitMyOtherOverloadedSignal(const QString &arg)

        { emit myOtherOverloadedSignal(arg); }

    void emitMyOtherOverloadedSignal(int arg)

        { emit myOtherOverloadedSignal(arg); }

    void emitMySignalWithDefaultArgWithArg(int arg)

        { emit mySignalWithDefaultArg(arg); }

    void emitMySignalWithDefaultArg()

        { emit mySignalWithDefaultArg(); }

    void emitMySignalWithVariantArg(const QVariant &arg)

        { emit mySignalWithVariantArg(arg); }

    void emitMySignalWithScriptEngineArg(QScriptEngine *arg)

        { emit mySignalWithScriptEngineArg(arg); }

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

    virtual int myVirtualSlot(int arg)

        { m_qtFunctionInvoked = 58; return 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 myOverloadedSignal(int arg);

    void myOverloadedSignal(const QString &arg);

    void myOtherOverloadedSignal(const QString &arg);

    void myOtherOverloadedSignal(int arg);

    void mySignalWithDefaultArg(int arg = 123);

    void mySignalWithVariantArg(const QVariant &arg);

    void mySignalWithScriptEngineArg(QScriptEngine *arg);

protected:

    void connectNotify(const char *signal) {

        m_connectedSignal = signal;

    }

    void disconnectNotify(const char *signal) {

        m_disconnectedSignal = signal;

    }

protected:

    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;

    Policy m_enumValue;

    Ability m_flagsValue;

    int m_qtFunctionInvoked;

    QVariantList m_actuals;

    QByteArray m_connectedSignal;

    QByteArray m_disconnectedSignal;

};

Q_DECLARE_METATYPE(MyQObject*)

Q_DECLARE_METATYPE(MyQObject::Policy)

class MyOtherQObject : public MyQObject

{

    Q_OBJECT

public:

    MyOtherQObject(QObject *parent = 0)

        : MyQObject(parent)

        { }

public Q_SLOTS:

    virtual int myVirtualSlot(int arg)

        { m_qtFunctionInvoked = 59; return arg; }

};

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 { return QLatin1String("p1"); }

    QString p2() const { return QLatin1String("p2"); }

    QString p3() const { return QLatin1String("p3"); }

    QString p4() const { return QLatin1String("p4"); }

    QString p5() const { return QLatin1String("p5"); }

    QString p6() const { return QLatin1String("p5"); }

public Q_SLOTS:

    void mySlot() { }

    void myOtherSlot() { }

Q_SIGNALS:

    void mySignal();

};

class tst_QScriptExtQObject : public QObject

{

    Q_OBJECT

public:

    tst_QScriptExtQObject();

    virtual ~tst_QScriptExtQObject();

public slots:

    void init();

    void cleanup();

protected slots:

    void onSignalHandlerException(const QScriptValue &exception)

    {

        m_signalHandlerException = exception;

    }

private slots:

    void registeredTypes();

    void getSetStaticProperty();

    void getSetDynamicProperty();

    void getSetChildren();

    void callQtInvokable();

    void connectAndDisconnect();

    void connectAndDisconnectWithBadArgs();

    void cppConnectAndDisconnect();

    void classEnums();

    void classConstructor();

    void overrideInvokable();

    void transferInvokable();

    void findChild();

    void findChildren();

    void overloadedSlots();