diff options
Diffstat (limited to 'tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp')
| -rw-r--r-- | tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp | 2887 |
1 files changed, 2887 insertions, 0 deletions
diff --git a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp new file mode 100644 index 0000000..3607ecd --- /dev/null +++ b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp @@ -0,0 +1,2887 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at http://www.qtsoftware.com/contact. +** $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_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_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; } + + 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; } + + 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; + 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 getSetStaticProperty(); + void getSetDynamicProperty(); + void getSetChildren(); + void callQtInvokable(); + void connectAndDisconnect(); + void cppConnectAndDisconnect(); + void classEnums(); + void classConstructor(); + void overrideInvokable(); + void transferInvokable(); + void findChild(); + void findChildren(); + void overloadedSlots(); + void enumerate_data(); + void enumerate(); + void enumerateSpecial(); + void wrapOptions(); + void prototypes(); + void objectDeleted(); + void connectToDestroyedSignal(); + +private: + QScriptEngine *m_engine; + MyQObject *m_myObject; + QScriptValue m_signalHandlerException; +}; + +tst_QScriptExtQObject::tst_QScriptExtQObject() +{ +} + +tst_QScriptExtQObject::~tst_QScriptExtQObject() +{ +} + +void tst_QScriptExtQObject::init() +{ + m_engine = new QScriptEngine(); + m_myObject = new MyQObject(); + m_engine->globalObject().setProperty("myObject", m_engine->newQObject(m_myObject)); + m_engine->globalObject().setProperty("global", m_engine->globalObject()); +} + +void tst_QScriptExtQObject::cleanup() +{ + delete m_engine; + delete m_myObject; +} + +static QScriptValue getSetProperty(QScriptContext *ctx, QScriptEngine *) +{ + if (ctx->argumentCount() != 0) + ctx->callee().setProperty("value", ctx->argument(0)); + return ctx->callee().property("value"); +} + +static QScriptValue policyToScriptValue(QScriptEngine *engine, const MyQObject::Policy &policy) +{ + return qScriptValueFromValue(engine, policy); +} + +static void policyFromScriptValue(const QScriptValue &value, MyQObject::Policy &policy) +{ + QString str = value.toString(); + if (str == QLatin1String("red")) + policy = MyQObject::FooPolicy; + else if (str == QLatin1String("green")) + policy = MyQObject::BarPolicy; + else if (str == QLatin1String("blue")) + policy = MyQObject::BazPolicy; + else + policy = (MyQObject::Policy)-1; +} + +void tst_QScriptExtQObject::getSetStaticProperty() +{ + QCOMPARE(m_engine->evaluate("myObject.noSuchProperty").isUndefined(), true); + + // initial value (set in MyQObject constructor) + QCOMPARE(m_engine->evaluate("myObject.intProperty") + .strictlyEquals(QScriptValue(m_engine, 123.0)), true); + QCOMPARE(m_engine->evaluate("myObject.variantProperty") + .toVariant(), QVariant(QLatin1String("foo"))); + QCOMPARE(m_engine->evaluate("myObject.stringProperty") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("bar"))), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty").isArray(), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty.length") + .strictlyEquals(QScriptValue(m_engine, 2)), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty[0]") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty[1]") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("foo"))), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty").isArray(), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty.length") + .strictlyEquals(QScriptValue(m_engine, 2)), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").isString(), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").toString(), + QLatin1String("zig")); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").isString(), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").toString(), + QLatin1String("zag")); + + // default flags for "normal" properties + { + QScriptValue mobj = m_engine->globalObject().property("myObject"); + QVERIFY(!(mobj.propertyFlags("intProperty") & QScriptValue::ReadOnly)); + QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::Undeletable); + QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::PropertyGetter); + QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::PropertySetter); + QVERIFY(!(mobj.propertyFlags("intProperty") & QScriptValue::SkipInEnumeration)); + QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::QObjectMember); + + QVERIFY(!(mobj.propertyFlags("mySlot") & QScriptValue::ReadOnly)); + QVERIFY(!(mobj.propertyFlags("mySlot") & QScriptValue::Undeletable)); + QVERIFY(!(mobj.propertyFlags("mySlot") & QScriptValue::SkipInEnumeration)); + QVERIFY(mobj.propertyFlags("mySlot") & QScriptValue::QObjectMember); + + // signature-based property + QVERIFY(!(mobj.propertyFlags("mySlot()") & QScriptValue::ReadOnly)); + QVERIFY(!(mobj.propertyFlags("mySlot()") & QScriptValue::Undeletable)); + QVERIFY(!(mobj.propertyFlags("mySlot()") & QScriptValue::SkipInEnumeration)); + QVERIFY(mobj.propertyFlags("mySlot()") & QScriptValue::QObjectMember); + } + + // property change in C++ should be reflected in script + m_myObject->setIntProperty(456); + QCOMPARE(m_engine->evaluate("myObject.intProperty") + .strictlyEquals(QScriptValue(m_engine, 456)), true); + m_myObject->setIntProperty(789); + QCOMPARE(m_engine->evaluate("myObject.intProperty") + .strictlyEquals(QScriptValue(m_engine, 789)), true); + + m_myObject->setVariantProperty(QLatin1String("bar")); + QVERIFY(m_engine->evaluate("myObject.variantProperty") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("bar")))); + m_myObject->setVariantProperty(42); + QCOMPARE(m_engine->evaluate("myObject.variantProperty") + .toVariant(), QVariant(42)); + m_myObject->setVariantProperty(qVariantFromValue(QBrush())); + QVERIFY(m_engine->evaluate("myObject.variantProperty").isVariant()); + + m_myObject->setStringProperty(QLatin1String("baz")); + QCOMPARE(m_engine->evaluate("myObject.stringProperty") + .equals(QScriptValue(m_engine, QLatin1String("baz"))), true); + m_myObject->setStringProperty(QLatin1String("zab")); + QCOMPARE(m_engine->evaluate("myObject.stringProperty") + .equals(QScriptValue(m_engine, QLatin1String("zab"))), true); + + // property change in script should be reflected in C++ + QCOMPARE(m_engine->evaluate("myObject.intProperty = 123") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + QCOMPARE(m_engine->evaluate("myObject.intProperty") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + QCOMPARE(m_myObject->intProperty(), 123); + QCOMPARE(m_engine->evaluate("myObject.intProperty = 'ciao!';" + "myObject.intProperty") + .strictlyEquals(QScriptValue(m_engine, 0)), true); + QCOMPARE(m_myObject->intProperty(), 0); + QCOMPARE(m_engine->evaluate("myObject.intProperty = '123';" + "myObject.intProperty") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + QCOMPARE(m_myObject->intProperty(), 123); + + QCOMPARE(m_engine->evaluate("myObject.stringProperty = 'ciao'") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("ciao"))), true); + QCOMPARE(m_engine->evaluate("myObject.stringProperty") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("ciao"))), true); + QCOMPARE(m_myObject->stringProperty(), QLatin1String("ciao")); + QCOMPARE(m_engine->evaluate("myObject.stringProperty = 123;" + "myObject.stringProperty") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("123"))), true); + QCOMPARE(m_myObject->stringProperty(), QLatin1String("123")); + QVERIFY(m_engine->evaluate("myObject.stringProperty = null;" + "myObject.stringProperty") + .strictlyEquals(QScriptValue(m_engine, QString()))); + QCOMPARE(m_myObject->stringProperty(), QString()); + QVERIFY(m_engine->evaluate("myObject.stringProperty = undefined;" + "myObject.stringProperty") + .strictlyEquals(QScriptValue(m_engine, QString()))); + QCOMPARE(m_myObject->stringProperty(), QString()); + + QCOMPARE(m_engine->evaluate("myObject.variantProperty = 'foo';" + "myObject.variantProperty.valueOf()").toString(), QLatin1String("foo")); + QCOMPARE(m_myObject->variantProperty(), QVariant(QLatin1String("foo"))); + QVERIFY(m_engine->evaluate("myObject.variantProperty = undefined;" + "myObject.variantProperty").isUndefined()); + QVERIFY(!m_myObject->variantProperty().isValid()); + QVERIFY(m_engine->evaluate("myObject.variantProperty = null;" + "myObject.variantProperty").isUndefined()); + QVERIFY(!m_myObject->variantProperty().isValid()); + QCOMPARE(m_engine->evaluate("myObject.variantProperty = 42;" + "myObject.variantProperty").toNumber(), 42.0); + QCOMPARE(m_myObject->variantProperty().toDouble(), 42.0); + + QCOMPARE(m_engine->evaluate("myObject.variantListProperty = [1, 'two', true];" + "myObject.variantListProperty.length") + .strictlyEquals(QScriptValue(m_engine, 3)), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty[0]") + .strictlyEquals(QScriptValue(m_engine, 1)), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty[1]") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("two"))), true); + QCOMPARE(m_engine->evaluate("myObject.variantListProperty[2]") + .strictlyEquals(QScriptValue(m_engine, true)), true); + { + QVariantList vl = qscriptvalue_cast<QVariantList>(m_engine->evaluate("myObject.variantListProperty")); + QCOMPARE(vl, QVariantList() + << QVariant(1) + << QVariant(QLatin1String("two")) + << QVariant(true)); + } + + QCOMPARE(m_engine->evaluate("myObject.stringListProperty = [1, 'two', true];" + "myObject.stringListProperty.length") + .strictlyEquals(QScriptValue(m_engine, 3)), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").isString(), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").toString(), + QLatin1String("1")); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").isString(), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").toString(), + QLatin1String("two")); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[2]").isString(), true); + QCOMPARE(m_engine->evaluate("myObject.stringListProperty[2]").toString(), + QLatin1String("true")); + { + QStringList sl = qscriptvalue_cast<QStringList>(m_engine->evaluate("myObject.stringListProperty")); + QCOMPARE(sl, QStringList() + << QLatin1String("1") + << QLatin1String("two") + << QLatin1String("true")); + } + + // test setting properties where we can't convert the type natively but where the + // types happen to be compatible variant types already + { + QKeySequence sequence(Qt::ControlModifier + Qt::AltModifier + Qt::Key_Delete); + QScriptValue mobj = m_engine->globalObject().property("myObject"); + + QVERIFY(m_myObject->shortcut().isEmpty()); + mobj.setProperty("shortcut", m_engine->newVariant(sequence)); + QVERIFY(m_myObject->shortcut() == sequence); + } + { + CustomType t; t.string = "hello"; + QScriptValue mobj = m_engine->globalObject().property("myObject"); + + QVERIFY(m_myObject->propWithCustomType().string.isEmpty()); + mobj.setProperty("propWithCustomType", m_engine->newVariant(qVariantFromValue(t))); + QVERIFY(m_myObject->propWithCustomType().string == t.string); + } + + // test that we do value conversion if necessary when setting properties + { + QScriptValue br = m_engine->evaluate("myObject.brushProperty"); + QVERIFY(br.isVariant()); + QVERIFY(!br.strictlyEquals(m_engine->evaluate("myObject.brushProperty"))); + QCOMPARE(qscriptvalue_cast<QBrush>(br), m_myObject->brushProperty()); + QCOMPARE(qscriptvalue_cast<QColor>(br), m_myObject->brushProperty().color()); + + QColor newColor(40, 30, 20, 10); + QScriptValue val = qScriptValueFromValue(m_engine, newColor); + m_engine->globalObject().setProperty("myColor", val); + QScriptValue ret = m_engine->evaluate("myObject.brushProperty = myColor"); + QCOMPARE(ret.strictlyEquals(val), true); + br = m_engine->evaluate("myObject.brushProperty"); + QCOMPARE(qscriptvalue_cast<QBrush>(br), QBrush(newColor)); + QCOMPARE(qscriptvalue_cast<QColor>(br), newColor); + + m_engine->globalObject().setProperty("myColor", QScriptValue()); + } + + // try to delete + QCOMPARE(m_engine->evaluate("delete myObject.intProperty").toBoolean(), false); + QCOMPARE(m_engine->evaluate("myObject.intProperty").toNumber(), 123.0); + + QCOMPARE(m_engine->evaluate("delete myObject.variantProperty").toBoolean(), false); + QCOMPARE(m_engine->evaluate("myObject.variantProperty").toNumber(), 42.0); + + // non-scriptable property + QCOMPARE(m_myObject->hiddenProperty(), 456.0); + QCOMPARE(m_engine->evaluate("myObject.hiddenProperty").isUndefined(), true); + QCOMPARE(m_engine->evaluate("myObject.hiddenProperty = 123;" + "myObject.hiddenProperty").toInt32(), 123); + QCOMPARE(m_myObject->hiddenProperty(), 456.0); + + // write-only property + QCOMPARE(m_myObject->writeOnlyProperty(), 789); + QCOMPARE(m_engine->evaluate("myObject.writeOnlyProperty").isUndefined(), true); + QCOMPARE(m_engine->evaluate("myObject.writeOnlyProperty = 123;" + "myObject.writeOnlyProperty").isUndefined(), true); + QCOMPARE(m_myObject->writeOnlyProperty(), 123); + + // read-only property + QCOMPARE(m_myObject->readOnlyProperty(), 987); + QCOMPARE(m_engine->evaluate("myObject.readOnlyProperty").toInt32(), 987); + QCOMPARE(m_engine->evaluate("myObject.readOnlyProperty = 654;" + "myObject.readOnlyProperty").toInt32(), 987); + QCOMPARE(m_myObject->readOnlyProperty(), 987); + { + QScriptValue mobj = m_engine->globalObject().property("myObject"); + QCOMPARE(mobj.propertyFlags("readOnlyProperty") & QScriptValue::ReadOnly, + QScriptValue::ReadOnly); + } + + // enum property + QCOMPARE(m_myObject->enumProperty(), MyQObject::BarPolicy); + { + QScriptValue val = m_engine->evaluate("myObject.enumProperty"); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), (int)MyQObject::BarPolicy); + } + m_engine->evaluate("myObject.enumProperty = 2"); + QCOMPARE(m_myObject->enumProperty(), MyQObject::BazPolicy); + m_engine->evaluate("myObject.enumProperty = 'BarPolicy'"); + QCOMPARE(m_myObject->enumProperty(), MyQObject::BarPolicy); + m_engine->evaluate("myObject.enumProperty = 'ScoobyDoo'"); + // ### ouch! Shouldn't QMetaProperty::write() rather not change the value...? + QCOMPARE(m_myObject->enumProperty(), (MyQObject::Policy)-1); + // enum property with custom conversion + qScriptRegisterMetaType<MyQObject::Policy>(m_engine, policyToScriptValue, policyFromScriptValue); + m_engine->evaluate("myObject.enumProperty = 'red'"); + QCOMPARE(m_myObject->enumProperty(), MyQObject::FooPolicy); + m_engine->evaluate("myObject.enumProperty = 'green'"); + QCOMPARE(m_myObject->enumProperty(), MyQObject::BarPolicy); + m_engine->evaluate("myObject.enumProperty = 'blue'"); + QCOMPARE(m_myObject->enumProperty(), MyQObject::BazPolicy); + m_engine->evaluate("myObject.enumProperty = 'nada'"); + QCOMPARE(m_myObject->enumProperty(), (MyQObject::Policy)-1); + + // auto-dereferencing of pointers + { + QBrush b = QColor(0xCA, 0xFE, 0xBA, 0xBE); + QBrush *bp = &b; + QScriptValue bpValue = m_engine->newVariant(qVariantFromValue(bp)); + m_engine->globalObject().setProperty("brushPointer", bpValue); + { + QScriptValue ret = m_engine->evaluate("myObject.setBrushProperty(brushPointer)"); + QCOMPARE(ret.isUndefined(), true); + QCOMPARE(qscriptvalue_cast<QBrush>(m_engine->evaluate("myObject.brushProperty")), b); + } + { + b = QColor(0xDE, 0xAD, 0xBE, 0xEF); + QScriptValue ret = m_engine->evaluate("myObject.brushProperty = brushPointer"); + QCOMPARE(ret.strictlyEquals(bpValue), true); + QCOMPARE(qscriptvalue_cast<QBrush>(m_engine->evaluate("myObject.brushProperty")), b); + } + m_engine->globalObject().setProperty("brushPointer", QScriptValue()); + } + + // try to install custom property getter+setter + { + QScriptValue mobj = m_engine->globalObject().property("myObject"); + QTest::ignoreMessage(QtWarningMsg, "QScriptValue::setProperty() failed: " + "cannot set getter or setter of native property " + "`intProperty'"); + mobj.setProperty("intProperty", m_engine->newFunction(getSetProperty), + QScriptValue::PropertyGetter | QScriptValue::PropertySetter); + } + + // method properties are persistent + { + QScriptValue slot = m_engine->evaluate("myObject.mySlot"); + QVERIFY(slot.isFunction()); + QScriptValue sameSlot = m_engine->evaluate("myObject.mySlot"); + QVERIFY(sameSlot.strictlyEquals(slot)); + sameSlot = m_engine->evaluate("myObject['mySlot()']"); + QEXPECT_FAIL("", "Signature-based method lookup creates new function wrapper object", Continue); + QVERIFY(sameSlot.strictlyEquals(slot)); + } +} + +void tst_QScriptExtQObject::getSetDynamicProperty() +{ + // initially the object does not have the property + QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('dynamicProperty')") + .strictlyEquals(QScriptValue(m_engine, false)), true); + + // add a dynamic property in C++ + QCOMPARE(m_myObject->setProperty("dynamicProperty", 123), false); + QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('dynamicProperty')") + .strictlyEquals(QScriptValue(m_engine, true)), true); + QCOMPARE(m_engine->evaluate("myObject.dynamicProperty") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + + // check the flags + { + QScriptValue mobj = m_engine->globalObject().property("myObject"); + QVERIFY(!(mobj.propertyFlags("dynamicProperty") & QScriptValue::ReadOnly)); + QVERIFY(!(mobj.propertyFlags("dynamicProperty") & QScriptValue::Undeletable)); + QVERIFY(!(mobj.propertyFlags("dynamicProperty") & QScriptValue::SkipInEnumeration)); + QVERIFY(mobj.propertyFlags("dynamicProperty") & QScriptValue::QObjectMember); + } + + // property change in script should be reflected in C++ + QCOMPARE(m_engine->evaluate("myObject.dynamicProperty = 'foo';" + "myObject.dynamicProperty") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("foo"))), true); + QCOMPARE(m_myObject->property("dynamicProperty").toString(), QLatin1String("foo")); + + // delete the property + QCOMPARE(m_engine->evaluate("delete myObject.dynamicProperty").toBoolean(), true); + QCOMPARE(m_myObject->property("dynamicProperty").isValid(), false); + QCOMPARE(m_engine->evaluate("myObject.dynamicProperty").isUndefined(), true); + QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('dynamicProperty')").toBoolean(), false); +} + +void tst_QScriptExtQObject::getSetChildren() +{ + // initially the object does not have the child + QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')") + .strictlyEquals(QScriptValue(m_engine, false)), true); + + // add a child + MyQObject *child = new MyQObject(m_myObject); + child->setObjectName("child"); + QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')") + .strictlyEquals(QScriptValue(m_engine, true)), true); + + QScriptValue mobj = m_engine->evaluate("myObject"); + QVERIFY(mobj.propertyFlags("child") & QScriptValue::ReadOnly); + QVERIFY(mobj.propertyFlags("child") & QScriptValue::Undeletable); + QVERIFY(mobj.propertyFlags("child") & QScriptValue::SkipInEnumeration); + QVERIFY(!(mobj.propertyFlags("child") & QScriptValue::QObjectMember)); + + { + QScriptValue scriptChild = m_engine->evaluate("myObject.child"); + QVERIFY(scriptChild.isQObject()); + QCOMPARE(scriptChild.toQObject(), (QObject*)child); + QScriptValue sameChild = m_engine->evaluate("myObject.child"); + QVERIFY(sameChild.strictlyEquals(scriptChild)); + } + + // add a grandchild + MyQObject *grandChild = new MyQObject(child); + grandChild->setObjectName("grandChild"); + QCOMPARE(m_engine->evaluate("myObject.child.hasOwnProperty('grandChild')") + .strictlyEquals(QScriptValue(m_engine, true)), true); + + // delete grandchild + delete grandChild; + QCOMPARE(m_engine->evaluate("myObject.child.hasOwnProperty('grandChild')") + .strictlyEquals(QScriptValue(m_engine, false)), true); + + // delete child + delete child; + QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')") + .strictlyEquals(QScriptValue(m_engine, false)), true); + +} + +Q_DECLARE_METATYPE(QVector<int>) +Q_DECLARE_METATYPE(QVector<double>) +Q_DECLARE_METATYPE(QVector<QString>) + +template <class T> +static QScriptValue qobjectToScriptValue(QScriptEngine *engine, T* const &in) +{ return engine->newQObject(in); } + +template <class T> +static void qobjectFromScriptValue(const QScriptValue &object, T* &out) +{ out = qobject_cast<T*>(object.toQObject()); } + +void tst_QScriptExtQObject::callQtInvokable() +{ + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokable()").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 0); + QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList()); + + // extra arguments should silently be ignored + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokable(10, 20, 30)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 0); + QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList()); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArg('123')").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithLonglongArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 2); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toLongLong(), qlonglong(123)); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithFloatArg(123.5)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 3); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toDouble(), 123.5); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithDoubleArg(123.5)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 4); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toDouble(), 123.5); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithStringArg('ciao')").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 5); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QLatin1String("ciao")); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithStringArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 5); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QLatin1String("123")); + + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableWithStringArg(null)").isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 5); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).type(), QVariant::String); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QString()); + + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableWithStringArg(undefined)").isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 5); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).type(), QVariant::String); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QString()); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArgs(123, 456)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 6); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 2); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + QCOMPARE(m_myObject->qtFunctionActuals().at(1).toInt(), 456); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningInt()") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 7); + QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList()); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningLongLong()") + .strictlyEquals(QScriptValue(m_engine, 456)), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 39); + QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList()); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningString()") + .strictlyEquals(QScriptValue(m_engine, QLatin1String("ciao"))), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 8); + QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList()); + + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableReturningVariant()") + .strictlyEquals(QScriptValue(m_engine, 123))); + QCOMPARE(m_myObject->qtFunctionInvoked(), 60); + + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableReturningScriptValue()") + .strictlyEquals(QScriptValue(m_engine, 456))); + QCOMPARE(m_myObject->qtFunctionInvoked(), 61); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArg(123, 456)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 9); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 2); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + QCOMPARE(m_myObject->qtFunctionActuals().at(1).toInt(), 456); + + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableWithVoidStarArg(null)").isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 44); + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableWithVoidStarArg(123)").isError()); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithAmbiguousArg(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: ambiguous call of overloaded function myInvokableWithAmbiguousArg(); candidates were\n myInvokableWithAmbiguousArg(int)\n myInvokableWithAmbiguousArg(uint)")); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithDefaultArgs(123, 'hello')"); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 47); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 2); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + QCOMPARE(m_myObject->qtFunctionActuals().at(1).toString(), QLatin1String("hello")); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithDefaultArgs(456)"); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 47); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 2); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 456); + QCOMPARE(m_myObject->qtFunctionActuals().at(1).toString(), QString()); + } + + { + QScriptValue fun = m_engine->evaluate("myObject.myInvokableWithPointArg"); + QVERIFY(fun.isFunction()); + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = fun.call(m_engine->evaluate("myObject"), + QScriptValueList() << qScriptValueFromValue(m_engine, QPoint(10, 20))); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 50); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toPoint(), QPoint(10, 20)); + } + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = fun.call(m_engine->evaluate("myObject"), + QScriptValueList() << qScriptValueFromValue(m_engine, QPointF(30, 40))); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 51); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toPointF(), QPointF(30, 40)); + } + } + + // calling function that returns (const)ref + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningRef()"); + QVERIFY(ret.isUndefined()); + QVERIFY(!m_engine->hasUncaughtException()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 48); + } + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningConstRef()"); + QVERIFY(ret.isUndefined()); + QVERIFY(!m_engine->hasUncaughtException()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 49); + } + + // first time we expect failure because the metatype is not registered + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningVectorOfInt()").isError(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithVectorOfIntArg(0)").isError(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + + // now we register it, and it should work + qScriptRegisterSequenceMetaType<QVector<int> >(m_engine); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningVectorOfInt()"); + QCOMPARE(ret.isArray(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 11); + } + + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVectorOfIntArg(myObject.myInvokableReturningVectorOfInt())"); + QCOMPARE(ret.isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 12); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningQObjectStar()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 13); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 0); + QCOMPARE(ret.isQObject(), true); + QCOMPARE(ret.toQObject(), (QObject *)m_myObject); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQObjectListArg([myObject])"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 14); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(ret.isArray(), true); + QCOMPARE(ret.property(QLatin1String("length")) + .strictlyEquals(QScriptValue(m_engine, 1)), true); + QCOMPARE(ret.property(QLatin1String("0")).isQObject(), true); + QCOMPARE(ret.property(QLatin1String("0")).toQObject(), (QObject *)m_myObject); + } + + m_myObject->resetQtFunctionInvoked(); + { + m_myObject->setVariantProperty(QVariant(123)); + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg(myObject.variantProperty)"); + QVERIFY(ret.isNumber()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 15); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0), m_myObject->variantProperty()); + QVERIFY(ret.strictlyEquals(QScriptValue(m_engine, 123))); + } + + m_myObject->resetQtFunctionInvoked(); + { + m_myObject->setVariantProperty(qVariantFromValue(QBrush())); + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg(myObject.variantProperty)"); + QVERIFY(ret.isVariant()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 15); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(ret.toVariant(), m_myObject->qtFunctionActuals().at(0)); + QCOMPARE(ret.toVariant(), m_myObject->variantProperty()); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg(123)"); + QVERIFY(ret.isNumber()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 15); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0), QVariant(123)); + QVERIFY(ret.strictlyEquals(QScriptValue(m_engine, 123))); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg('ciao')"); + QVERIFY(ret.isString()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 15); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0), QVariant(QString::fromLatin1("ciao"))); + QVERIFY(ret.strictlyEquals(QScriptValue(m_engine, QString::fromLatin1("ciao")))); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg(null)"); + QVERIFY(ret.isUndefined()); // invalid QVariant is converted to Undefined + QCOMPARE(m_myObject->qtFunctionInvoked(), 15); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0), QVariant()); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg(undefined)"); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 15); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0), QVariant()); + } + + m_engine->globalObject().setProperty("fishy", m_engine->newVariant(123)); + m_engine->evaluate("myObject.myInvokableWithStringArg(fishy)"); + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantMapArg({ a:123, b:'ciao' })"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 16); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QVariant v = m_myObject->qtFunctionActuals().at(0); + QCOMPARE(v.userType(), int(QMetaType::QVariantMap)); + QVariantMap vmap = qvariant_cast<QVariantMap>(v); + QCOMPARE(vmap.keys().size(), 2); + QCOMPARE(vmap.keys().at(0), QLatin1String("a")); + QCOMPARE(vmap.value("a"), QVariant(123)); + QCOMPARE(vmap.keys().at(1), QLatin1String("b")); + QCOMPARE(vmap.value("b"), QVariant("ciao")); + + QCOMPARE(ret.isObject(), true); + QCOMPARE(ret.property("a").strictlyEquals(QScriptValue(m_engine, 123)), true); + QCOMPARE(ret.property("b").strictlyEquals(QScriptValue(m_engine, "ciao")), true); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithListOfIntArg([1, 5])"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 17); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QVariant v = m_myObject->qtFunctionActuals().at(0); + QCOMPARE(v.userType(), qMetaTypeId<QList<int> >()); + QList<int> ilst = qvariant_cast<QList<int> >(v); + QCOMPARE(ilst.size(), 2); + QCOMPARE(ilst.at(0), 1); + QCOMPARE(ilst.at(1), 5); + + QCOMPARE(ret.isArray(), true); + QCOMPARE(ret.property("0").strictlyEquals(QScriptValue(m_engine, 1)), true); + QCOMPARE(ret.property("1").strictlyEquals(QScriptValue(m_engine, 5)), true); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQObjectStarArg(myObject)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 18); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QVariant v = m_myObject->qtFunctionActuals().at(0); + QCOMPARE(v.userType(), int(QMetaType::QObjectStar)); + QCOMPARE(qvariant_cast<QObject*>(v), (QObject *)m_myObject); + + QCOMPARE(ret.isQObject(), true); + QCOMPARE(qscriptvalue_cast<QObject*>(ret), (QObject *)m_myObject); + } + + m_myObject->resetQtFunctionInvoked(); + { + // no implicit conversion from integer to QObject* + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQObjectStarArg(123)"); + QCOMPARE(ret.isError(), true); + } + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue fun = m_engine->evaluate("myObject.myInvokableWithQBrushArg"); + QVERIFY(fun.isFunction()); + QColor color(10, 20, 30, 40); + // QColor should be converted to a QBrush + QScriptValue ret = fun.call(QScriptValue(), QScriptValueList() + << qScriptValueFromValue(m_engine, color)); + QCOMPARE(m_myObject->qtFunctionInvoked(), 19); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QVariant v = m_myObject->qtFunctionActuals().at(0); + QCOMPARE(v.userType(), int(QMetaType::QBrush)); + QCOMPARE(qvariant_cast<QColor>(v), color); + + QCOMPARE(qscriptvalue_cast<QColor>(ret), color); + } + + // private slots should not be part of the QObject binding + QCOMPARE(m_engine->evaluate("myObject.myPrivateSlot").isUndefined(), true); + + // protected slots should be fine + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myProtectedSlot()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 36); + + // call with too few arguments + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithIntArg()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("SyntaxError: too few arguments in call to myInvokableWithIntArg(); candidates are\n myInvokableWithIntArg(int,int)\n myInvokableWithIntArg(int)")); + } + + // call function where not all types have been registered + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithBrushStyleArg(0)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: cannot call myInvokableWithBrushStyleArg(): argument 1 has unknown type `Qt::BrushStyle' (register the type with qScriptRegisterMetaType())")); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + } + + // call function with incompatible argument type + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQBrushArg(null)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: incompatible type of argument(s) in call to myInvokableWithQBrushArg(); candidates were\n myInvokableWithQBrushArg(QBrush)")); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + } + + // ability to call a slot with QObject-based arguments, even if those types haven't been registered + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithMyQObjectArg(myObject)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 52); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(qvariant_cast<QObject*>(m_myObject->qtFunctionActuals().at(0)), (QObject*)m_myObject); + } + + // inability to call a slot returning QObject-based type, when that type hasn't been registered + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningMyQObject()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: cannot call myInvokableReturningMyQObject(): unknown return type `MyQObject*' (register the type with qScriptRegisterMetaType())")); + } + + // ability to call a slot returning QObject-based type when that type has been registered + qRegisterMetaType<MyQObject*>("MyQObject*"); + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningMyQObject()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 53); + QVERIFY(ret.isVariant()); + QCOMPARE(*reinterpret_cast<MyQObject* const *>(ret.toVariant().constData()), m_myObject); + } + + // ability to call a slot with QObject-based argument, when the argument is const + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithConstMyQObjectArg(myObject)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 54); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(qvariant_cast<QObject*>(m_myObject->qtFunctionActuals().at(0)), (QObject*)m_myObject); + } + + // QScriptValue arguments should be passed on without conversion + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithScriptValueArg(123)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 56); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithScriptValueArg('ciao')"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 56); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("ciao")); + } + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithScriptValueArg(this)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 56); + QVERIFY(ret.isObject()); + QVERIFY(ret.strictlyEquals(m_engine->globalObject())); + } + + // the prototype specified by a conversion function should not be "down-graded" + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue qobjectProto = m_engine->newObject(); + qScriptRegisterMetaType<QObject*>(m_engine, qobjectToScriptValue, + qobjectFromScriptValue, qobjectProto); + QScriptValue myQObjectProto = m_engine->newObject(); + myQObjectProto.setPrototype(qobjectProto); + qScriptRegisterMetaType<MyQObject*>(m_engine, qobjectToScriptValue, + qobjectFromScriptValue, myQObjectProto); + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningMyQObjectAsQObject()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 57); + QVERIFY(ret.isQObject()); + QVERIFY(ret.prototype().strictlyEquals(myQObjectProto)); + + qScriptRegisterMetaType<QObject*>(m_engine, 0, 0, QScriptValue()); + qScriptRegisterMetaType<MyQObject*>(m_engine, 0, 0, QScriptValue()); + } + + // detect exceptions during argument conversion + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue (*dummy)(QScriptEngine *, const QDir &) = 0; + qScriptRegisterMetaType<QDir>(m_engine, dummy, dirFromScript); + { + QVERIFY(!m_engine->hasUncaughtException()); + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQDirArg({})"); + QVERIFY(m_engine->hasUncaughtException()); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("Error: No path")); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + } + m_engine->clearExceptions(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQDirArg({path:'.'})"); + QVERIFY(!m_engine->hasUncaughtException()); + QVERIFY(ret.isUndefined()); + QCOMPARE(m_myObject->qtFunctionInvoked(), 55); + } + } + + // qscript_call() + { + m_myObject->resetQtFunctionInvoked(); + QScriptValue ret = m_engine->evaluate("new myObject(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: myObject is not a constructor")); + } + { + m_myObject->resetQtFunctionInvoked(); + QScriptValue ret = m_engine->evaluate("myObject(123)"); + QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: myObject is not a function")); + } + + // task 233624 + { + MyNS::A a; + m_engine->globalObject().setProperty("anObject", m_engine->newQObject(&a)); + QScriptValue ret = m_engine->evaluate("anObject.slotTakingScopedEnumArg(1)"); + QVERIFY(!ret.isError()); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 1); + m_engine->globalObject().setProperty("anObject", QScriptValue()); + } + + // virtual slot redeclared in subclass (task 236467) + { + MyOtherQObject moq; + m_engine->globalObject().setProperty("myOtherQObject", m_engine->newQObject(&moq)); + moq.resetQtFunctionInvoked(); + QScriptValue ret = m_engine->evaluate("myOtherQObject.myVirtualSlot(123)"); + QCOMPARE(moq.qtFunctionInvoked(), 59); + QVERIFY(!ret.isError()); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } +} + +void tst_QScriptExtQObject::connectAndDisconnect() +{ + // connect(function) + QCOMPARE(m_engine->evaluate("myObject.mySignal.connect(123)").isError(), true); + + m_engine->evaluate("myHandler = function() { global.gotSignal = true; global.signalArgs = arguments; global.slotThisObject = this; global.signalSender = __qt_sender__; }"); + + m_myObject->clearConnectedSignal(); + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myHandler)").isUndefined()); + QCOMPARE(m_myObject->connectedSignal().constData(), SIGNAL(mySignal())); + + m_engine->evaluate("gotSignal = false"); + m_engine->evaluate("myObject.mySignal()"); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 0.0); + QCOMPARE(m_engine->evaluate("signalSender").toQObject(), (QObject *)m_myObject); + QVERIFY(m_engine->evaluate("slotThisObject").strictlyEquals(m_engine->globalObject())); + + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal(); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 0.0); + + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.connect(myHandler)").isUndefined()); + + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignalWithIntArg(123); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QCOMPARE(m_engine->evaluate("signalArgs[0]").toNumber(), 123.0); + + m_myObject->clearDisconnectedSignal(); + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(myHandler)").isUndefined()); + QCOMPARE(m_myObject->disconnectedSignal().constData(), SIGNAL(mySignal())); + + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(myHandler)").isError()); + + QVERIFY(m_engine->evaluate("myObject.mySignal2.connect(myHandler)").isUndefined()); + + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal2(false); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QCOMPARE(m_engine->evaluate("signalArgs[0]").toBoolean(), false); + + m_engine->evaluate("gotSignal = false"); + QVERIFY(m_engine->evaluate("myObject.mySignal2.connect(myHandler)").isUndefined()); + m_myObject->emitMySignal2(true); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QCOMPARE(m_engine->evaluate("signalArgs[0]").toBoolean(), true); + + QVERIFY(m_engine->evaluate("myObject.mySignal2.disconnect(myHandler)").isUndefined()); + + QVERIFY(m_engine->evaluate("myObject['mySignal2()'].connect(myHandler)").isUndefined()); + + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal2(); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + + QVERIFY(m_engine->evaluate("myObject['mySignal2()'].disconnect(myHandler)").isUndefined()); + + // connecting to signal with default args should pick the most generic version (i.e. with all args) + QVERIFY(m_engine->evaluate("myObject.mySignalWithDefaultArg.connect(myHandler)").isUndefined()); + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignalWithDefaultArgWithArg(456); + QVERIFY(m_engine->evaluate("gotSignal").toBoolean()); + QCOMPARE(m_engine->evaluate("signalArgs.length").toInt32(), 1); + QCOMPARE(m_engine->evaluate("signalArgs[0]").toInt32(), 456); + + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignalWithDefaultArg(); + QVERIFY(m_engine->evaluate("gotSignal").toBoolean()); + QCOMPARE(m_engine->evaluate("signalArgs.length").toInt32(), 1); + QCOMPARE(m_engine->evaluate("signalArgs[0]").toInt32(), 123); + + QVERIFY(m_engine->evaluate("myObject.mySignalWithDefaultArg.disconnect(myHandler)").isUndefined()); + + m_engine->evaluate("gotSignal = false"); + // connecting to overloaded signal should throw an error + { + QScriptValue ret = m_engine->evaluate("myObject.myOverloadedSignal.connect(myHandler)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("Error: Function.prototype.connect: ambiguous connect to MyQObject::myOverloadedSignal(); candidates are\n" + " myOverloadedSignal(int)\n" + " myOverloadedSignal(QString)\n" + "Use e.g. object['myOverloadedSignal(QString)'].connect() to connect to a particular overload")); + } + m_myObject->emitMyOverloadedSignal(123); + QVERIFY(!m_engine->evaluate("gotSignal").toBoolean()); + m_myObject->emitMyOverloadedSignal("ciao"); + QVERIFY(!m_engine->evaluate("gotSignal").toBoolean()); + + m_engine->evaluate("gotSignal = false"); + { + QScriptValue ret = m_engine->evaluate("myObject.myOtherOverloadedSignal.connect(myHandler)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("Error: Function.prototype.connect: ambiguous connect to MyQObject::myOtherOverloadedSignal(); candidates are\n" + " myOtherOverloadedSignal(QString)\n" + " myOtherOverloadedSignal(int)\n" + "Use e.g. object['myOtherOverloadedSignal(int)'].connect() to connect to a particular overload")); + } + m_myObject->emitMyOtherOverloadedSignal("ciao"); + QVERIFY(!m_engine->evaluate("gotSignal").toBoolean()); + m_myObject->emitMyOtherOverloadedSignal(123); + QVERIFY(!m_engine->evaluate("gotSignal").toBoolean()); + + // signal with QVariant arg: argument conversion should work + m_myObject->clearConnectedSignal(); + QVERIFY(m_engine->evaluate("myObject.mySignalWithVariantArg.connect(myHandler)").isUndefined()); + QCOMPARE(m_myObject->connectedSignal().constData(), SIGNAL(mySignalWithVariantArg(QVariant))); + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignalWithVariantArg(123); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QCOMPARE(m_engine->evaluate("signalArgs[0]").toNumber(), 123.0); + QVERIFY(m_engine->evaluate("myObject.mySignalWithVariantArg.disconnect(myHandler)").isUndefined()); + + // signal with argument type that's unknown to the meta-type system + m_myObject->clearConnectedSignal(); + QVERIFY(m_engine->evaluate("myObject.mySignalWithScriptEngineArg.connect(myHandler)").isUndefined()); + QCOMPARE(m_myObject->connectedSignal().constData(), SIGNAL(mySignalWithScriptEngineArg(QScriptEngine*))); + m_engine->evaluate("gotSignal = false"); + QTest::ignoreMessage(QtWarningMsg, "QScriptEngine: Unable to handle unregistered datatype 'QScriptEngine*' when invoking handler of signal MyQObject::mySignalWithScriptEngineArg(QScriptEngine*)"); + m_myObject->emitMySignalWithScriptEngineArg(m_engine); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QVERIFY(m_engine->evaluate("signalArgs[0]").isUndefined()); + QVERIFY(m_engine->evaluate("myObject.mySignalWithScriptEngineArg.disconnect(myHandler)").isUndefined()); + + // connect(object, function) + m_engine->evaluate("otherObject = { name:'foo' }"); + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(otherObject, myHandler)").isUndefined()); + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(otherObject, myHandler)").isUndefined()); + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal(); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), false); + + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(otherObject, myHandler)").isError()); + + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(otherObject, myHandler)").isUndefined()); + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal(); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 0.0); + QVERIFY(m_engine->evaluate("slotThisObject").strictlyEquals(m_engine->evaluate("otherObject"))); + QVERIFY(m_engine->evaluate("signalSender").strictlyEquals(m_engine->evaluate("myObject"))); + QCOMPARE(m_engine->evaluate("slotThisObject").property("name").toString(), QLatin1String("foo")); + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(otherObject, myHandler)").isUndefined()); + + m_engine->evaluate("yetAnotherObject = { name:'bar', func : function() { } }"); + QVERIFY(m_engine->evaluate("myObject.mySignal2.connect(yetAnotherObject, myHandler)").isUndefined()); + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal2(true); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QVERIFY(m_engine->evaluate("slotThisObject").strictlyEquals(m_engine->evaluate("yetAnotherObject"))); + QVERIFY(m_engine->evaluate("signalSender").strictlyEquals(m_engine->evaluate("myObject"))); + QCOMPARE(m_engine->evaluate("slotThisObject").property("name").toString(), QLatin1String("bar")); + QVERIFY(m_engine->evaluate("myObject.mySignal2.disconnect(yetAnotherObject, myHandler)").isUndefined()); + + QVERIFY(m_engine->evaluate("myObject.mySignal2.connect(myObject, myHandler)").isUndefined()); + m_engine->evaluate("gotSignal = false"); + m_myObject->emitMySignal2(true); + QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true); + QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0); + QCOMPARE(m_engine->evaluate("slotThisObject").toQObject(), (QObject *)m_myObject); + QVERIFY(m_engine->evaluate("signalSender").strictlyEquals(m_engine->evaluate("myObject"))); + QVERIFY(m_engine->evaluate("myObject.mySignal2.disconnect(myObject, myHandler)").isUndefined()); + + // connect(obj, string) + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(yetAnotherObject, 'func')").isUndefined()); + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myObject, 'mySlot')").isUndefined()); + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(yetAnotherObject, 'func')").isUndefined()); + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(myObject, 'mySlot')").isUndefined()); + + // check that emitting signals from script works + + // no arguments + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myObject.mySlot)").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.mySignal()").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 20); + QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(myObject.mySlot)").isUndefined()); + + // one argument + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.connect(myObject.mySlotWithIntArg)").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.mySignalWithIntArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 21); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myObject.mySlotWithIntArg)").isUndefined()); + + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.connect(myObject.mySlotWithDoubleArg)").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.mySignalWithIntArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 22); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toDouble(), 123.0); + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myObject.mySlotWithDoubleArg)").isUndefined()); + + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.connect(myObject.mySlotWithStringArg)").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.mySignalWithIntArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 23); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QLatin1String("123")); + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myObject.mySlotWithStringArg)").isUndefined()); + + // connecting to overloaded slot + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.connect(myObject.myOverloadedSlot)").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.mySignalWithIntArg(123)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 26); // double overload + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123); + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myObject.myOverloadedSlot)").isUndefined()); + + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.connect(myObject['myOverloadedSlot(int)'])").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.mySignalWithIntArg(456)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 28); // int overload + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 456); + QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myObject['myOverloadedSlot(int)'])").isUndefined()); + + // erroneous input + { + QScriptValue ret = m_engine->evaluate("(function() { }).connect()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: Function.prototype.connect: no arguments given")); + } + { + QScriptValue ret = m_engine->evaluate("var o = { }; o.connect = Function.prototype.connect; o.connect()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: Function.prototype.connect: no arguments given")); + } + + { + QScriptValue ret = m_engine->evaluate("(function() { }).connect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.connect: this object is not a signal")); + } + { + QScriptValue ret = m_engine->evaluate("var o = { }; o.connect = Function.prototype.connect; o.connect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.connect: this object is not a signal")); + } + + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokable.connect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.connect: MyQObject::myInvokable() is not a signal")); + } + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokable.connect(function() { })"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.connect: MyQObject::myInvokable() is not a signal")); + } + + { + QScriptValue ret = m_engine->evaluate("myObject.mySignal.connect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.connect: target is not a function")); + } + + { + QScriptValue ret = m_engine->evaluate("(function() { }).disconnect()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: Function.prototype.disconnect: no arguments given")); + } + { + QScriptValue ret = m_engine->evaluate("var o = { }; o.disconnect = Function.prototype.disconnect; o.disconnect()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: Function.prototype.disconnect: no arguments given")); + } + + { + QScriptValue ret = m_engine->evaluate("(function() { }).disconnect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.disconnect: this object is not a signal")); + } + { + QScriptValue ret = m_engine->evaluate("var o = { }; o.disconnect = Function.prototype.disconnect; o.disconnect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.disconnect: this object is not a signal")); + } + + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokable.disconnect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.disconnect: MyQObject::myInvokable() is not a signal")); + } + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokable.disconnect(function() { })"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.disconnect: MyQObject::myInvokable() is not a signal")); + } + + { + QScriptValue ret = m_engine->evaluate("myObject.mySignal.disconnect(123)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: Function.prototype.disconnect: target is not a function")); + } + + { + QScriptValue ret = m_engine->evaluate("myObject.mySignal.disconnect(function() { })"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: Function.prototype.disconnect: failed to disconnect from MyQObject::mySignal()")); + } + + // when the wrapper dies, the connection stays alive + QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myObject.mySlot)").isUndefined()); + m_myObject->resetQtFunctionInvoked(); + m_myObject->emitMySignal(); + QCOMPARE(m_myObject->qtFunctionInvoked(), 20); + m_engine->evaluate("myObject = null"); + m_engine->collectGarbage(); + m_myObject->resetQtFunctionInvoked(); + m_myObject->emitMySignal(); + QCOMPARE(m_myObject->qtFunctionInvoked(), 20); +} + +void tst_QScriptExtQObject::cppConnectAndDisconnect() +{ + QScriptEngine eng; + QLineEdit edit; + QLineEdit edit2; + QScriptValue fun = eng.evaluate("function fun(text) { signalObject = this; signalArg = text; }; fun"); + QVERIFY(fun.isFunction()); + for (int z = 0; z < 2; ++z) { + QScriptValue receiver; + if (z == 0) + receiver = QScriptValue(); + else + receiver = eng.newObject(); + for (int y = 0; y < 2; ++y) { + QVERIFY(qScriptConnect(&edit, SIGNAL(textChanged(const QString &)), receiver, fun)); + QVERIFY(qScriptConnect(&edit2, SIGNAL(textChanged(const QString &)), receiver, fun)); + // check signal emission + for (int x = 0; x < 4; ++x) { + QLineEdit *ed = (x < 2) ? &edit : &edit2; + ed->setText((x % 2) ? "foo" : "bar"); + { + QScriptValue ret = eng.globalObject().property("signalObject"); + if (receiver.isObject()) + QVERIFY(ret.strictlyEquals(receiver)); + else + QVERIFY(ret.strictlyEquals(eng.globalObject())); + } + { + QScriptValue ret = eng.globalObject().property("signalArg"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), ed->text()); + } + eng.collectGarbage(); + } + + // check disconnect + QVERIFY(qScriptDisconnect(&edit, SIGNAL(textChanged(const QString &)), receiver, fun)); + eng.globalObject().setProperty("signalObject", QScriptValue()); + eng.globalObject().setProperty("signalArg", QScriptValue()); + edit.setText("something else"); + QVERIFY(!eng.globalObject().property("signalObject").isValid()); + QVERIFY(!eng.globalObject().property("signalArg").isValid()); + QVERIFY(!qScriptDisconnect(&edit, SIGNAL(textChanged(const QString &)), receiver, fun)); + + // other object's connection should remain + edit2.setText(edit.text()); + { + QScriptValue ret = eng.globalObject().property("signalObject"); + if (receiver.isObject()) + QVERIFY(ret.strictlyEquals(receiver)); + else + QVERIFY(ret.strictlyEquals(eng.globalObject())); + } + { + QScriptValue ret = eng.globalObject().property("signalArg"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), edit2.text()); + } + + // disconnect other object too + QVERIFY(qScriptDisconnect(&edit2, SIGNAL(textChanged(const QString &)), receiver, fun)); + eng.globalObject().setProperty("signalObject", QScriptValue()); + eng.globalObject().setProperty("signalArg", QScriptValue()); + edit2.setText("even more different"); + QVERIFY(!eng.globalObject().property("signalObject").isValid()); + QVERIFY(!eng.globalObject().property("signalArg").isValid()); + QVERIFY(!qScriptDisconnect(&edit2, SIGNAL(textChanged(const QString &)), receiver, fun)); + } + } + + // make sure we don't crash when engine is deleted + { + QScriptEngine *eng2 = new QScriptEngine; + QScriptValue fun2 = eng2->evaluate("function(text) { signalObject = this; signalArg = text; }"); + QVERIFY(qScriptConnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun2)); + delete eng2; + edit.setText("ciao"); + QVERIFY(!qScriptDisconnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun2)); + } + + // mixing script-side and C++-side connect + { + eng.globalObject().setProperty("edit", eng.newQObject(&edit)); + QVERIFY(eng.evaluate("edit.textChanged.connect(fun)").isUndefined()); + QVERIFY(qScriptDisconnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun)); + + QVERIFY(qScriptConnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun)); + QVERIFY(eng.evaluate("edit.textChanged.disconnect(fun)").isUndefined()); + } + + // signalHandlerException() + { + connect(&eng, SIGNAL(signalHandlerException(QScriptValue)), + this, SLOT(onSignalHandlerException(QScriptValue))); + + eng.globalObject().setProperty("edit", eng.newQObject(&edit)); + QScriptValue fun = eng.evaluate("function() { nonExistingFunction(); }"); + QVERIFY(qScriptConnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun)); + + m_signalHandlerException = QScriptValue(); + QScriptValue ret = eng.evaluate("edit.text = 'trigger a signal handler exception from script'"); + QVERIFY(ret.isError()); + QVERIFY(m_signalHandlerException.strictlyEquals(ret)); + + m_signalHandlerException = QScriptValue(); + edit.setText("trigger a signal handler exception from C++"); + QVERIFY(m_signalHandlerException.isError()); + + QVERIFY(qScriptDisconnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun)); + + m_signalHandlerException = QScriptValue(); + eng.evaluate("edit.text = 'no more exception from script'"); + QVERIFY(!m_signalHandlerException.isValid()); + edit.setText("no more exception from C++"); + QVERIFY(!m_signalHandlerException.isValid()); + + disconnect(&eng, SIGNAL(signalHandlerException(QScriptValue)), + this, SLOT(onSignalHandlerException(QScriptValue))); + } + + // check that connectNotify() and disconnectNotify() are called (task 232987) + { + m_myObject->clearConnectedSignal(); + QVERIFY(qScriptConnect(m_myObject, SIGNAL(mySignal()), QScriptValue(), fun)); + QCOMPARE(m_myObject->connectedSignal().constData(), SIGNAL(mySignal())); + + m_myObject->clearDisconnectedSignal(); + QVERIFY(qScriptDisconnect(m_myObject, SIGNAL(mySignal()), QScriptValue(), fun)); + QCOMPARE(m_myObject->disconnectedSignal().constData(), SIGNAL(mySignal())); + } + + // bad args + QVERIFY(!qScriptConnect(0, SIGNAL(foo()), QScriptValue(), fun)); + QVERIFY(!qScriptConnect(&edit, 0, QScriptValue(), fun)); + QVERIFY(!qScriptConnect(&edit, SIGNAL(foo()), QScriptValue(), fun)); + QVERIFY(!qScriptConnect(&edit, SIGNAL(textChanged(QString)), QScriptValue(), QScriptValue())); + QVERIFY(!qScriptDisconnect(0, SIGNAL(foo()), QScriptValue(), fun)); + QVERIFY(!qScriptDisconnect(&edit, 0, QScriptValue(), fun)); + QVERIFY(!qScriptDisconnect(&edit, SIGNAL(foo()), QScriptValue(), fun)); + QVERIFY(!qScriptDisconnect(&edit, SIGNAL(textChanged(QString)), QScriptValue(), QScriptValue())); + { + QScriptEngine eng2; + QScriptValue receiverInDifferentEngine = eng2.newObject(); + QVERIFY(!qScriptConnect(&edit, SIGNAL(textChanged(QString)), receiverInDifferentEngine, fun)); + QVERIFY(!qScriptDisconnect(&edit, SIGNAL(textChanged(QString)), receiverInDifferentEngine, fun)); + } +} + +void tst_QScriptExtQObject::classEnums() +{ + QScriptValue myClass = m_engine->newQMetaObject(m_myObject->metaObject(), m_engine->undefinedValue()); + m_engine->globalObject().setProperty("MyQObject", myClass); + + QCOMPARE(static_cast<MyQObject::Policy>(m_engine->evaluate("MyQObject.FooPolicy").toInt32()), + MyQObject::FooPolicy); + QCOMPARE(static_cast<MyQObject::Policy>(m_engine->evaluate("MyQObject.BarPolicy").toInt32()), + MyQObject::BarPolicy); + QCOMPARE(static_cast<MyQObject::Policy>(m_engine->evaluate("MyQObject.BazPolicy").toInt32()), + MyQObject::BazPolicy); + + QCOMPARE(static_cast<MyQObject::Strategy>(m_engine->evaluate("MyQObject.FooStrategy").toInt32()), + MyQObject::FooStrategy); + QCOMPARE(static_cast<MyQObject::Strategy>(m_engine->evaluate("MyQObject.BarStrategy").toInt32()), + MyQObject::BarStrategy); + QCOMPARE(static_cast<MyQObject::Strategy>(m_engine->evaluate("MyQObject.BazStrategy").toInt32()), + MyQObject::BazStrategy); + + QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.NoAbility").toInt32()), + MyQObject::NoAbility); + QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.FooAbility").toInt32()), + MyQObject::FooAbility); + QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.BarAbility").toInt32()), + MyQObject::BarAbility); + QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.BazAbility").toInt32()), + MyQObject::BazAbility); + QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.AllAbility").toInt32()), + MyQObject::AllAbility); + + QScriptValue::PropertyFlags expectedEnumFlags = QScriptValue::ReadOnly | QScriptValue::Undeletable; + QCOMPARE(myClass.propertyFlags("FooPolicy"), expectedEnumFlags); + QCOMPARE(myClass.propertyFlags("BarPolicy"), expectedEnumFlags); + QCOMPARE(myClass.propertyFlags("BazPolicy"), expectedEnumFlags); + + // enums from Qt are inherited through prototype + QCOMPARE(static_cast<Qt::FocusPolicy>(m_engine->evaluate("MyQObject.StrongFocus").toInt32()), + Qt::StrongFocus); + QCOMPARE(static_cast<Qt::Key>(m_engine->evaluate("MyQObject.Key_Left").toInt32()), + Qt::Key_Left); + + QCOMPARE(m_engine->evaluate("MyQObject.className()").toString(), QLatin1String("MyQObject")); + + qRegisterMetaType<MyQObject::Policy>("Policy"); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithEnumArg(MyQObject.BazPolicy)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 10); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), int(MyQObject::BazPolicy)); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithEnumArg('BarPolicy')").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 10); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), int(MyQObject::BarPolicy)); + + m_myObject->resetQtFunctionInvoked(); + QVERIFY(m_engine->evaluate("myObject.myInvokableWithEnumArg('NoSuchPolicy')").isError()); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + + m_myObject->resetQtFunctionInvoked(); + QCOMPARE(m_engine->evaluate("myObject.myInvokableWithQualifiedEnumArg(MyQObject.BazPolicy)").isUndefined(), true); + QCOMPARE(m_myObject->qtFunctionInvoked(), 36); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 1); + QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), int(MyQObject::BazPolicy)); + + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningEnum()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 37); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 0); + QCOMPARE(ret.isVariant(), true); + } + m_myObject->resetQtFunctionInvoked(); + { + QScriptValue ret = m_engine->evaluate("myObject.myInvokableReturningQualifiedEnum()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 38); + QCOMPARE(m_myObject->qtFunctionActuals().size(), 0); + QCOMPARE(ret.isNumber(), true); + } + + // enum properties are not deletable or writable + QVERIFY(!m_engine->evaluate("delete MyQObject.BazPolicy").toBool()); + myClass.setProperty("BazPolicy", QScriptValue()); + QCOMPARE(static_cast<MyQObject::Policy>(myClass.property("BazPolicy").toInt32()), + MyQObject::BazPolicy); + myClass.setProperty("BazPolicy", MyQObject::FooPolicy); + QCOMPARE(static_cast<MyQObject::Policy>(myClass.property("BazPolicy").toInt32()), + MyQObject::BazPolicy); +} + +QT_BEGIN_NAMESPACE +Q_SCRIPT_DECLARE_QMETAOBJECT(MyQObject, QObject*) +Q_SCRIPT_DECLARE_QMETAOBJECT(QObject, QObject*) +QT_END_NAMESPACE + +class ConstructorTest : public QObject +{ + Q_OBJECT +public: + Q_INVOKABLE ConstructorTest(QObject *parent) + : QObject(parent) + { + setProperty("ctorIndex", 0); + } + Q_INVOKABLE ConstructorTest(int arg, QObject *parent = 0) + : QObject(parent) + { + setProperty("ctorIndex", 1); + setProperty("arg", arg); + } + Q_INVOKABLE ConstructorTest(const QString &arg, QObject *parent = 0) + : QObject(parent) + { + setProperty("ctorIndex", 2); + setProperty("arg", arg); + } + Q_INVOKABLE ConstructorTest(int arg, const QString &arg2, QObject *parent = 0) + : QObject(parent) + { + setProperty("ctorIndex", 3); + setProperty("arg", arg); + setProperty("arg2", arg2); + } + Q_INVOKABLE ConstructorTest(const QBrush &arg, QObject *parent = 0) + : QObject(parent) + { + setProperty("ctorIndex", 4); + setProperty("arg", arg); + } +}; + +void tst_QScriptExtQObject::classConstructor() +{ + QScriptValue myClass = qScriptValueFromQMetaObject<MyQObject>(m_engine); + m_engine->globalObject().setProperty("MyQObject", myClass); + + QScriptValue myObj = m_engine->evaluate("myObj = MyQObject()"); + QObject *qobj = myObj.toQObject(); + QVERIFY(qobj != 0); + QCOMPARE(qobj->metaObject()->className(), "MyQObject"); + QCOMPARE(qobj->parent(), (QObject *)0); + + QScriptValue qobjectClass = qScriptValueFromQMetaObject<QObject>(m_engine); + m_engine->globalObject().setProperty("QObject", qobjectClass); + + QScriptValue otherObj = m_engine->evaluate("otherObj = QObject(myObj)"); + QObject *qqobj = otherObj.toQObject(); + QVERIFY(qqobj != 0); + QCOMPARE(qqobj->metaObject()->className(), "QObject"); + QCOMPARE(qqobj->parent(), qobj); + + delete qobj; + + // Q_INVOKABLE constructors + { + QScriptValue klazz = m_engine->newQMetaObject(&ConstructorTest::staticMetaObject); + { + QScriptValue obj = klazz.construct(); + QVERIFY(obj.isError()); + QCOMPARE(obj.toString(), QString::fromLatin1("SyntaxError: too few arguments in call to ConstructorTest(); candidates are\n" + " ConstructorTest(QBrush)\n" + " ConstructorTest(QBrush,QObject*)\n" + " ConstructorTest(int,QString)\n" + " ConstructorTest(int,QString,QObject*)\n" + " ConstructorTest(QString)\n" + " ConstructorTest(QString,QObject*)\n" + " ConstructorTest(int)\n" + " ConstructorTest(int,QObject*)\n" + " ConstructorTest(QObject*)")); + } + { + QObject objobj; + QScriptValue arg = m_engine->newQObject(&objobj); + QScriptValue obj = klazz.construct(QScriptValueList() << arg); + QVERIFY(!obj.isError()); + QVERIFY(obj.instanceOf(klazz)); + QVERIFY(obj.property("ctorIndex").isNumber()); + QCOMPARE(obj.property("ctorIndex").toInt32(), 0); + } + { + int arg = 123; + QScriptValue obj = klazz.construct(QScriptValueList() << arg); + QVERIFY(!obj.isError()); + QVERIFY(obj.instanceOf(klazz)); + QVERIFY(obj.property("ctorIndex").isNumber()); + QCOMPARE(obj.property("ctorIndex").toInt32(), 1); + QVERIFY(obj.property("arg").isNumber()); + QCOMPARE(obj.property("arg").toInt32(), arg); + } + { + QString arg = "foo"; + QScriptValue obj = klazz.construct(QScriptValueList() << arg); + QVERIFY(!obj.isError()); + QVERIFY(obj.instanceOf(klazz)); + QVERIFY(obj.property("ctorIndex").isNumber()); + QCOMPARE(obj.property("ctorIndex").toInt32(), 2); + QVERIFY(obj.property("arg").isString()); + QCOMPARE(obj.property("arg").toString(), arg); + } + { + int arg = 123; + QString arg2 = "foo"; + QScriptValue obj = klazz.construct(QScriptValueList() << arg << arg2); + QVERIFY(!obj.isError()); + QVERIFY(obj.instanceOf(klazz)); + QVERIFY(obj.property("ctorIndex").isNumber()); + QCOMPARE(obj.property("ctorIndex").toInt32(), 3); + QVERIFY(obj.property("arg").isNumber()); + QCOMPARE(obj.property("arg").toInt32(), arg); + QVERIFY(obj.property("arg2").isString()); + QCOMPARE(obj.property("arg2").toString(), arg2); + } + { + QBrush arg(Qt::red); + QScriptValue obj = klazz.construct(QScriptValueList() << qScriptValueFromValue(m_engine, arg)); + QVERIFY(!obj.isError()); + QVERIFY(obj.instanceOf(klazz)); + QVERIFY(obj.property("ctorIndex").isNumber()); + QCOMPARE(obj.property("ctorIndex").toInt32(), 4); + QVERIFY(obj.property("arg").isVariant()); + QCOMPARE(qvariant_cast<QBrush>(obj.property("arg").toVariant()), arg); + } + { + QDir arg; + QScriptValue obj = klazz.construct(QScriptValueList() + << qScriptValueFromValue(m_engine, arg)); + QVERIFY(obj.isError()); + QCOMPARE(obj.toString(), QString::fromLatin1("TypeError: ambiguous call of overloaded function ConstructorTest(); candidates were\n" + " ConstructorTest(int)\n" + " ConstructorTest(QString)")); + } + } +} + +void tst_QScriptExtQObject::overrideInvokable() +{ + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myInvokable()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 0); + + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myInvokable = function() { global.a = 123; }"); + m_engine->evaluate("myObject.myInvokable()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + QCOMPARE(m_engine->evaluate("global.a").toNumber(), 123.0); + + m_engine->evaluate("myObject.myInvokable = function() { global.a = 456; }"); + m_engine->evaluate("myObject.myInvokable()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), -1); + QCOMPARE(m_engine->evaluate("global.a").toNumber(), 456.0); + + m_engine->evaluate("delete myObject.myInvokable"); + m_engine->evaluate("myObject.myInvokable()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 0); + + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myInvokable = myObject.myInvokableWithIntArg"); + m_engine->evaluate("myObject.myInvokable(123)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 1); + + m_engine->evaluate("delete myObject.myInvokable"); + m_myObject->resetQtFunctionInvoked(); + // this form (with the '()') is read-only + m_engine->evaluate("myObject['myInvokable()'] = function() { global.a = 123; }"); + m_engine->evaluate("myObject.myInvokable()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 0); +} + +void tst_QScriptExtQObject::transferInvokable() +{ + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.foozball = myObject.myInvokable"); + m_engine->evaluate("myObject.foozball()"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 0); + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.foozball = myObject.myInvokableWithIntArg"); + m_engine->evaluate("myObject.foozball(123)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 1); + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myInvokable = myObject.myInvokableWithIntArg"); + m_engine->evaluate("myObject.myInvokable(123)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 1); + + MyOtherQObject other; + m_engine->globalObject().setProperty( + "myOtherObject", m_engine->newQObject(&other)); + m_engine->evaluate("myOtherObject.foo = myObject.foozball"); + other.resetQtFunctionInvoked(); + m_engine->evaluate("myOtherObject.foo(456)"); + QCOMPARE(other.qtFunctionInvoked(), 1); +} + +void tst_QScriptExtQObject::findChild() +{ + QObject *child = new QObject(m_myObject); + child->setObjectName(QLatin1String("myChildObject")); + + { + QScriptValue result = m_engine->evaluate("myObject.findChild('noSuchChild')"); + QCOMPARE(result.isNull(), true); + } + + { + QScriptValue result = m_engine->evaluate("myObject.findChild('myChildObject')"); + QCOMPARE(result.isQObject(), true); + QCOMPARE(result.toQObject(), child); + } + + delete child; +} + +void tst_QScriptExtQObject::findChildren() +{ + QObject *child = new QObject(m_myObject); + child->setObjectName(QLatin1String("myChildObject")); + + { + QScriptValue result = m_engine->evaluate("myObject.findChildren('noSuchChild')"); + QCOMPARE(result.isArray(), true); + QCOMPARE(result.property(QLatin1String("length")).toNumber(), 0.0); + } + + { + QScriptValue result = m_engine->evaluate("myObject.findChildren('myChildObject')"); + QCOMPARE(result.isArray(), true); + QCOMPARE(result.property(QLatin1String("length")).toNumber(), 1.0); + QCOMPARE(result.property(QLatin1String("0")).toQObject(), child); + } + + QObject *namelessChild = new QObject(m_myObject); + + { + QScriptValue result = m_engine->evaluate("myObject.findChildren('myChildObject')"); + QCOMPARE(result.isArray(), true); + QCOMPARE(result.property(QLatin1String("length")).toNumber(), 1.0); + QCOMPARE(result.property(QLatin1String("0")).toQObject(), child); + } + + QObject *anotherChild = new QObject(m_myObject); + anotherChild->setObjectName(QLatin1String("anotherChildObject")); + + { + QScriptValue result = m_engine->evaluate("myObject.findChildren('anotherChildObject')"); + QCOMPARE(result.isArray(), true); + QCOMPARE(result.property(QLatin1String("length")).toNumber(), 1.0); + QCOMPARE(result.property(QLatin1String("0")).toQObject(), anotherChild); + } + + anotherChild->setObjectName(QLatin1String("myChildObject")); + { + QScriptValue result = m_engine->evaluate("myObject.findChildren('myChildObject')"); + QCOMPARE(result.isArray(), true); + QCOMPARE(result.property(QLatin1String("length")).toNumber(), 2.0); + QObject *o1 = result.property(QLatin1String("0")).toQObject(); + QObject *o2 = result.property(QLatin1String("1")).toQObject(); + if (o1 != child) { + QCOMPARE(o1, anotherChild); + QCOMPARE(o2, child); + } else { + QCOMPARE(o1, child); + QCOMPARE(o2, anotherChild); + } + } + + // find all + { + QScriptValue result = m_engine->evaluate("myObject.findChildren()"); + QVERIFY(result.isArray()); + int count = 3; + QCOMPARE(result.property("length").toInt32(), count); + for (int i = 0; i < 3; ++i) { + QObject *o = result.property(i).toQObject(); + if (o == namelessChild || o == child || o == anotherChild) + --count; + } + QVERIFY(count == 0); + } + + delete anotherChild; + delete namelessChild; + delete child; +} + +void tst_QScriptExtQObject::overloadedSlots() +{ + // should pick myOverloadedSlot(double) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(10)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 26); + + // should pick myOverloadedSlot(double) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(10.0)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 26); + + // should pick myOverloadedSlot(QString) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot('10')"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 29); + + // should pick myOverloadedSlot(bool) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(true)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 25); + + // should pick myOverloadedSlot(QDateTime) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(new Date())"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 32); + + // should pick myOverloadedSlot(QRegExp) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(new RegExp())"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 34); + + // should pick myOverloadedSlot(QVariant) + m_myObject->resetQtFunctionInvoked(); + QScriptValue f = m_engine->evaluate("myObject.myOverloadedSlot"); + f.call(QScriptValue(), QScriptValueList() << m_engine->newVariant(QVariant("ciao"))); + QCOMPARE(m_myObject->qtFunctionInvoked(), 35); + + // should pick myOverloadedSlot(QObject*) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(myObject)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 41); + + // should pick myOverloadedSlot(QObject*) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(null)"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 41); + + // should pick myOverloadedSlot(QStringList) + m_myObject->resetQtFunctionInvoked(); + m_engine->evaluate("myObject.myOverloadedSlot(['hello'])"); + QCOMPARE(m_myObject->qtFunctionInvoked(), 42); +} + +void tst_QScriptExtQObject::enumerate_data() +{ + QTest::addColumn<int>("wrapOptions"); + QTest::addColumn<QStringList>("expectedNames"); + + QTest::newRow( "enumerate all" ) + << 0 + << (QStringList() + // meta-object-defined properties: + // inherited + << "objectName" + // non-inherited + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3" + // inherited slots + << "destroyed(QObject*)" << "destroyed()" + << "deleteLater()" + // not included because it's private: + // << "_q_reregisterTimers(void*)" + // signals + << "mySignal()" + // slots + << "mySlot()" << "myOtherSlot()"); + + QTest::newRow( "don't enumerate inherited properties" ) + << int(QScriptEngine::ExcludeSuperClassProperties) + << (QStringList() + // meta-object-defined properties: + // non-inherited + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3" + // inherited slots + << "destroyed(QObject*)" << "destroyed()" + << "deleteLater()" + // not included because it's private: + // << "_q_reregisterTimers(void*)" + // signals + << "mySignal()" + // slots + << "mySlot()" << "myOtherSlot()"); + + QTest::newRow( "don't enumerate inherited methods" ) + << int(QScriptEngine::ExcludeSuperClassMethods) + << (QStringList() + // meta-object-defined properties: + // inherited + << "objectName" + // non-inherited + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3" + // signals + << "mySignal()" + // slots + << "mySlot()" << "myOtherSlot()"); + + QTest::newRow( "don't enumerate inherited members" ) + << int(QScriptEngine::ExcludeSuperClassMethods + | QScriptEngine::ExcludeSuperClassProperties) + << (QStringList() + // meta-object-defined properties + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3" + // signals + << "mySignal()" + // slots + << "mySlot()" << "myOtherSlot()"); + + QTest::newRow( "enumerate properties, not methods" ) + << int(QScriptEngine::SkipMethodsInEnumeration) + << (QStringList() + // meta-object-defined properties: + // inherited + << "objectName" + // non-inherited + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3"); + + QTest::newRow( "don't enumerate inherited properties + methods" ) + << int(QScriptEngine::ExcludeSuperClassProperties + | QScriptEngine::SkipMethodsInEnumeration) + << (QStringList() + // meta-object-defined properties: + // non-inherited + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3"); + + QTest::newRow( "don't enumerate inherited members" ) + << int(QScriptEngine::ExcludeSuperClassContents) + << (QStringList() + // meta-object-defined properties + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3" + // signals + << "mySignal()" + // slots + << "mySlot()" << "myOtherSlot()"); + + QTest::newRow( "don't enumerate deleteLater()" ) + << int(QScriptEngine::ExcludeDeleteLater) + << (QStringList() + // meta-object-defined properties: + // inherited + << "objectName" + // non-inherited + << "p1" << "p2" << "p4" << "p6" + // dynamic properties + << "dp1" << "dp2" << "dp3" + // inherited slots + << "destroyed(QObject*)" << "destroyed()" + // not included because it's private: + // << "_q_reregisterTimers(void*)" + // signals + << "mySignal()" + // slots + << "mySlot()" << "myOtherSlot()"); +} + +void tst_QScriptExtQObject::enumerate() +{ + QFETCH( int, wrapOptions ); + QFETCH( QStringList, expectedNames ); + + QScriptEngine eng; + MyEnumTestQObject enumQObject; + // give it some dynamic properties + enumQObject.setProperty("dp1", "dp1"); + enumQObject.setProperty("dp2", "dp2"); + enumQObject.setProperty("dp3", "dp3"); + QScriptValue obj = eng.newQObject(&enumQObject, QScriptEngine::QtOwnership, + QScriptEngine::QObjectWrapOptions(wrapOptions)); + + // enumerate in script + { + eng.globalObject().setProperty("myEnumObject", obj); + eng.evaluate("var enumeratedProperties = []"); + eng.evaluate("for (var p in myEnumObject) { enumeratedProperties.push(p); }"); + QStringList result = qscriptvalue_cast<QStringList>(eng.evaluate("enumeratedProperties")); + QCOMPARE(result.size(), expectedNames.size()); + for (int i = 0; i < expectedNames.size(); ++i) + QCOMPARE(result.at(i), expectedNames.at(i)); + } + // enumerate in C++ + { + QScriptValueIterator it(obj); + QStringList result; + while (it.hasNext()) { + it.next(); + QCOMPARE(it.flags(), obj.propertyFlags(it.name())); + result.append(it.name()); + } + QCOMPARE(result.size(), expectedNames.size()); + for (int i = 0; i < expectedNames.size(); ++i) + QCOMPARE(result.at(i), expectedNames.at(i)); + } +} + +class SpecialEnumTestObject : public QObject +{ + Q_OBJECT + // overriding a property in the super-class to make it non-scriptable + Q_PROPERTY(QString objectName READ objectName SCRIPTABLE false) +public: + SpecialEnumTestObject(QObject *parent = 0) + : QObject(parent) {} +}; + +class SpecialEnumTestObject2 : public QObject +{ + Q_OBJECT + // overriding a property in the super-class to make it non-designable (but still scriptable) + Q_PROPERTY(QString objectName READ objectName DESIGNABLE false) +public: + SpecialEnumTestObject2(QObject *parent = 0) + : QObject(parent) {} +}; + +void tst_QScriptExtQObject::enumerateSpecial() +{ + QScriptEngine eng; + { + SpecialEnumTestObject testObj; + QScriptValueIterator it(eng.newQObject(&testObj)); + bool objectNameEncountered = false; + while (it.hasNext()) { + it.next(); + if (it.name() == QLatin1String("objectName")) { + objectNameEncountered = true; + break; + } + } + QVERIFY(!objectNameEncountered); + } + { + SpecialEnumTestObject2 testObj; + testObj.setObjectName("foo"); + QScriptValueList values; + QScriptValueIterator it(eng.newQObject(&testObj)); + while (it.hasNext()) { + it.next(); + if (it.name() == "objectName") + values.append(it.value()); + } + QCOMPARE(values.size(), 1); + QCOMPARE(values.at(0).toString(), QString::fromLatin1("foo")); + } +} + +void tst_QScriptExtQObject::wrapOptions() +{ + QCOMPARE(m_myObject->setProperty("dynamicProperty", 123), false); + MyQObject *child = new MyQObject(m_myObject); + child->setObjectName("child"); + // exclude child objects + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::ExcludeChildObjects); + QCOMPARE(obj.property("child").isValid(), false); + obj.setProperty("child", QScriptValue(m_engine, 123)); + QCOMPARE(obj.property("child") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + } + // don't auto-create dynamic properties + { + QScriptValue obj = m_engine->newQObject(m_myObject); + QVERIFY(!m_myObject->dynamicPropertyNames().contains("anotherDynamicProperty")); + obj.setProperty("anotherDynamicProperty", QScriptValue(m_engine, 123)); + QVERIFY(!m_myObject->dynamicPropertyNames().contains("anotherDynamicProperty")); + QCOMPARE(obj.property("anotherDynamicProperty") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + } + // auto-create dynamic properties + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::AutoCreateDynamicProperties); + QVERIFY(!m_myObject->dynamicPropertyNames().contains("anotherDynamicProperty")); + obj.setProperty("anotherDynamicProperty", QScriptValue(m_engine, 123)); + QVERIFY(m_myObject->dynamicPropertyNames().contains("anotherDynamicProperty")); + QCOMPARE(obj.property("anotherDynamicProperty") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + // task 236685 + { + QScriptValue obj2 = m_engine->newObject(); + obj2.setProperty("notADynamicProperty", 456); + obj.setPrototype(obj2); + QScriptValue ret = obj.property("notADynamicProperty"); + QVERIFY(ret.isNumber()); + QVERIFY(ret.strictlyEquals(obj2.property("notADynamicProperty"))); + } + } + // don't exclude super-class properties + { + QScriptValue obj = m_engine->newQObject(m_myObject); + QVERIFY(obj.property("objectName").isValid()); + QVERIFY(obj.propertyFlags("objectName") & QScriptValue::QObjectMember); + } + // exclude super-class properties + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::ExcludeSuperClassProperties); + QVERIFY(!obj.property("objectName").isValid()); + QVERIFY(!(obj.propertyFlags("objectName") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("intProperty").isValid()); + QVERIFY(obj.propertyFlags("intProperty") & QScriptValue::QObjectMember); + } + // don't exclude super-class methods + { + QScriptValue obj = m_engine->newQObject(m_myObject); + QVERIFY(obj.property("deleteLater").isValid()); + QVERIFY(obj.propertyFlags("deleteLater") & QScriptValue::QObjectMember); + } + // exclude super-class methods + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::ExcludeSuperClassMethods); + QVERIFY(!obj.property("deleteLater").isValid()); + QVERIFY(!(obj.propertyFlags("deleteLater") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("mySlot").isValid()); + QVERIFY(obj.propertyFlags("mySlot") & QScriptValue::QObjectMember); + } + // exclude all super-class contents + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::ExcludeSuperClassContents); + QVERIFY(!obj.property("deleteLater").isValid()); + QVERIFY(!(obj.propertyFlags("deleteLater") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("mySlot").isValid()); + QVERIFY(obj.propertyFlags("mySlot") & QScriptValue::QObjectMember); + + QVERIFY(!obj.property("objectName").isValid()); + QVERIFY(!(obj.propertyFlags("objectName") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("intProperty").isValid()); + QVERIFY(obj.propertyFlags("intProperty") & QScriptValue::QObjectMember); + } + // exclude deleteLater() + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::ExcludeDeleteLater); + QVERIFY(!obj.property("deleteLater").isValid()); + QVERIFY(!(obj.propertyFlags("deleteLater") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("mySlot").isValid()); + QVERIFY(obj.propertyFlags("mySlot") & QScriptValue::QObjectMember); + + QVERIFY(obj.property("objectName").isValid()); + QVERIFY(obj.propertyFlags("objectName") & QScriptValue::QObjectMember); + QVERIFY(obj.property("intProperty").isValid()); + QVERIFY(obj.propertyFlags("intProperty") & QScriptValue::QObjectMember); + } + // exclude all that we can + { + QScriptValue obj = m_engine->newQObject(m_myObject, QScriptEngine::QtOwnership, + QScriptEngine::ExcludeSuperClassMethods + | QScriptEngine::ExcludeSuperClassProperties + | QScriptEngine::ExcludeChildObjects); + QVERIFY(!obj.property("deleteLater").isValid()); + QVERIFY(!(obj.propertyFlags("deleteLater") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("mySlot").isValid()); + QVERIFY(obj.propertyFlags("mySlot") & QScriptValue::QObjectMember); + + QVERIFY(!obj.property("objectName").isValid()); + QVERIFY(!(obj.propertyFlags("objectName") & QScriptValue::QObjectMember)); + QVERIFY(obj.property("intProperty").isValid()); + QVERIFY(obj.propertyFlags("intProperty") & QScriptValue::QObjectMember); + + QCOMPARE(obj.property("child").isValid(), false); + obj.setProperty("child", QScriptValue(m_engine, 123)); + QCOMPARE(obj.property("child") + .strictlyEquals(QScriptValue(m_engine, 123)), true); + } + + delete child; +} + +Q_DECLARE_METATYPE(QWidget*) +Q_DECLARE_METATYPE(QPushButton*) + +void tst_QScriptExtQObject::prototypes() +{ + QScriptEngine eng; + QScriptValue widgetProto = eng.newQObject(new QWidget(), QScriptEngine::ScriptOwnership); + eng.setDefaultPrototype(qMetaTypeId<QWidget*>(), widgetProto); + QPushButton *pbp = new QPushButton(); + QScriptValue buttonProto = eng.newQObject(pbp, QScriptEngine::ScriptOwnership); + buttonProto.setPrototype(widgetProto); + eng.setDefaultPrototype(qMetaTypeId<QPushButton*>(), buttonProto); + QPushButton *pb = new QPushButton(); + QScriptValue button = eng.newQObject(pb, QScriptEngine::ScriptOwnership); + QVERIFY(button.prototype().strictlyEquals(buttonProto)); + + buttonProto.setProperty("text", QScriptValue(&eng, "prototype button")); + QCOMPARE(pbp->text(), QLatin1String("prototype button")); + button.setProperty("text", QScriptValue(&eng, "not the prototype button")); + QCOMPARE(pb->text(), QLatin1String("not the prototype button")); + QCOMPARE(pbp->text(), QLatin1String("prototype button")); + + buttonProto.setProperty("objectName", QScriptValue(&eng, "prototype button")); + QCOMPARE(pbp->objectName(), QLatin1String("prototype button")); + button.setProperty("objectName", QScriptValue(&eng, "not the prototype button")); + QCOMPARE(pb->objectName(), QLatin1String("not the prototype button")); + QCOMPARE(pbp->objectName(), QLatin1String("prototype button")); +} + +void tst_QScriptExtQObject::objectDeleted() +{ + QScriptEngine eng; + MyQObject *qobj = new MyQObject(); + QScriptValue v = eng.newQObject(qobj); + v.setProperty("objectName", QScriptValue(&eng, "foo")); + QCOMPARE(qobj->objectName(), QLatin1String("foo")); + v.setProperty("intProperty", QScriptValue(&eng, 123)); + QCOMPARE(qobj->intProperty(), 123); + qobj->resetQtFunctionInvoked(); + v.property("myInvokable").call(v); + QCOMPARE(qobj->qtFunctionInvoked(), 0); + + // now delete the object + delete qobj; + + // the documented behavior is: isQObject() should still return true, + // but toQObject() should return 0 + QVERIFY(v.isQObject()); + QCOMPARE(v.toQObject(), (QObject *)0); + + // any attempt to access properties of the object should result in an exception + { + QScriptValue ret = v.property("objectName"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: cannot access member `objectName' of deleted QObject")); + } + { + eng.evaluate("Object"); + QVERIFY(!eng.hasUncaughtException()); + v.setProperty("objectName", QScriptValue(&eng, "foo")); + QVERIFY(eng.hasUncaughtException()); + QVERIFY(eng.uncaughtException().isError()); + QCOMPARE(eng.uncaughtException().toString(), QLatin1String("Error: cannot access member `objectName' of deleted QObject")); + } + + { + QScriptValue ret = v.call(); + QVERIFY(!ret.isValid()); + } + + // myInvokable is stored in member table (since we've accessed it before deletion) + QVERIFY(v.property("myInvokable").isFunction()); + { + QScriptValue ret = v.property("myInvokable").call(v); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: cannot call function of deleted QObject")); + } + // myInvokableWithIntArg is not stored in member table (since we've not accessed it) + { + QScriptValue ret = v.property("myInvokableWithIntArg"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: cannot access member `myInvokableWithIntArg' of deleted QObject")); + } + + // access from script + eng.globalObject().setProperty("o", v); + { + QScriptValue ret = eng.evaluate("o()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("TypeError: o is not a function")); + } + { + QScriptValue ret = eng.evaluate("o.objectName"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: cannot access member `objectName' of deleted QObject")); + } + { + QScriptValue ret = eng.evaluate("o.myInvokable()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: cannot call function of deleted QObject")); + } + { + QScriptValue ret = eng.evaluate("o.myInvokableWithIntArg(10)"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QLatin1String("Error: cannot access member `myInvokableWithIntArg' of deleted QObject")); + } +} + +void tst_QScriptExtQObject::connectToDestroyedSignal() +{ + // ### the following test currently depends on signal emission order +#if 0 + { + // case 1: deleted when the engine is not doing GC + QScriptEngine eng; + QObject *obj = new QObject(); + eng.globalObject().setProperty("o", eng.newQObject(obj, QScriptEngine::QtOwnership)); + eng.evaluate("o.destroyed.connect(function() { wasDestroyed = true; })"); + eng.evaluate("wasDestroyed = false"); + delete obj; + QVERIFY(eng.evaluate("wasDestroyed").toBoolean()); + } + { + // case 2: deleted when the engine is doing GC + QScriptEngine eng; + QObject *obj = new QObject(); + eng.globalObject().setProperty("o", eng.newQObject(obj, QScriptEngine::ScriptOwnership)); + eng.evaluate("o.destroyed.connect(function() { wasDestroyed = true; })"); + eng.evaluate("wasDestroyed = false"); + eng.evaluate("o = null"); + eng.collectGarbage(); + QVERIFY(eng.evaluate("wasDestroyed").toBoolean()); + } + { + // case 3: deleted when the engine is destroyed + QScriptEngine eng; + QObject *obj = new QObject(); + eng.globalObject().setProperty("o", eng.newQObject(obj, QScriptEngine::ScriptOwnership)); + eng.evaluate("o.destroyed.connect(function() { })"); + // the signal handler won't get called -- we don't want to crash + } +#endif +} + +QTEST_MAIN(tst_QScriptExtQObject) +#include "tst_qscriptextqobject.moc" |