1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 #include <qscriptengine.h>

    46 #include <qscriptcontext.h>

    47 #include <qscriptvalueiterator.h>

    48 #include <qwidget.h>

    49 #include <qpushbutton.h>

    50 #include <qlineedit.h>

    51 

    52 //TESTED_CLASS=

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

    54 

    55 struct CustomType

    56 {

    57 #if defined (Q_CC_NOKIAX86)

    58     // Compiler crash workaround

    59     CustomType() {}

    60 #endif

    61     QString string;

    62 };

    63 Q_DECLARE_METATYPE(CustomType)

    64 

    65 Q_DECLARE_METATYPE(QBrush*)

    66 Q_DECLARE_METATYPE(QObjectList)

    67 Q_DECLARE_METATYPE(QList<int>)

    68 Q_DECLARE_METATYPE(Qt::BrushStyle)

    69 Q_DECLARE_METATYPE(QDir)

    70 

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

    72 {

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

    74     if (!path.isValid())

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

    76     else

    77         out.setPath(path.toString());

    78 }

    79 

    80 namespace MyNS

    81 {

    82     class A : public QObject

    83     {

    84         Q_OBJECT

    85     public:

    86         enum Type {

    87             Foo,

    88             Bar

    89         };

    90         Q_ENUMS(Type)

    91     public Q_SLOTS:

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

    93             return t;

    94         }

    95     };

    96 }

    97 

    98 class MyQObject : public QObject

    99 {

   100     Q_OBJECT

   101 

   102     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty)

   103     Q_PROPERTY(QVariant variantProperty READ variantProperty WRITE setVariantProperty)

   104     Q_PROPERTY(QVariantList variantListProperty READ variantListProperty WRITE setVariantListProperty)

   105     Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty)

   106     Q_PROPERTY(QStringList stringListProperty READ stringListProperty WRITE setStringListProperty)

   107     Q_PROPERTY(QByteArray byteArrayProperty READ byteArrayProperty WRITE setByteArrayProperty)

   108     Q_PROPERTY(QBrush brushProperty READ brushProperty WRITE setBrushProperty)

   109     Q_PROPERTY(double hiddenProperty READ hiddenProperty WRITE setHiddenProperty SCRIPTABLE false)

   110     Q_PROPERTY(int writeOnlyProperty WRITE setWriteOnlyProperty)

   111     Q_PROPERTY(int readOnlyProperty READ readOnlyProperty)

   112     Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)

   113     Q_PROPERTY(CustomType propWithCustomType READ propWithCustomType WRITE setPropWithCustomType)

   114     Q_PROPERTY(Policy enumProperty READ enumProperty WRITE setEnumProperty)

   115     Q_ENUMS(Policy Strategy)

   116     Q_FLAGS(Ability)

   117 

   118 public:

   119     enum Policy {

   120         FooPolicy = 0,

   121         BarPolicy,

   122         BazPolicy

   123     };

   124 

   125     enum Strategy {

   126         FooStrategy = 10,

   127         BarStrategy,

   128         BazStrategy

   129     };

   130 

   131     enum AbilityFlag {

   132         NoAbility  = 0x000,

   133         FooAbility = 0x001,

   134         BarAbility = 0x080,

   135         BazAbility = 0x200,

   136         AllAbility = FooAbility | BarAbility | BazAbility

   137     };

   138 

   139     Q_DECLARE_FLAGS(Ability, AbilityFlag)

   140 

   141     MyQObject(QObject *parent = 0)

   142         : QObject(parent),

   143           m_intValue(123),

   144           m_variantValue(QLatin1String("foo")),

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

   146           m_stringValue(QLatin1String("bar")),

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

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

   149           m_hiddenValue(456.0),

   150           m_writeOnlyValue(789),

   151           m_readOnlyValue(987),

   152           m_enumValue(BarPolicy),

   153           m_qtFunctionInvoked(-1)

   154         { }

   155 

   156     int intProperty() const

   157         { return m_intValue; }

   158     void setIntProperty(int value)

   159         { m_intValue = value; }

   160 

   161     QVariant variantProperty() const

   162         { return m_variantValue; }

   163     void setVariantProperty(const QVariant &value)

   164         { m_variantValue = value; }

   165 

   166     QVariantList variantListProperty() const

   167         { return m_variantListValue; }

   168     void setVariantListProperty(const QVariantList &value)

   169         { m_variantListValue = value; }

   170 

   171     QString stringProperty() const

   172         { return m_stringValue; }

   173     void setStringProperty(const QString &value)

   174         { m_stringValue = value; }

   175 

   176     QStringList stringListProperty() const

   177         { return m_stringListValue; }

   178     void setStringListProperty(const QStringList &value)

   179         { m_stringListValue = value; }

   180 

   181     QByteArray byteArrayProperty() const

   182         { return m_byteArrayValue; }

   183     void setByteArrayProperty(const QByteArray &value)

   184         { m_byteArrayValue = value; }

   185 

   186     QBrush brushProperty() const

   187         { return m_brushValue; }

   188     Q_INVOKABLE void setBrushProperty(const QBrush &value)

   189         { m_brushValue = value; }

   190 

   191     double hiddenProperty() const

   192         { return m_hiddenValue; }

   193     void setHiddenProperty(double value)

   194         { m_hiddenValue = value; }

   195 

   196     int writeOnlyProperty() const

   197         { return m_writeOnlyValue; }

   198     void setWriteOnlyProperty(int value)

   199         { m_writeOnlyValue = value; }

   200 

   201     int readOnlyProperty() const

   202         { return m_readOnlyValue; }

   203 

   204     QKeySequence shortcut() const

   205         { return m_shortcut; }

   206     void setShortcut(const QKeySequence &seq)

   207         { m_shortcut = seq; }

   208 

   209     CustomType propWithCustomType() const

   210         { return m_customType; }

   211     void setPropWithCustomType(const CustomType &c)

   212         { m_customType = c; }

   213 

   214     Policy enumProperty() const

   215         { return m_enumValue; }

   216     void setEnumProperty(Policy policy)

   217         { m_enumValue = policy; }

   218 

   219     int qtFunctionInvoked() const

   220         { return m_qtFunctionInvoked; }

   221 

   222     QVariantList qtFunctionActuals() const

   223         { return m_actuals; }

   224 

   225     void resetQtFunctionInvoked()

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

   227 

   228     void clearConnectedSignal()

   229         { m_connectedSignal = QByteArray(); }

   230     void clearDisconnectedSignal()

   231         { m_disconnectedSignal = QByteArray(); }

   232     QByteArray connectedSignal() const

   233         { return m_connectedSignal; }

   234     QByteArray disconnectedSignal() const

   235         { return m_disconnectedSignal; }

   236 

   237     Q_INVOKABLE void myInvokable()

   238         { m_qtFunctionInvoked = 0; }

   239     Q_INVOKABLE void myInvokableWithIntArg(int arg)

   240         { m_qtFunctionInvoked = 1; m_actuals << arg; }

   241     Q_INVOKABLE void myInvokableWithLonglongArg(qlonglong arg)

   242         { m_qtFunctionInvoked = 2; m_actuals << arg; }

   243     Q_INVOKABLE void myInvokableWithFloatArg(float arg)

   244         { m_qtFunctionInvoked = 3; m_actuals << arg; }

   245     Q_INVOKABLE void myInvokableWithDoubleArg(double arg)

   246         { m_qtFunctionInvoked = 4; m_actuals << arg; }

   247     Q_INVOKABLE void myInvokableWithStringArg(const QString &arg)

   248         { m_qtFunctionInvoked = 5; m_actuals << arg; }

   249     Q_INVOKABLE void myInvokableWithIntArgs(int arg1, int arg2)

   250         { m_qtFunctionInvoked = 6; m_actuals << arg1 << arg2; }

   251     Q_INVOKABLE int myInvokableReturningInt()

   252         { m_qtFunctionInvoked = 7; return 123; }

   253     Q_INVOKABLE qlonglong myInvokableReturningLongLong()

   254         { m_qtFunctionInvoked = 39; return 456; }

   255     Q_INVOKABLE QString myInvokableReturningString()

   256         { m_qtFunctionInvoked = 8; return QLatin1String("ciao"); }

   257     Q_INVOKABLE QVariant myInvokableReturningVariant()

   258         { m_qtFunctionInvoked = 60; return 123; }

   259     Q_INVOKABLE QScriptValue myInvokableReturningScriptValue()

   260         { m_qtFunctionInvoked = 61; return 456; }

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

   262         { m_qtFunctionInvoked = 9; m_actuals << arg1 << arg2; }

   263     Q_INVOKABLE void myInvokableWithEnumArg(Policy policy)

   264         { m_qtFunctionInvoked = 10; m_actuals << policy; }

   265     Q_INVOKABLE void myInvokableWithQualifiedEnumArg(MyQObject::Policy policy)

   266         { m_qtFunctionInvoked = 36; m_actuals << policy; }

   267     Q_INVOKABLE Policy myInvokableReturningEnum()

   268         { m_qtFunctionInvoked = 37; return BazPolicy; }

   269     Q_INVOKABLE MyQObject::Strategy myInvokableReturningQualifiedEnum()

   270         { m_qtFunctionInvoked = 38; return BazStrategy; }

   271     Q_INVOKABLE QVector<int> myInvokableReturningVectorOfInt()

   272         { m_qtFunctionInvoked = 11; return QVector<int>(); }

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

   274         { m_qtFunctionInvoked = 12; }

   275     Q_INVOKABLE QObject *myInvokableReturningQObjectStar()

   276         { m_qtFunctionInvoked = 13; return this; }

   277     Q_INVOKABLE QObjectList myInvokableWithQObjectListArg(const QObjectList &lst)

   278         { m_qtFunctionInvoked = 14; m_actuals << qVariantFromValue(lst); return lst; }

   279     Q_INVOKABLE QVariant myInvokableWithVariantArg(const QVariant &v)

   280         { m_qtFunctionInvoked = 15; m_actuals << v; return v; }

   281     Q_INVOKABLE QVariantMap myInvokableWithVariantMapArg(const QVariantMap &vm)

   282         { m_qtFunctionInvoked = 16; m_actuals << vm; return vm; }

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

   284         { m_qtFunctionInvoked = 17; m_actuals << qVariantFromValue(lst); return lst; }

   285     Q_INVOKABLE QObject* myInvokableWithQObjectStarArg(QObject *obj)

   286         { m_qtFunctionInvoked = 18; m_actuals << qVariantFromValue(obj); return obj; }

   287     Q_INVOKABLE QBrush myInvokableWithQBrushArg(const QBrush &brush)

   288         { m_qtFunctionInvoked = 19; m_actuals << qVariantFromValue(brush); return brush; }

   289     Q_INVOKABLE void myInvokableWithBrushStyleArg(Qt::BrushStyle style)

   290         { m_qtFunctionInvoked = 43; m_actuals << qVariantFromValue(style); }

   291     Q_INVOKABLE void myInvokableWithVoidStarArg(void *arg)

   292         { m_qtFunctionInvoked = 44; m_actuals << qVariantFromValue(arg); }

   293     Q_INVOKABLE void myInvokableWithAmbiguousArg(int arg)

   294         { m_qtFunctionInvoked = 45; m_actuals << qVariantFromValue(arg); }

   295     Q_INVOKABLE void myInvokableWithAmbiguousArg(uint arg)

   296         { m_qtFunctionInvoked = 46; m_actuals << qVariantFromValue(arg); }

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

   298         { m_qtFunctionInvoked = 47; m_actuals << qVariantFromValue(arg1) << qVariantFromValue(arg2); }

   299     Q_INVOKABLE QObject& myInvokableReturningRef()

   300         { m_qtFunctionInvoked = 48; return *this; }

   301     Q_INVOKABLE const QObject& myInvokableReturningConstRef() const

   302         { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 49; return *this; }

   303     Q_INVOKABLE void myInvokableWithPointArg(const QPoint &arg)

   304         { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 50; m_actuals << qVariantFromValue(arg); }

   305     Q_INVOKABLE void myInvokableWithPointArg(const QPointF &arg)

   306         { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 51; m_actuals << qVariantFromValue(arg); }

   307     Q_INVOKABLE void myInvokableWithMyQObjectArg(MyQObject *arg)

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

   309     Q_INVOKABLE MyQObject* myInvokableReturningMyQObject()

   310         { m_qtFunctionInvoked = 53; return this; }

   311     Q_INVOKABLE void myInvokableWithConstMyQObjectArg(const MyQObject *arg)

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

   313     Q_INVOKABLE void myInvokableWithQDirArg(const QDir &arg)

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

   315     Q_INVOKABLE QScriptValue myInvokableWithScriptValueArg(const QScriptValue &arg)

   316         { m_qtFunctionInvoked = 56; return arg; }

   317     Q_INVOKABLE QObject* myInvokableReturningMyQObjectAsQObject()

   318         { m_qtFunctionInvoked = 57; return this; }

   319 

   320     Q_INVOKABLE QObjectList findObjects() const

   321     {  return findChildren<QObject *>();  }

   322     Q_INVOKABLE QList<int> myInvokableNumbers() const

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

   324 

   325     void emitMySignal()

   326         { emit mySignal(); }

   327     void emitMySignalWithIntArg(int arg)

   328         { emit mySignalWithIntArg(arg); }

   329     void emitMySignal2(bool arg)

   330         { emit mySignal2(arg); }

   331     void emitMySignal2()

   332         { emit mySignal2(); }

   333     void emitMyOverloadedSignal(int arg)

   334         { emit myOverloadedSignal(arg); }

   335     void emitMyOverloadedSignal(const QString &arg)

   336         { emit myOverloadedSignal(arg); }

   337     void emitMyOtherOverloadedSignal(const QString &arg)

   338         { emit myOtherOverloadedSignal(arg); }

   339     void emitMyOtherOverloadedSignal(int arg)

   340         { emit myOtherOverloadedSignal(arg); }

   341     void emitMySignalWithDefaultArgWithArg(int arg)

   342         { emit mySignalWithDefaultArg(arg); }

   343     void emitMySignalWithDefaultArg()

   344         { emit mySignalWithDefaultArg(); }

   345     void emitMySignalWithVariantArg(const QVariant &arg)

   346         { emit mySignalWithVariantArg(arg); }

   347     void emitMySignalWithScriptEngineArg(QScriptEngine *arg)

   348         { emit mySignalWithScriptEngineArg(arg); }

   349 

   350 public Q_SLOTS:

   351     void mySlot()

   352         { m_qtFunctionInvoked = 20; }

   353     void mySlotWithIntArg(int arg)

   354         { m_qtFunctionInvoked = 21; m_actuals << arg; }

   355     void mySlotWithDoubleArg(double arg)

   356         { m_qtFunctionInvoked = 22; m_actuals << arg; }

   357     void mySlotWithStringArg(const QString &arg)

   358         { m_qtFunctionInvoked = 23; m_actuals << arg; }

   359 

   360     void myOverloadedSlot()

   361         { m_qtFunctionInvoked = 24; }

   362     void myOverloadedSlot(QObject *arg)

   363         { m_qtFunctionInvoked = 41; m_actuals << qVariantFromValue(arg); }

   364     void myOverloadedSlot(bool arg)

   365         { m_qtFunctionInvoked = 25; m_actuals << arg; }

   366     void myOverloadedSlot(const QStringList &arg)

   367         { m_qtFunctionInvoked = 42; m_actuals << arg; }

   368     void myOverloadedSlot(double arg)

   369         { m_qtFunctionInvoked = 26; m_actuals << arg; }

   370     void myOverloadedSlot(float arg)

   371         { m_qtFunctionInvoked = 27; m_actuals << arg; }

   372     void myOverloadedSlot(int arg)

   373         { m_qtFunctionInvoked = 28; m_actuals << arg; }

   374     void myOverloadedSlot(const QString &arg)

   375         { m_qtFunctionInvoked = 29; m_actuals << arg; }

   376     void myOverloadedSlot(const QColor &arg)

   377         { m_qtFunctionInvoked = 30; m_actuals << arg; }

   378     void myOverloadedSlot(const QBrush &arg)

   379         { m_qtFunctionInvoked = 31; m_actuals << arg; }

   380     void myOverloadedSlot(const QDateTime &arg)

   381         { m_qtFunctionInvoked = 32; m_actuals << arg; }

   382     void myOverloadedSlot(const QDate &arg)

   383         { m_qtFunctionInvoked = 33; m_actuals << arg; }

   384     void myOverloadedSlot(const QRegExp &arg)

   385         { m_qtFunctionInvoked = 34; m_actuals << arg; }

   386     void myOverloadedSlot(const QVariant &arg)

   387         { m_qtFunctionInvoked = 35; m_actuals << arg; }

   388 

   389     virtual int myVirtualSlot(int arg)

   390         { m_qtFunctionInvoked = 58; return arg; }

   391 

   392     void qscript_call(int arg)

   393         { m_qtFunctionInvoked = 40; m_actuals << arg; }

   394 

   395 protected Q_SLOTS:

   396     void myProtectedSlot() { m_qtFunctionInvoked = 36; }

   397 

   398 private Q_SLOTS:

   399     void myPrivateSlot() { }

   400 

   401 Q_SIGNALS:

   402     void mySignal();

   403     void mySignalWithIntArg(int arg);

   404     void mySignalWithDoubleArg(double arg);

   405     void mySignal2(bool arg = false);

   406     void myOverloadedSignal(int arg);

   407     void myOverloadedSignal(const QString &arg);

   408     void myOtherOverloadedSignal(const QString &arg);

   409     void myOtherOverloadedSignal(int arg);

   410     void mySignalWithDefaultArg(int arg = 123);

   411     void mySignalWithVariantArg(const QVariant &arg);

   412     void mySignalWithScriptEngineArg(QScriptEngine *arg);

   413 

   414 protected:

   415     void connectNotify(const char *signal) {

   416         m_connectedSignal = signal;

   417     }

   418     void disconnectNotify(const char *signal) {

   419         m_disconnectedSignal = signal;

   420     }

   421 

   422 protected:

   423     int m_intValue;

   424     QVariant m_variantValue;

   425     QVariantList m_variantListValue;

   426     QString m_stringValue;

   427     QStringList m_stringListValue;

   428     QByteArray m_byteArrayValue;

   429     QBrush m_brushValue;

   430     double m_hiddenValue;

   431     int m_writeOnlyValue;

   432     int m_readOnlyValue;

   433     QKeySequence m_shortcut;

   434     CustomType m_customType;

   435     Policy m_enumValue;

   436     int m_qtFunctionInvoked;

   437     QVariantList m_actuals;

   438     QByteArray m_connectedSignal;

   439     QByteArray m_disconnectedSignal;

   440 };

   441 

   442 Q_DECLARE_METATYPE(MyQObject*)

   443 Q_DECLARE_METATYPE(MyQObject::Policy)

   444 

   445 class MyOtherQObject : public MyQObject

   446 {

   447     Q_OBJECT

   448 public:

   449     MyOtherQObject(QObject *parent = 0)

   450         : MyQObject(parent)

   451         { }

   452 public Q_SLOTS:

   453     virtual int myVirtualSlot(int arg)

   454         { m_qtFunctionInvoked = 59; return arg; }

   455 };

   456 

   457 class MyEnumTestQObject : public QObject

   458 {

   459     Q_OBJECT

   460     Q_PROPERTY(QString p1 READ p1)

   461     Q_PROPERTY(QString p2 READ p2)

   462     Q_PROPERTY(QString p3 READ p3 SCRIPTABLE false)

   463     Q_PROPERTY(QString p4 READ p4)

   464     Q_PROPERTY(QString p5 READ p5 SCRIPTABLE false)

   465     Q_PROPERTY(QString p6 READ p6)

   466 public:

   467     MyEnumTestQObject(QObject *parent = 0)

   468         : QObject(parent) { }

   469     QString p1() const { return QLatin1String("p1"); }

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

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

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

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

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

   475 public Q_SLOTS:

   476     void mySlot() { }

   477     void myOtherSlot() { }

   478 Q_SIGNALS:

   479     void mySignal();

   480 };

   481 

   482 class tst_QScriptExtQObject : public QObject

   483 {

   484     Q_OBJECT

   485 

   486 public:

   487     tst_QScriptExtQObject();

   488     virtual ~tst_QScriptExtQObject();

   489 

   490 public slots:

   491     void init();

   492     void cleanup();

   493 

   494 protected slots:

   495     void onSignalHandlerException(const QScriptValue &exception)

   496     {

   497         m_signalHandlerException = exception;

   498     }

   499 

   500 private slots:

   501     void registeredTypes();

   502     void getSetStaticProperty();

   503     void getSetDynamicProperty();

   504     void getSetChildren();

   505     void callQtInvokable();

   506     void connectAndDisconnect();

   507     void connectAndDisconnectWithBadArgs();

   508     void cppConnectAndDisconnect();

   509     void classEnums();

   510     void classConstructor();

   511     void overrideInvokable();

   512     void transferInvokable();

   513     void findChild();

   514     void findChildren();

   515     void overloadedSlots();

   516     void enumerate_data();

   517     void enumerate();

   518     void enumerateSpecial();

   519     void wrapOptions();

   520     void prototypes();

   521     void objectDeleted();

   522     void connectToDestroyedSignal();

   523 

   524 private:

   525     QScriptEngine *m_engine;

   526     MyQObject *m_myObject;

   527     QScriptValue m_signalHandlerException;

   528 };

   529 

   530 tst_QScriptExtQObject::tst_QScriptExtQObject()

   531 {

   532 }

   533 

   534 tst_QScriptExtQObject::~tst_QScriptExtQObject()

   535 {

   536 }

   537 

   538 void tst_QScriptExtQObject::init()

   539 {

   540     m_engine = new QScriptEngine();

   541     m_myObject = new MyQObject();

   542     m_engine->globalObject().setProperty("myObject", m_engine->newQObject(m_myObject));

   543     m_engine->globalObject().setProperty("global", m_engine->globalObject());

   544 }

   545 

   546 void tst_QScriptExtQObject::cleanup()

   547 {

   548     delete m_engine;

   549     delete m_myObject;

   550 }

   551 

   552 // this test has to be first and test that some types are automatically registered

   553 void tst_QScriptExtQObject::registeredTypes()

   554 {

   555     QScriptEngine e;

   556     QObject *t = new MyQObject;

   557     QObject *c = new QObject(t);

   558     c->setObjectName ("child1");

   559 

   560     e.globalObject().setProperty("MyTest", e.newQObject(t));

   561 

   562     QScriptValue v1 = e.evaluate("MyTest.findObjects()[0].objectName;");

   563     QCOMPARE(v1.toString(), c->objectName());

   564 

   565     QScriptValue v2 = e.evaluate("MyTest.myInvokableNumbers()");

   566     QCOMPARE(qscriptvalue_cast<QList<int> >(v2), (QList<int>() << 1 << 2 << 3));

   567 }

   568 

   569 

   570 static QScriptValue getSetProperty(QScriptContext *ctx, QScriptEngine *)

   571 {

   572     if (ctx->argumentCount() != 0)

   573         ctx->callee().setProperty("value", ctx->argument(0));

   574     return ctx->callee().property("value");

   575 }

   576 

   577 static QScriptValue policyToScriptValue(QScriptEngine *engine, const MyQObject::Policy &policy)

   578 {

   579     return qScriptValueFromValue(engine, policy);

   580 }

   581 

   582 static void policyFromScriptValue(const QScriptValue &value, MyQObject::Policy &policy)

   583 {

   584     QString str = value.toString();

   585     if (str == QLatin1String("red"))

   586         policy = MyQObject::FooPolicy;

   587     else if (str == QLatin1String("green"))

   588         policy = MyQObject::BarPolicy;

   589     else if (str == QLatin1String("blue"))

   590         policy = MyQObject::BazPolicy;

   591     else

   592         policy = (MyQObject::Policy)-1;

   593 }

   594 

   595 void tst_QScriptExtQObject::getSetStaticProperty()

   596 {

   597     QCOMPARE(m_engine->evaluate("myObject.noSuchProperty").isUndefined(), true);

   598 

   599     // initial value (set in MyQObject constructor)

   600     QCOMPARE(m_engine->evaluate("myObject.intProperty")

   601              .strictlyEquals(QScriptValue(m_engine, 123.0)), true);

   602     QCOMPARE(m_engine->evaluate("myObject.variantProperty")

   603              .toVariant(), QVariant(QLatin1String("foo")));

   604     QCOMPARE(m_engine->evaluate("myObject.stringProperty")

   605              .strictlyEquals(QScriptValue(m_engine, QLatin1String("bar"))), true);

   606     QCOMPARE(m_engine->evaluate("myObject.variantListProperty").isArray(), true);

   607     QCOMPARE(m_engine->evaluate("myObject.variantListProperty.length")

   608              .strictlyEquals(QScriptValue(m_engine, 2)), true);

   609     QCOMPARE(m_engine->evaluate("myObject.variantListProperty[0]")

   610              .strictlyEquals(QScriptValue(m_engine, 123)), true);

   611     QCOMPARE(m_engine->evaluate("myObject.variantListProperty[1]")

   612              .strictlyEquals(QScriptValue(m_engine, QLatin1String("foo"))), true);

   613     QCOMPARE(m_engine->evaluate("myObject.stringListProperty").isArray(), true);

   614     QCOMPARE(m_engine->evaluate("myObject.stringListProperty.length")

   615              .strictlyEquals(QScriptValue(m_engine, 2)), true);

   616     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").isString(), true);

   617     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").toString(),

   618              QLatin1String("zig"));

   619     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").isString(), true);

   620     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").toString(),

   621              QLatin1String("zag"));

   622 

   623     // default flags for "normal" properties

   624     {

   625         QScriptValue mobj = m_engine->globalObject().property("myObject");

   626         QVERIFY(!(mobj.propertyFlags("intProperty") & QScriptValue::ReadOnly));

   627         QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::Undeletable);

   628         QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::PropertyGetter);

   629         QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::PropertySetter);

   630         QVERIFY(!(mobj.propertyFlags("intProperty") & QScriptValue::SkipInEnumeration));

   631         QVERIFY(mobj.propertyFlags("intProperty") & QScriptValue::QObjectMember);

   632 

   633         QVERIFY(!(mobj.propertyFlags("mySlot") & QScriptValue::ReadOnly));

   634         QVERIFY(!(mobj.propertyFlags("mySlot") & QScriptValue::Undeletable));

   635         QVERIFY(!(mobj.propertyFlags("mySlot") & QScriptValue::SkipInEnumeration));

   636         QVERIFY(mobj.propertyFlags("mySlot") & QScriptValue::QObjectMember);

   637 

   638         // signature-based property

   639         QVERIFY(!(mobj.propertyFlags("mySlot()") & QScriptValue::ReadOnly));

   640         QVERIFY(!(mobj.propertyFlags("mySlot()") & QScriptValue::Undeletable));

   641         QVERIFY(!(mobj.propertyFlags("mySlot()") & QScriptValue::SkipInEnumeration));

   642         QVERIFY(mobj.propertyFlags("mySlot()") & QScriptValue::QObjectMember);

   643     }

   644 

   645     // property change in C++ should be reflected in script

   646     m_myObject->setIntProperty(456);

   647     QCOMPARE(m_engine->evaluate("myObject.intProperty")

   648              .strictlyEquals(QScriptValue(m_engine, 456)), true);

   649     m_myObject->setIntProperty(789);

   650     QCOMPARE(m_engine->evaluate("myObject.intProperty")

   651              .strictlyEquals(QScriptValue(m_engine, 789)), true);

   652 

   653     m_myObject->setVariantProperty(QLatin1String("bar"));

   654     QVERIFY(m_engine->evaluate("myObject.variantProperty")

   655             .strictlyEquals(QScriptValue(m_engine, QLatin1String("bar"))));

   656     m_myObject->setVariantProperty(42);

   657     QCOMPARE(m_engine->evaluate("myObject.variantProperty")

   658              .toVariant(), QVariant(42));

   659     m_myObject->setVariantProperty(qVariantFromValue(QBrush()));

   660     QVERIFY(m_engine->evaluate("myObject.variantProperty").isVariant());

   661 

   662     m_myObject->setStringProperty(QLatin1String("baz"));

   663     QCOMPARE(m_engine->evaluate("myObject.stringProperty")

   664              .equals(QScriptValue(m_engine, QLatin1String("baz"))), true);

   665     m_myObject->setStringProperty(QLatin1String("zab"));

   666     QCOMPARE(m_engine->evaluate("myObject.stringProperty")

   667              .equals(QScriptValue(m_engine, QLatin1String("zab"))), true);

   668 

   669     // property change in script should be reflected in C++

   670     QCOMPARE(m_engine->evaluate("myObject.intProperty = 123")

   671              .strictlyEquals(QScriptValue(m_engine, 123)), true);

   672     QCOMPARE(m_engine->evaluate("myObject.intProperty")

   673              .strictlyEquals(QScriptValue(m_engine, 123)), true);

   674     QCOMPARE(m_myObject->intProperty(), 123);

   675     QCOMPARE(m_engine->evaluate("myObject.intProperty = 'ciao!';"

   676                                 "myObject.intProperty")

   677              .strictlyEquals(QScriptValue(m_engine, 0)), true);

   678     QCOMPARE(m_myObject->intProperty(), 0);

   679     QCOMPARE(m_engine->evaluate("myObject.intProperty = '123';"

   680                                 "myObject.intProperty")

   681              .strictlyEquals(QScriptValue(m_engine, 123)), true);

   682     QCOMPARE(m_myObject->intProperty(), 123);

   683 

   684     QCOMPARE(m_engine->evaluate("myObject.stringProperty = 'ciao'")

   685              .strictlyEquals(QScriptValue(m_engine, QLatin1String("ciao"))), true);

   686     QCOMPARE(m_engine->evaluate("myObject.stringProperty")

   687              .strictlyEquals(QScriptValue(m_engine, QLatin1String("ciao"))), true);

   688     QCOMPARE(m_myObject->stringProperty(), QLatin1String("ciao"));

   689     QCOMPARE(m_engine->evaluate("myObject.stringProperty = 123;"

   690                                 "myObject.stringProperty")

   691              .strictlyEquals(QScriptValue(m_engine, QLatin1String("123"))), true);

   692     QCOMPARE(m_myObject->stringProperty(), QLatin1String("123"));

   693     QVERIFY(m_engine->evaluate("myObject.stringProperty = null;"

   694                                "myObject.stringProperty")

   695             .strictlyEquals(QScriptValue(m_engine, QString())));

   696     QCOMPARE(m_myObject->stringProperty(), QString());

   697     QVERIFY(m_engine->evaluate("myObject.stringProperty = undefined;"

   698                                "myObject.stringProperty")

   699             .strictlyEquals(QScriptValue(m_engine, QString())));

   700     QCOMPARE(m_myObject->stringProperty(), QString());

   701 

   702     QCOMPARE(m_engine->evaluate("myObject.variantProperty = 'foo';"

   703                                 "myObject.variantProperty.valueOf()").toString(), QLatin1String("foo"));

   704     QCOMPARE(m_myObject->variantProperty(), QVariant(QLatin1String("foo")));

   705     QVERIFY(m_engine->evaluate("myObject.variantProperty = undefined;"

   706                                "myObject.variantProperty").isUndefined());

   707     QVERIFY(!m_myObject->variantProperty().isValid());

   708     QVERIFY(m_engine->evaluate("myObject.variantProperty = null;"

   709                                "myObject.variantProperty").isUndefined());

   710     QVERIFY(!m_myObject->variantProperty().isValid());

   711     QCOMPARE(m_engine->evaluate("myObject.variantProperty = 42;"

   712                                 "myObject.variantProperty").toNumber(), 42.0);

   713     QCOMPARE(m_myObject->variantProperty().toDouble(), 42.0);

   714 

   715     QCOMPARE(m_engine->evaluate("myObject.variantListProperty = [1, 'two', true];"

   716                                 "myObject.variantListProperty.length")

   717              .strictlyEquals(QScriptValue(m_engine, 3)), true);

   718     QCOMPARE(m_engine->evaluate("myObject.variantListProperty[0]")

   719              .strictlyEquals(QScriptValue(m_engine, 1)), true);

   720     QCOMPARE(m_engine->evaluate("myObject.variantListProperty[1]")

   721              .strictlyEquals(QScriptValue(m_engine, QLatin1String("two"))), true);

   722     QCOMPARE(m_engine->evaluate("myObject.variantListProperty[2]")

   723              .strictlyEquals(QScriptValue(m_engine, true)), true);

   724     {

   725         QVariantList vl = qscriptvalue_cast<QVariantList>(m_engine->evaluate("myObject.variantListProperty"));

   726         QCOMPARE(vl, QVariantList()

   727                  << QVariant(1)

   728                  << QVariant(QLatin1String("two"))

   729                  << QVariant(true));

   730     }

   731 

   732     QCOMPARE(m_engine->evaluate("myObject.stringListProperty = [1, 'two', true];"

   733                                 "myObject.stringListProperty.length")

   734              .strictlyEquals(QScriptValue(m_engine, 3)), true);

   735     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").isString(), true);

   736     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[0]").toString(),

   737              QLatin1String("1"));

   738     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").isString(), true);

   739     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[1]").toString(),

   740              QLatin1String("two"));

   741     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[2]").isString(), true);

   742     QCOMPARE(m_engine->evaluate("myObject.stringListProperty[2]").toString(),

   743              QLatin1String("true"));

   744     {

   745         QStringList sl = qscriptvalue_cast<QStringList>(m_engine->evaluate("myObject.stringListProperty"));

   746         QCOMPARE(sl, QStringList()

   747                  << QLatin1String("1")

   748                  << QLatin1String("two")

   749                  << QLatin1String("true"));

   750     }

   751 

   752     // test setting properties where we can't convert the type natively but where the

   753     // types happen to be compatible variant types already

   754     {

   755         QKeySequence sequence(Qt::ControlModifier + Qt::AltModifier + Qt::Key_Delete);

   756         QScriptValue mobj = m_engine->globalObject().property("myObject");

   757 

   758         QVERIFY(m_myObject->shortcut().isEmpty());

   759         mobj.setProperty("shortcut", m_engine->newVariant(sequence));

   760         QVERIFY(m_myObject->shortcut() == sequence);

   761     }

   762     {

   763         CustomType t; t.string = "hello";

   764         QScriptValue mobj = m_engine->globalObject().property("myObject");

   765 

   766         QVERIFY(m_myObject->propWithCustomType().string.isEmpty());

   767         mobj.setProperty("propWithCustomType", m_engine->newVariant(qVariantFromValue(t)));

   768         QVERIFY(m_myObject->propWithCustomType().string == t.string);

   769     }

   770 

   771     // test that we do value conversion if necessary when setting properties

   772     {

   773         QScriptValue br = m_engine->evaluate("myObject.brushProperty");

   774         QVERIFY(br.isVariant());

   775         QVERIFY(!br.strictlyEquals(m_engine->evaluate("myObject.brushProperty")));

   776         QCOMPARE(qscriptvalue_cast<QBrush>(br), m_myObject->brushProperty());

   777         QCOMPARE(qscriptvalue_cast<QColor>(br), m_myObject->brushProperty().color());

   778 

   779         QColor newColor(40, 30, 20, 10);

   780         QScriptValue val = qScriptValueFromValue(m_engine, newColor);

   781         m_engine->globalObject().setProperty("myColor", val);

   782         QScriptValue ret = m_engine->evaluate("myObject.brushProperty = myColor");

   783         QCOMPARE(ret.strictlyEquals(val), true);

   784         br = m_engine->evaluate("myObject.brushProperty");

   785         QCOMPARE(qscriptvalue_cast<QBrush>(br), QBrush(newColor));

   786         QCOMPARE(qscriptvalue_cast<QColor>(br), newColor);

   787 

   788         m_engine->globalObject().setProperty("myColor", QScriptValue());

   789     }

   790 

   791     // try to delete

   792     QCOMPARE(m_engine->evaluate("delete myObject.intProperty").toBoolean(), false);

   793     QCOMPARE(m_engine->evaluate("myObject.intProperty").toNumber(), 123.0);

   794 

   795     QCOMPARE(m_engine->evaluate("delete myObject.variantProperty").toBoolean(), false);

   796     QCOMPARE(m_engine->evaluate("myObject.variantProperty").toNumber(), 42.0);

   797 

   798     // non-scriptable property

   799     QCOMPARE(m_myObject->hiddenProperty(), 456.0);

   800     QCOMPARE(m_engine->evaluate("myObject.hiddenProperty").isUndefined(), true);

   801     QCOMPARE(m_engine->evaluate("myObject.hiddenProperty = 123;"

   802                                 "myObject.hiddenProperty").toInt32(), 123);

   803     QCOMPARE(m_myObject->hiddenProperty(), 456.0);

   804 

   805     // write-only property

   806     QCOMPARE(m_myObject->writeOnlyProperty(), 789);

   807     QCOMPARE(m_engine->evaluate("myObject.writeOnlyProperty").isUndefined(), true);

   808     QCOMPARE(m_engine->evaluate("myObject.writeOnlyProperty = 123;"

   809                                 "myObject.writeOnlyProperty").isUndefined(), true);

   810     QCOMPARE(m_myObject->writeOnlyProperty(), 123);

   811 

   812     // read-only property

   813     QCOMPARE(m_myObject->readOnlyProperty(), 987);

   814     QCOMPARE(m_engine->evaluate("myObject.readOnlyProperty").toInt32(), 987);

   815     QCOMPARE(m_engine->evaluate("myObject.readOnlyProperty = 654;"

   816                                 "myObject.readOnlyProperty").toInt32(), 987);

   817     QCOMPARE(m_myObject->readOnlyProperty(), 987);

   818     {

   819         QScriptValue mobj = m_engine->globalObject().property("myObject");

   820         QCOMPARE(mobj.propertyFlags("readOnlyProperty") & QScriptValue::ReadOnly,

   821                  QScriptValue::ReadOnly);

   822     }

   823 

   824     // enum property

   825     QCOMPARE(m_myObject->enumProperty(), MyQObject::BarPolicy);

   826     {

   827         QScriptValue val = m_engine->evaluate("myObject.enumProperty");

   828         QVERIFY(val.isNumber());

   829         QCOMPARE(val.toInt32(), (int)MyQObject::BarPolicy);

   830     }

   831     m_engine->evaluate("myObject.enumProperty = 2");

   832     QCOMPARE(m_myObject->enumProperty(), MyQObject::BazPolicy);

   833     m_engine->evaluate("myObject.enumProperty = 'BarPolicy'");

   834     QCOMPARE(m_myObject->enumProperty(), MyQObject::BarPolicy);

   835     m_engine->evaluate("myObject.enumProperty = 'ScoobyDoo'");

   836     // ### ouch! Shouldn't QMetaProperty::write() rather not change the value...?

   837     QCOMPARE(m_myObject->enumProperty(), (MyQObject::Policy)-1);

   838     // enum property with custom conversion

   839     qScriptRegisterMetaType<MyQObject::Policy>(m_engine, policyToScriptValue, policyFromScriptValue);

   840     m_engine->evaluate("myObject.enumProperty = 'red'");

   841     QCOMPARE(m_myObject->enumProperty(), MyQObject::FooPolicy);

   842     m_engine->evaluate("myObject.enumProperty = 'green'");

   843     QCOMPARE(m_myObject->enumProperty(), MyQObject::BarPolicy);

   844     m_engine->evaluate("myObject.enumProperty = 'blue'");

   845     QCOMPARE(m_myObject->enumProperty(), MyQObject::BazPolicy);

   846     m_engine->evaluate("myObject.enumProperty = 'nada'");

   847     QCOMPARE(m_myObject->enumProperty(), (MyQObject::Policy)-1);

   848 

   849     // auto-dereferencing of pointers

   850     {

   851         QBrush b = QColor(0xCA, 0xFE, 0xBA, 0xBE);

   852         QBrush *bp = &b;

   853         QScriptValue bpValue = m_engine->newVariant(qVariantFromValue(bp));

   854         m_engine->globalObject().setProperty("brushPointer", bpValue);

   855         {

   856             QScriptValue ret = m_engine->evaluate("myObject.setBrushProperty(brushPointer)");

   857             QCOMPARE(ret.isUndefined(), true);

   858             QCOMPARE(qscriptvalue_cast<QBrush>(m_engine->evaluate("myObject.brushProperty")), b);

   859         }

   860         {

   861             b = QColor(0xDE, 0xAD, 0xBE, 0xEF);

   862             QScriptValue ret = m_engine->evaluate("myObject.brushProperty = brushPointer");

   863             QCOMPARE(ret.strictlyEquals(bpValue), true);

   864             QCOMPARE(qscriptvalue_cast<QBrush>(m_engine->evaluate("myObject.brushProperty")), b);

   865         }

   866         m_engine->globalObject().setProperty("brushPointer", QScriptValue());

   867     }

   868 

   869     // install custom property getter+setter

   870     {

   871         QScriptValue mobj = m_engine->globalObject().property("myObject");

   872         mobj.setProperty("intProperty", m_engine->newFunction(getSetProperty),

   873                          QScriptValue::PropertyGetter | QScriptValue::PropertySetter);

   874         QVERIFY(mobj.property("intProperty").toInt32() != 321);

   875         mobj.setProperty("intProperty", 321);

   876         QCOMPARE(mobj.property("intProperty").toInt32(), 321);

   877     }

   878 

   879     // method properties are persistent

   880     {

   881         QScriptValue slot = m_engine->evaluate("myObject.mySlot");

   882         QVERIFY(slot.isFunction());

   883         QScriptValue sameSlot = m_engine->evaluate("myObject.mySlot");

   884         QVERIFY(sameSlot.strictlyEquals(slot));

   885         sameSlot = m_engine->evaluate("myObject[mySlot()]");

   886         QEXPECT_FAIL("", "Signature-based method lookup creates new function wrapper object", Continue);

   887         QVERIFY(sameSlot.strictlyEquals(slot));

   888     }

   889 }

   890 

   891 void tst_QScriptExtQObject::getSetDynamicProperty()

   892 {

   893     // initially the object does not have the property

   894     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('dynamicProperty')")

   895              .strictlyEquals(QScriptValue(m_engine, false)), true);

   896 

   897     // add a dynamic property in C++

   898     QCOMPARE(m_myObject->setProperty("dynamicProperty", 123), false);

   899     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('dynamicProperty')")

   900              .strictlyEquals(QScriptValue(m_engine, true)), true);

   901     QCOMPARE(m_engine->evaluate("myObject.dynamicProperty")

   902              .strictlyEquals(QScriptValue(m_engine, 123)), true);

   903 

   904     // check the flags

   905     {

   906         QScriptValue mobj = m_engine->globalObject().property("myObject");

   907         QVERIFY(!(mobj.propertyFlags("dynamicProperty") & QScriptValue::ReadOnly));

   908         QVERIFY(!(mobj.propertyFlags("dynamicProperty") & QScriptValue::Undeletable));

   909         QVERIFY(!(mobj.propertyFlags("dynamicProperty") & QScriptValue::SkipInEnumeration));

   910         QVERIFY(mobj.propertyFlags("dynamicProperty") & QScriptValue::QObjectMember);

   911     }

   912 

   913     // property change in script should be reflected in C++

   914     QCOMPARE(m_engine->evaluate("myObject.dynamicProperty = 'foo';"

   915                                 "myObject.dynamicProperty")

   916              .strictlyEquals(QScriptValue(m_engine, QLatin1String("foo"))), true);

   917     QCOMPARE(m_myObject->property("dynamicProperty").toString(), QLatin1String("foo"));

   918 

   919     // delete the property

   920     QCOMPARE(m_engine->evaluate("delete myObject.dynamicProperty").toBoolean(), true);

   921     QCOMPARE(m_myObject->property("dynamicProperty").isValid(), false);

   922     QCOMPARE(m_engine->evaluate("myObject.dynamicProperty").isUndefined(), true);

   923     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('dynamicProperty')").toBoolean(), false);

   924 }

   925 

   926 void tst_QScriptExtQObject::getSetChildren()

   927 {

   928     QScriptValue mobj = m_engine->evaluate("myObject");

   929 

   930     // initially the object does not have the child

   931     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')")

   932              .strictlyEquals(QScriptValue(m_engine, false)), true);

   933 

   934     // add a child

   935     MyQObject *child = new MyQObject(m_myObject);

   936     child->setObjectName("child");

   937     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')")

   938              .strictlyEquals(QScriptValue(m_engine, true)), true);

   939 

   940     QVERIFY(mobj.propertyFlags("child") & QScriptValue::ReadOnly);

   941     QVERIFY(mobj.propertyFlags("child") & QScriptValue::Undeletable);

   942     QVERIFY(mobj.propertyFlags("child") & QScriptValue::SkipInEnumeration);

   943     QVERIFY(!(mobj.propertyFlags("child") & QScriptValue::QObjectMember));

   944 

   945     {

   946         QScriptValue scriptChild = m_engine->evaluate("myObject.child");

   947         QVERIFY(scriptChild.isQObject());

   948         QCOMPARE(scriptChild.toQObject(), (QObject*)child);

   949         QScriptValue sameChild = m_engine->evaluate("myObject.child");

   950         QVERIFY(sameChild.strictlyEquals(scriptChild));

   951     }

   952 

   953     // add a grandchild

   954     MyQObject *grandChild = new MyQObject(child);

   955     grandChild->setObjectName("grandChild");

   956     QCOMPARE(m_engine->evaluate("myObject.child.hasOwnProperty('grandChild')")

   957              .strictlyEquals(QScriptValue(m_engine, true)), true);

   958 

   959     // delete grandchild

   960     delete grandChild;

   961     QCOMPARE(m_engine->evaluate("myObject.child.hasOwnProperty('grandChild')")

   962              .strictlyEquals(QScriptValue(m_engine, false)), true);

   963 

   964     // delete child

   965     delete child;

   966     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')")

   967              .strictlyEquals(QScriptValue(m_engine, false)), true);

   968 

   969 }

   970 

   971 Q_DECLARE_METATYPE(QVector<int>)

   972 Q_DECLARE_METATYPE(QVector<double>)

   973 Q_DECLARE_METATYPE(QVector<QString>)

   974 

   975 template <class T>

   976 static QScriptValue qobjectToScriptValue(QScriptEngine *engine, T* const &in)

   977 { return engine->newQObject(in); }

   978 

   979 template <class T>

   980 static void qobjectFromScriptValue(const QScriptValue &object, T* &out)

   981 { out = qobject_cast<T*>(object.toQObject()); }

   982 

   983 void tst_QScriptExtQObject::callQtInvokable()

   984 {

   985     m_myObject->resetQtFunctionInvoked();

   986     QCOMPARE(m_engine->evaluate("myObject.myInvokable()").isUndefined(), true);

   987     QCOMPARE(m_myObject->qtFunctionInvoked(), 0);

   988     QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList());

   989 

   990     // extra arguments should silently be ignored

   991     m_myObject->resetQtFunctionInvoked();

   992     QCOMPARE(m_engine->evaluate("myObject.myInvokable(10, 20, 30)").isUndefined(), true);

   993     QCOMPARE(m_myObject->qtFunctionInvoked(), 0);

   994     QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList());

   995 

   996     m_myObject->resetQtFunctionInvoked();

   997     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArg(123)").isUndefined(), true);

   998     QCOMPARE(m_myObject->qtFunctionInvoked(), 1);

   999     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1000     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123);

  1001 

  1002     m_myObject->resetQtFunctionInvoked();

  1003     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArg('123')").isUndefined(), true);

  1004     QCOMPARE(m_myObject->qtFunctionInvoked(), 1);

  1005     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1006     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123);

  1007 

  1008     m_myObject->resetQtFunctionInvoked();

  1009     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithLonglongArg(123)").isUndefined(), true);

  1010     QCOMPARE(m_myObject->qtFunctionInvoked(), 2);

  1011     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1012     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toLongLong(), qlonglong(123));

  1013 

  1014     m_myObject->resetQtFunctionInvoked();

  1015     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithFloatArg(123.5)").isUndefined(), true);

  1016     QCOMPARE(m_myObject->qtFunctionInvoked(), 3);

  1017     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1018     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toDouble(), 123.5);

  1019 

  1020     m_myObject->resetQtFunctionInvoked();

  1021     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithDoubleArg(123.5)").isUndefined(), true);

  1022     QCOMPARE(m_myObject->qtFunctionInvoked(), 4);

  1023     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1024     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toDouble(), 123.5);

  1025 

  1026     m_myObject->resetQtFunctionInvoked();

  1027     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithStringArg('ciao')").isUndefined(), true);

  1028     QCOMPARE(m_myObject->qtFunctionInvoked(), 5);

  1029     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1030     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QLatin1String("ciao"));

  1031 

  1032     m_myObject->resetQtFunctionInvoked();

  1033     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithStringArg(123)").isUndefined(), true);

  1034     QCOMPARE(m_myObject->qtFunctionInvoked(), 5);

  1035     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1036     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QLatin1String("123"));

  1037 

  1038     m_myObject->resetQtFunctionInvoked();

  1039     QVERIFY(m_engine->evaluate("myObject.myInvokableWithStringArg(null)").isUndefined());

  1040     QCOMPARE(m_myObject->qtFunctionInvoked(), 5);

  1041     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1042     QCOMPARE(m_myObject->qtFunctionActuals().at(0).type(), QVariant::String);

  1043     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QString());

  1044 

  1045     m_myObject->resetQtFunctionInvoked();

  1046     QVERIFY(m_engine->evaluate("myObject.myInvokableWithStringArg(undefined)").isUndefined());

  1047     QCOMPARE(m_myObject->qtFunctionInvoked(), 5);

  1048     QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);

  1049     QCOMPARE(m_myObject->qtFunctionActuals().at(0).type(), QVariant::String);

  1050     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toString(), QString());

  1051 

  1052     m_myObject->resetQtFunctionInvoked();

  1053     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArgs(123, 456)").isUndefined(), true);

  1054     QCOMPARE(m_myObject->qtFunctionInvoked(), 6);

  1055     QCOMPARE(m_myObject->qtFunctionActuals().size(), 2);

  1056     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123);

  1057     QCOMPARE(m_myObject->qtFunctionActuals().at(1).toInt(), 456);

  1058 

  1059     m_myObject->resetQtFunctionInvoked();

  1060     QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningInt()")

  1061              .strictlyEquals(QScriptValue(m_engine, 123)), true);

  1062     QCOMPARE(m_myObject->qtFunctionInvoked(), 7);

  1063     QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList());

  1064 

  1065     m_myObject->resetQtFunctionInvoked();

  1066     QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningLongLong()")

  1067              .strictlyEquals(QScriptValue(m_engine, 456)), true);

  1068     QCOMPARE(m_myObject->qtFunctionInvoked(), 39);

  1069     QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList());

  1070 

  1071     m_myObject->resetQtFunctionInvoked();

  1072     QCOMPARE(m_engine->evaluate("myObject.myInvokableReturningString()")

  1073              .strictlyEquals(QScriptValue(m_engine, QLatin1String("ciao"))), true);

  1074     QCOMPARE(m_myObject->qtFunctionInvoked(), 8);

  1075     QCOMPARE(m_myObject->qtFunctionActuals(), QVariantList());

  1076 

  1077     m_myObject->resetQtFunctionInvoked();

  1078     QVERIFY(m_engine->evaluate("myObject.myInvokableReturningVariant()")

  1079              .strictlyEquals(QScriptValue(m_engine, 123)));

  1080     QCOMPARE(m_myObject->qtFunctionInvoked(), 60);

  1081 

  1082     m_myObject->resetQtFunctionInvoked();

  1083     QVERIFY(m_engine->evaluate("myObject.myInvokableReturningScriptValue()")

  1084              .strictlyEquals(QScriptValue(m_engine, 456)));

  1085     QCOMPARE(m_myObject->qtFunctionInvoked(), 61);

  1086 

  1087     m_myObject->resetQtFunctionInvoked();

  1088     QCOMPARE(m_engine->evaluate("myObject.myInvokableWithIntArg(123, 456)").isUndefined(), true);

  1089     QCOMPARE(m_myObject->qtFunctionInvoked(), 9);

  1090     QCOMPARE(m_myObject->qtFunctionActuals().size(), 2);

  1091     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123);

  1092     QCOMPARE(m_myObject->qtFunctionActuals().at(1).toInt(), 456);

  1093 

  1094     m_myObject->resetQtFunctionInvoked();

  1095     QVERIFY(m_engine->evaluate("myObject.myInvokableWithVoidStarArg(null)").isUndefined());

  1096     QCOMPARE(m_myObject->qtFunctionInvoked(), 44);

  1097     m_myObject->resetQtFunctionInvoked();

  1098     QVERIFY(m_engine->evaluate("myObject.myInvokableWithVoidStarArg(123)").isError());

  1099     QCOMPARE(m_myObject->qtFunctionInvoked(), -1);

  1100 

  1101     m_myObject->resetQtFunctionInvoked();

  1102     {

  1103         QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithAmbiguousArg(123)");

  1104         QVERIFY(ret.isError());

  1105         QCOMPARE(ret.toString(), QLatin1String("TypeError: ambiguous call of overloaded function myInvokableWithAmbiguousArg(); candidates were\n    myInvokableWithAmbiguousArg(int)\n    myInvokableWithAmbiguousArg(uint)"));

  1106     }

  1107 

  1108     m_myObject->resetQtFunctionInvoked();

  1109     {

  1110         QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithDefaultArgs(123, 'hello')");

  1111         QVERIFY(ret.isUndefined());

  1112         QCOMPARE(m_myObject->qtFunctionInvoked(), 47);

  1113         QCOMPARE(m_myObject->qtFunctionActuals().size(), 2);

  1114         QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 123);

  1115         QCOMPARE(m_myObject->qtFunctionActuals().at(1).toString(), QLatin1String("hello"));

  1116     }

  1117 

  1118     m_myObject->resetQtFunctionInvoked();

  1119     {

  1120         QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithDefaultArgs(456)");

  1121         QVERIFY(ret.isUndefined());

  1122         QCOMPARE(m_myObject->qtFunctionInvoked(), 47);

  1123         QCOMPARE(m_myObject->qtFunctionActuals().size(), 2);

  1124         QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 456);

  1125         QCOMPARE(m_myObject->qtFunctionActuals().at(1).toString(), QString());

  1126     }

  1127 

  1128     {

  1129         QScriptValue fun = m_engine->evaluate("myObject.myInvokableWithPointArg");

  1130         QVERIFY(fun.isFunction());

  1131         m_myObject->resetQtFunctionInvoked();

  1132         {

  1133             QScriptValue ret = fun.call(m_engine->evaluate("myObject"),

  1134                                         QScriptValueList() << qScriptValueFromValue(m_engine, QPoint(10, 20)));