1 /*

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

     3 

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

     5     modify it under the terms of the GNU Library General Public

     6     License as published by the Free Software Foundation; either

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

     8 

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

    10     but WITHOUT ANY WARRANTY; without even the implied warranty of

    11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12     Library General Public License for more details.

    13 

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

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

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

    17     Boston, MA 02110-1301, USA.

    18 */

    19 

    20 

    21 #include <QtTest/QtTest>

    22 

    23 #include <qwebpage.h>

    24 #include <qwebelement.h>

    25 #include <qwidget.h>

    26 #include <qwebview.h>

    27 #include <qwebframe.h>

    28 #include <qwebhistory.h>

    29 #include <QAbstractItemView>

    30 #include <QApplication>

    31 #include <QComboBox>

    32 #include <QPicture>

    33 #include <QRegExp>

    34 #include <QNetworkRequest>

    35 #include <QNetworkReply>

    36 #ifndef QT_NO_OPENSSL

    37 #include <qsslerror.h>

    38 #endif

    39 #include "../util.h"

    40 

    41 struct CustomType {

    42     QString string;

    43 };

    44 Q_DECLARE_METATYPE(CustomType)

    45 

    46 Q_DECLARE_METATYPE(QBrush*)

    47 Q_DECLARE_METATYPE(QObjectList)

    48 Q_DECLARE_METATYPE(QList<int>)

    49 Q_DECLARE_METATYPE(Qt::BrushStyle)

    50 Q_DECLARE_METATYPE(QVariantList)

    51 Q_DECLARE_METATYPE(QVariantMap)

    52 

    53 class MyQObject : public QObject

    54 {

    55     Q_OBJECT

    56 

    57     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty)

    58     Q_PROPERTY(QVariant variantProperty READ variantProperty WRITE setVariantProperty)

    59     Q_PROPERTY(QVariantList variantListProperty READ variantListProperty WRITE setVariantListProperty)

    60     Q_PROPERTY(QVariantMap variantMapProperty READ variantMapProperty WRITE setVariantMapProperty)

    61     Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty)

    62     Q_PROPERTY(QStringList stringListProperty READ stringListProperty WRITE setStringListProperty)

    63     Q_PROPERTY(QByteArray byteArrayProperty READ byteArrayProperty WRITE setByteArrayProperty)

    64     Q_PROPERTY(QBrush brushProperty READ brushProperty WRITE setBrushProperty)

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

    66     Q_PROPERTY(int writeOnlyProperty WRITE setWriteOnlyProperty)

    67     Q_PROPERTY(int readOnlyProperty READ readOnlyProperty)

    68     Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)

    69     Q_PROPERTY(CustomType propWithCustomType READ propWithCustomType WRITE setPropWithCustomType)

    70     Q_PROPERTY(QWebElement webElementProperty READ webElementProperty WRITE setWebElementProperty)

    71     Q_PROPERTY(QObject* objectStarProperty READ objectStarProperty WRITE setObjectStarProperty)

    72     Q_ENUMS(Policy Strategy)

    73     Q_FLAGS(Ability)

    74 

    75 public:

    76     enum Policy {

    77         FooPolicy = 0,

    78         BarPolicy,

    79         BazPolicy

    80     };

    81 

    82     enum Strategy {

    83         FooStrategy = 10,

    84         BarStrategy,

    85         BazStrategy

    86     };

    87 

    88     enum AbilityFlag {

    89         NoAbility  = 0x000,

    90         FooAbility = 0x001,

    91         BarAbility = 0x080,

    92         BazAbility = 0x200,

    93         AllAbility = FooAbility | BarAbility | BazAbility

    94     };

    95 

    96     Q_DECLARE_FLAGS(Ability, AbilityFlag)

    97 

    98     MyQObject(QObject* parent = 0)

    99         : QObject(parent),

   100             m_intValue(123),

   101             m_variantValue(QLatin1String("foo")),

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

   103             m_stringValue(QLatin1String("bar")),

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

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

   106             m_hiddenValue(456.0),

   107             m_writeOnlyValue(789),

   108             m_readOnlyValue(987),

   109             m_objectStar(0),

   110             m_qtFunctionInvoked(-1)

   111     {

   112         m_variantMapValue.insert("a", QVariant(123));

   113         m_variantMapValue.insert("b", QVariant(QLatin1String("foo")));

   114         m_variantMapValue.insert("c", QVariant::fromValue<QObject*>(this));

   115     }

   116 

   117     ~MyQObject() { }

   118 

   119     int intProperty() const {

   120         return m_intValue;

   121     }

   122     void setIntProperty(int value) {

   123         m_intValue = value;

   124     }

   125 

   126     QVariant variantProperty() const {

   127         return m_variantValue;

   128     }

   129     void setVariantProperty(const QVariant &value) {

   130         m_variantValue = value;

   131     }

   132 

   133     QVariantList variantListProperty() const {

   134         return m_variantListValue;

   135     }

   136     void setVariantListProperty(const QVariantList &value) {

   137         m_variantListValue = value;

   138     }

   139 

   140     QVariantMap variantMapProperty() const {

   141         return m_variantMapValue;

   142     }

   143     void setVariantMapProperty(const QVariantMap &value) {

   144         m_variantMapValue = value;

   145     }

   146 

   147     QString stringProperty() const {

   148         return m_stringValue;

   149     }

   150     void setStringProperty(const QString &value) {

   151         m_stringValue = value;

   152     }

   153 

   154     QStringList stringListProperty() const {

   155         return m_stringListValue;

   156     }

   157     void setStringListProperty(const QStringList &value) {

   158         m_stringListValue = value;

   159     }

   160 

   161     QByteArray byteArrayProperty() const {

   162         return m_byteArrayValue;

   163     }

   164     void setByteArrayProperty(const QByteArray &value) {

   165         m_byteArrayValue = value;

   166     }

   167 

   168     QBrush brushProperty() const {

   169         return m_brushValue;

   170     }

   171     Q_INVOKABLE void setBrushProperty(const QBrush &value) {

   172         m_brushValue = value;

   173     }

   174 

   175     double hiddenProperty() const {

   176         return m_hiddenValue;

   177     }

   178     void setHiddenProperty(double value) {

   179         m_hiddenValue = value;

   180     }

   181 

   182     int writeOnlyProperty() const {

   183         return m_writeOnlyValue;

   184     }

   185     void setWriteOnlyProperty(int value) {

   186         m_writeOnlyValue = value;

   187     }

   188 

   189     int readOnlyProperty() const {

   190         return m_readOnlyValue;

   191     }

   192 

   193     QKeySequence shortcut() const {

   194         return m_shortcut;

   195     }

   196     void setShortcut(const QKeySequence &seq) {

   197         m_shortcut = seq;

   198     }

   199 

   200     QWebElement webElementProperty() const {

   201         return m_webElement;

   202     }

   203 

   204     void setWebElementProperty(const QWebElement& element) {

   205         m_webElement = element;

   206     }

   207 

   208     CustomType propWithCustomType() const {

   209         return m_customType;

   210     }

   211     void setPropWithCustomType(const CustomType &c) {

   212         m_customType = c;

   213     }

   214 

   215     QObject* objectStarProperty() const {

   216         return m_objectStar;

   217     }

   218 

   219     void setObjectStarProperty(QObject* object) {

   220         m_objectStar = object;

   221     }

   222 

   223 

   224     int qtFunctionInvoked() const {

   225         return m_qtFunctionInvoked;

   226     }

   227 

   228     QVariantList qtFunctionActuals() const {

   229         return m_actuals;

   230     }

   231 

   232     void resetQtFunctionInvoked() {

   233         m_qtFunctionInvoked = -1;

   234         m_actuals.clear();

   235     }

   236 

   237     Q_INVOKABLE void myInvokable() {

   238         m_qtFunctionInvoked = 0;

   239     }

   240     Q_INVOKABLE void myInvokableWithIntArg(int arg) {

   241         m_qtFunctionInvoked = 1;

   242         m_actuals << arg;

   243     }

   244     Q_INVOKABLE void myInvokableWithLonglongArg(qlonglong arg) {

   245         m_qtFunctionInvoked = 2;

   246         m_actuals << arg;

   247     }

   248     Q_INVOKABLE void myInvokableWithFloatArg(float arg) {

   249         m_qtFunctionInvoked = 3;

   250         m_actuals << arg;

   251     }

   252     Q_INVOKABLE void myInvokableWithDoubleArg(double arg) {

   253         m_qtFunctionInvoked = 4;

   254         m_actuals << arg;

   255     }

   256     Q_INVOKABLE void myInvokableWithStringArg(const QString &arg) {

   257         m_qtFunctionInvoked = 5;

   258         m_actuals << arg;

   259     }

   260     Q_INVOKABLE void myInvokableWithIntArgs(int arg1, int arg2) {

   261         m_qtFunctionInvoked = 6;

   262         m_actuals << arg1 << arg2;

   263     }

   264     Q_INVOKABLE int myInvokableReturningInt() {

   265         m_qtFunctionInvoked = 7;

   266         return 123;

   267     }

   268     Q_INVOKABLE qlonglong myInvokableReturningLongLong() {

   269         m_qtFunctionInvoked = 39;

   270         return 456;

   271     }

   272     Q_INVOKABLE QString myInvokableReturningString() {

   273         m_qtFunctionInvoked = 8;

   274         return QLatin1String("ciao");

   275     }

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

   277         m_qtFunctionInvoked = 9;

   278         m_actuals << arg1 << arg2;

   279     }

   280     Q_INVOKABLE void myInvokableWithEnumArg(Policy policy) {

   281         m_qtFunctionInvoked = 10;

   282         m_actuals << policy;

   283     }

   284     Q_INVOKABLE void myInvokableWithQualifiedEnumArg(MyQObject::Policy policy) {

   285         m_qtFunctionInvoked = 36;

   286         m_actuals << policy;

   287     }

   288     Q_INVOKABLE Policy myInvokableReturningEnum() {

   289         m_qtFunctionInvoked = 37;

   290         return BazPolicy;

   291     }

   292     Q_INVOKABLE MyQObject::Policy myInvokableReturningQualifiedEnum() {

   293         m_qtFunctionInvoked = 38;

   294         return BazPolicy;

   295     }

   296     Q_INVOKABLE QVector<int> myInvokableReturningVectorOfInt() {

   297         m_qtFunctionInvoked = 11;

   298         return QVector<int>();

   299     }

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

   301         m_qtFunctionInvoked = 12;

   302     }

   303     Q_INVOKABLE QObject* myInvokableReturningQObjectStar() {

   304         m_qtFunctionInvoked = 13;

   305         return this;

   306     }

   307     Q_INVOKABLE QObjectList myInvokableWithQObjectListArg(const QObjectList &lst) {

   308         m_qtFunctionInvoked = 14;

   309         m_actuals << qVariantFromValue(lst);

   310         return lst;

   311     }

   312     Q_INVOKABLE QVariant myInvokableWithVariantArg(const QVariant &v) {

   313         m_qtFunctionInvoked = 15;

   314         m_actuals << v;

   315         return v;

   316     }

   317     Q_INVOKABLE QVariantMap myInvokableWithVariantMapArg(const QVariantMap &vm) {

   318         m_qtFunctionInvoked = 16;

   319         m_actuals << vm;

   320         return vm;

   321     }

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

   323         m_qtFunctionInvoked = 17;

   324         m_actuals << qVariantFromValue(lst);

   325         return lst;

   326     }

   327     Q_INVOKABLE QObject* myInvokableWithQObjectStarArg(QObject* obj) {

   328         m_qtFunctionInvoked = 18;

   329         m_actuals << qVariantFromValue(obj);

   330         return obj;

   331     }

   332     Q_INVOKABLE QBrush myInvokableWithQBrushArg(const QBrush &brush) {

   333         m_qtFunctionInvoked = 19;

   334         m_actuals << qVariantFromValue(brush);

   335         return brush;

   336     }

   337     Q_INVOKABLE void myInvokableWithBrushStyleArg(Qt::BrushStyle style) {

   338         m_qtFunctionInvoked = 43;

   339         m_actuals << qVariantFromValue(style);

   340     }

   341     Q_INVOKABLE void myInvokableWithVoidStarArg(void* arg) {

   342         m_qtFunctionInvoked = 44;

   343         m_actuals << qVariantFromValue(arg);

   344     }

   345     Q_INVOKABLE void myInvokableWithAmbiguousArg(int arg) {

   346         m_qtFunctionInvoked = 45;

   347         m_actuals << qVariantFromValue(arg);

   348     }

   349     Q_INVOKABLE void myInvokableWithAmbiguousArg(uint arg) {

   350         m_qtFunctionInvoked = 46;

   351         m_actuals << qVariantFromValue(arg);

   352     }

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

   354         m_qtFunctionInvoked = 47;

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

   356     }

   357     Q_INVOKABLE QObject& myInvokableReturningRef() {

   358         m_qtFunctionInvoked = 48;

   359         return *this;

   360     }

   361     Q_INVOKABLE const QObject& myInvokableReturningConstRef() const {

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

   363         return *this;

   364     }

   365     Q_INVOKABLE void myInvokableWithPointArg(const QPoint &arg) {

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

   367         m_actuals << qVariantFromValue(arg);

   368     }

   369     Q_INVOKABLE void myInvokableWithPointArg(const QPointF &arg) {

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

   371         m_actuals << qVariantFromValue(arg);

   372     }

   373     Q_INVOKABLE void myInvokableWithBoolArg(bool arg) {

   374         m_qtFunctionInvoked = 52;

   375         m_actuals << arg;

   376     }

   377 

   378     void emitMySignal() {

   379         emit mySignal();

   380     }

   381     void emitMySignalWithIntArg(int arg) {

   382         emit mySignalWithIntArg(arg);

   383     }

   384     void emitMySignal2(bool arg) {

   385         emit mySignal2(arg);

   386     }

   387     void emitMySignal2() {

   388         emit mySignal2();

   389     }

   390     void emitMySignalWithDateTimeArg(QDateTime dt) {

   391         emit mySignalWithDateTimeArg(dt);

   392     }

   393     void emitMySignalWithRegexArg(QRegExp r) {

   394         emit mySignalWithRegexArg(r);

   395     }

   396 

   397 public Q_SLOTS:

   398     void mySlot() {

   399         m_qtFunctionInvoked = 20;

   400     }

   401     void mySlotWithIntArg(int arg) {

   402         m_qtFunctionInvoked = 21;

   403         m_actuals << arg;

   404     }

   405     void mySlotWithDoubleArg(double arg) {

   406         m_qtFunctionInvoked = 22;

   407         m_actuals << arg;

   408     }

   409     void mySlotWithStringArg(const QString &arg) {

   410         m_qtFunctionInvoked = 23;

   411         m_actuals << arg;

   412     }

   413 

   414     void myOverloadedSlot() {

   415         m_qtFunctionInvoked = 24;

   416     }

   417     void myOverloadedSlot(QObject* arg) {

   418         m_qtFunctionInvoked = 41;

   419         m_actuals << qVariantFromValue(arg);

   420     }

   421     void myOverloadedSlot(bool arg) {

   422         m_qtFunctionInvoked = 25;

   423         m_actuals << arg;

   424     }

   425     void myOverloadedSlot(const QStringList &arg) {

   426         m_qtFunctionInvoked = 42;

   427         m_actuals << arg;

   428     }

   429     void myOverloadedSlot(double arg) {

   430         m_qtFunctionInvoked = 26;

   431         m_actuals << arg;

   432     }

   433     void myOverloadedSlot(float arg) {

   434         m_qtFunctionInvoked = 27;

   435         m_actuals << arg;

   436     }

   437     void myOverloadedSlot(int arg) {

   438         m_qtFunctionInvoked = 28;

   439         m_actuals << arg;

   440     }

   441     void myOverloadedSlot(const QString &arg) {

   442         m_qtFunctionInvoked = 29;

   443         m_actuals << arg;

   444     }

   445     void myOverloadedSlot(const QColor &arg) {

   446         m_qtFunctionInvoked = 30;

   447         m_actuals << arg;

   448     }

   449     void myOverloadedSlot(const QBrush &arg) {

   450         m_qtFunctionInvoked = 31;

   451         m_actuals << arg;

   452     }

   453     void myOverloadedSlot(const QDateTime &arg) {

   454         m_qtFunctionInvoked = 32;

   455         m_actuals << arg;

   456     }

   457     void myOverloadedSlot(const QDate &arg) {

   458         m_qtFunctionInvoked = 33;

   459         m_actuals << arg;

   460     }

   461     void myOverloadedSlot(const QRegExp &arg) {

   462         m_qtFunctionInvoked = 34;

   463         m_actuals << arg;

   464     }

   465     void myOverloadedSlot(const QVariant &arg) {

   466         m_qtFunctionInvoked = 35;

   467         m_actuals << arg;

   468     }

   469     void myOverloadedSlot(const QWebElement &arg) {

   470         m_qtFunctionInvoked = 36;

   471         m_actuals << QVariant::fromValue<QWebElement>(arg);

   472     }

   473 

   474     void qscript_call(int arg) {

   475         m_qtFunctionInvoked = 40;

   476         m_actuals << arg;

   477     }

   478 

   479 protected Q_SLOTS:

   480     void myProtectedSlot() {

   481         m_qtFunctionInvoked = 36;

   482     }

   483 

   484 private Q_SLOTS:

   485     void myPrivateSlot() { }

   486 

   487 Q_SIGNALS:

   488     void mySignal();

   489     void mySignalWithIntArg(int arg);

   490     void mySignalWithDoubleArg(double arg);

   491     void mySignal2(bool arg = false);

   492     void mySignalWithDateTimeArg(QDateTime dt);

   493     void mySignalWithRegexArg(QRegExp r);

   494 

   495 private:

   496     int m_intValue;

   497     QVariant m_variantValue;

   498     QVariantList m_variantListValue;

   499     QVariantMap m_variantMapValue;

   500     QString m_stringValue;

   501     QStringList m_stringListValue;

   502     QByteArray m_byteArrayValue;

   503     QBrush m_brushValue;

   504     double m_hiddenValue;

   505     int m_writeOnlyValue;

   506     int m_readOnlyValue;

   507     QKeySequence m_shortcut;

   508     QWebElement m_webElement;

   509     CustomType m_customType;

   510     QObject* m_objectStar;

   511     int m_qtFunctionInvoked;

   512     QVariantList m_actuals;

   513 };

   514 

   515 class MyOtherQObject : public MyQObject

   516 {

   517 public:

   518     MyOtherQObject(QObject* parent = 0)

   519         : MyQObject(parent) { }

   520 };

   521 

   522 class MyEnumTestQObject : public QObject

   523 {

   524     Q_OBJECT

   525     Q_PROPERTY(QString p1 READ p1)

   526     Q_PROPERTY(QString p2 READ p2)

   527     Q_PROPERTY(QString p3 READ p3 SCRIPTABLE false)

   528     Q_PROPERTY(QString p4 READ p4)

   529     Q_PROPERTY(QString p5 READ p5 SCRIPTABLE false)

   530     Q_PROPERTY(QString p6 READ p6)

   531 public:

   532     MyEnumTestQObject(QObject* parent = 0)

   533         : QObject(parent) { }

   534     QString p1() const {

   535         return QLatin1String("p1");

   536     }

   537     QString p2() const {

   538         return QLatin1String("p2");

   539     }

   540     QString p3() const {

   541         return QLatin1String("p3");

   542     }

   543     QString p4() const {

   544         return QLatin1String("p4");

   545     }

   546     QString p5() const {

   547         return QLatin1String("p5");

   548     }

   549     QString p6() const {

   550         return QLatin1String("p5");

   551     }

   552 public Q_SLOTS:

   553     void mySlot() { }

   554     void myOtherSlot() { }

   555 Q_SIGNALS:

   556     void mySignal();

   557 };

   558 

   559 class tst_QWebFrame : public QObject

   560 {

   561     Q_OBJECT

   562 

   563 public:

   564     tst_QWebFrame();

   565     virtual ~tst_QWebFrame();

   566     bool eventFilter(QObject* watched, QEvent* event);

   567 

   568 public slots:

   569     void init();

   570     void cleanup();

   571 

   572 private slots:

   573     void getSetStaticProperty();

   574     void getSetDynamicProperty();

   575     void getSetChildren();

   576     void callQtInvokable();

   577     void connectAndDisconnect();

   578     void classEnums();

   579     void classConstructor();

   580     void overrideInvokable();

   581     void transferInvokable();

   582     void findChild();

   583     void findChildren();

   584     void overloadedSlots();

   585     void enumerate_data();

   586     void enumerate();

   587     void objectDeleted();

   588     void typeConversion();

   589     void arrayObjectEnumerable();

   590     void symmetricUrl();

   591     void progressSignal();

   592     void urlChange();

   593     void domCycles();

   594     void requestedUrl();

   595     void javaScriptWindowObjectCleared_data();

   596     void javaScriptWindowObjectCleared();

   597     void javaScriptWindowObjectClearedOnEvaluate();

   598     void setHtml();

   599     void setHtmlWithResource();

   600     void setHtmlWithBaseURL();

   601     void setHtmlWithJSAlert();

   602     void ipv6HostEncoding();

   603     void metaData();

   604 #if !defined(Q_WS_MAEMO_5)

   605     // as maemo 5 does not use QComboBoxes to implement the popups

   606     // this test does not make sense for it.

   607     void popupFocus();

   608 #endif

   609     void inputFieldFocus();

   610     void hitTestContent();

   611     void jsByteArray();

   612     void ownership();

   613     void nullValue();

   614     void baseUrl_data();

   615     void baseUrl();

   616     void hasSetFocus();

   617     void render();

   618     void scrollPosition();

   619     void scrollToAnchor();

   620     void scrollbarsOff();

   621     void evaluateWillCauseRepaint();

   622     void qObjectWrapperWithSameIdentity();

   623     void introspectQtMethods_data();

   624     void introspectQtMethods();

   625 

   626 private:

   627     QString  evalJS(const QString&s) {

   628         // Convert an undefined return variant to the string "undefined"

   629         QVariant ret = evalJSV(s);

   630         if (ret.userType() == QMetaType::Void)

   631             return "undefined";

   632         else

   633             return ret.toString();

   634     }

   635     QVariant evalJSV(const QString &s) {

   636         return m_page->mainFrame()->evaluateJavaScript(s);

   637     }

   638 

   639     QString  evalJS(const QString&s, QString& type) {

   640         return evalJSV(s, type).toString();

   641     }

   642     QVariant evalJSV(const QString &s, QString& type) {

   643         // As a special measure, if we get an exception we set the type to 'error'

   644         // (in ecma, an Error object has typeof object, but qtscript has a convenience function)

   645         // Similarly, an array is an object, but we'd prefer to have a type of 'array'

   646         // Also, consider a QMetaType::Void QVariant to be undefined

   647         QString escaped = s;

   648         escaped.replace('\'', "\\'"); // Don't preescape your single quotes!

   649         evalJS("var retvalue;\

   650                var typevalue; \

   651                try {\

   652                retvalue = eval('" + escaped + "'); \

   653                typevalue = typeof retvalue; \

   654                if (retvalue instanceof Array) \

   655                typevalue = 'array'; \

   656            } \

   657                catch(e) {\

   658                retvalue = e.name + ': ' + e.message;\

   659                typevalue = 'error';\

   660            }");

   661         QVariant ret = evalJSV("retvalue");

   662         if (ret.userType() != QMetaType::Void)

   663             type = evalJS("typevalue");

   664         else {

   665             ret = QString("undefined");

   666             type = sUndefined;

   667         }

   668         evalJS("delete retvalue; delete typevalue");

   669         return ret;

   670     }

   671     QObject* firstChildByClassName(QObject* parent, const char* className) {

   672         const QObjectList & children = parent->children();

   673         foreach (QObject* child, children) {

   674             if (!strcmp(child->metaObject()->className(), className)) {

   675                 return child;

   676             }

   677         }

   678         return 0;

   679     }

   680 

   681     const QString sTrue;

   682     const QString sFalse;

   683     const QString sUndefined;

   684     const QString sArray;

   685     const QString sFunction;

   686     const QString sError;

   687     const QString sString;

   688     const QString sObject;

   689     const QString sNumber;

   690 

   691 private:

   692     QWebView* m_view;

   693     QWebPage* m_page;

   694     MyQObject* m_myObject;

   695     QWebView* m_inputFieldsTestView;

   696     int m_inputFieldTestPaintCount;

   697 };

   698 

   699 tst_QWebFrame::tst_QWebFrame()

   700     : sTrue("true"), sFalse("false"), sUndefined("undefined"), sArray("array"), sFunction("function"), sError("error"),

   701         sString("string"), sObject("object"), sNumber("number"), m_inputFieldsTestView(0), m_inputFieldTestPaintCount(0)

   702 {

   703 }

   704 

   705 tst_QWebFrame::~tst_QWebFrame()

   706 {

   707 }

   708 

   709 bool tst_QWebFrame::eventFilter(QObject* watched, QEvent* event)

   710 {

   711     // used on the inputFieldFocus test

   712     if (watched == m_inputFieldsTestView) {

   713         if (event->type() == QEvent::Paint)

   714             m_inputFieldTestPaintCount++;

   715     }

   716     return QObject::eventFilter(watched, event);

   717 }

   718 

   719 void tst_QWebFrame::init()

   720 {

   721     m_view = new QWebView();

   722     m_page = m_view->page();

   723     m_myObject = new MyQObject();

   724     m_page->mainFrame()->addToJavaScriptWindowObject("myObject", m_myObject);

   725 }

   726 

   727 void tst_QWebFrame::cleanup()

   728 {

   729     delete m_view;

   730     delete m_myObject;

   731 }

   732 

   733 void tst_QWebFrame::getSetStaticProperty()

   734 {

   735     m_page->mainFrame()->setHtml("<html><head><body></body></html>");

   736     QCOMPARE(evalJS("typeof myObject.noSuchProperty"), sUndefined);

   737 

   738     // initial value (set in MyQObject constructor)

   739     {

   740         QString type;

   741         QVariant ret = evalJSV("myObject.intProperty", type);

   742         QCOMPARE(type, sNumber);

   743         QCOMPARE(ret.type(), QVariant::Double);

   744         QCOMPARE(ret.toInt(), 123);

   745     }

   746     QCOMPARE(evalJS("myObject.intProperty === 123.0"), sTrue);

   747 

   748     {

   749         QString type;

   750         QVariant ret = evalJSV("myObject.variantProperty", type);

   751         QCOMPARE(type, sString);

   752         QCOMPARE(ret.type(), QVariant::String);

   753         QCOMPARE(ret.toString(), QLatin1String("foo"));

   754     }

   755     QCOMPARE(evalJS("myObject.variantProperty == 'foo'"), sTrue);

   756 

   757     {

   758         QString type;

   759         QVariant ret = evalJSV("myObject.stringProperty", type);

   760         QCOMPARE(type, sString);

   761         QCOMPARE(ret.type(), QVariant::String);

   762         QCOMPARE(ret.toString(), QLatin1String("bar"));

   763     }

   764     QCOMPARE(evalJS("myObject.stringProperty === 'bar'"), sTrue);

   765 

   766     {

   767         QString type;

   768         QVariant ret = evalJSV("myObject.variantListProperty", type);

   769         QCOMPARE(type, sArray);

   770         QCOMPARE(ret.type(), QVariant::List);

   771         QVariantList vl = ret.value<QVariantList>();

   772         QCOMPARE(vl.size(), 2);

   773         QCOMPARE(vl.at(0).toInt(), 123);

   774         QCOMPARE(vl.at(1).toString(), QLatin1String("foo"));

   775     }

   776     QCOMPARE(evalJS("myObject.variantListProperty.length === 2"), sTrue);

   777     QCOMPARE(evalJS("myObject.variantListProperty[0] === 123"), sTrue);

   778     QCOMPARE(evalJS("myObject.variantListProperty[1] === 'foo'"), sTrue);

   779 

   780     {

   781         QString type;

   782         QVariant ret = evalJSV("myObject.variantMapProperty", type);

   783         QCOMPARE(type, sObject);

   784         QCOMPARE(ret.type(), QVariant::Map);

   785         QVariantMap vm = ret.value<QVariantMap>();

   786         QCOMPARE(vm.size(), 3);

   787         QCOMPARE(vm.value("a").toInt(), 123);

   788         QCOMPARE(vm.value("b").toString(), QLatin1String("foo"));

   789         QCOMPARE(vm.value("c").value<QObject*>(), static_cast<QObject*>(m_myObject));

   790     }

   791     QCOMPARE(evalJS("myObject.variantMapProperty.a === 123"), sTrue);

   792     QCOMPARE(evalJS("myObject.variantMapProperty.b === 'foo'"), sTrue);

   793     QCOMPARE(evalJS("myObject.variantMapProperty.c.variantMapProperty.b === 'foo'"), sTrue);

   794 

   795     {

   796         QString type;

   797         QVariant ret = evalJSV("myObject.stringListProperty", type);

   798         QCOMPARE(type, sArray);

   799         QCOMPARE(ret.type(), QVariant::List);

   800         QVariantList vl = ret.value<QVariantList>();

   801         QCOMPARE(vl.size(), 2);

   802         QCOMPARE(vl.at(0).toString(), QLatin1String("zig"));

   803         QCOMPARE(vl.at(1).toString(), QLatin1String("zag"));

   804     }

   805     QCOMPARE(evalJS("myObject.stringListProperty.length === 2"), sTrue);

   806     QCOMPARE(evalJS("typeof myObject.stringListProperty[0]"), sString);

   807     QCOMPARE(evalJS("myObject.stringListProperty[0]"), QLatin1String("zig"));

   808     QCOMPARE(evalJS("typeof myObject.stringListProperty[1]"), sString);

   809     QCOMPARE(evalJS("myObject.stringListProperty[1]"), QLatin1String("zag"));

   810 

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

   812     m_myObject->setIntProperty(456);

   813     QCOMPARE(evalJS("myObject.intProperty == 456"), sTrue);

   814     m_myObject->setIntProperty(789);

   815     QCOMPARE(evalJS("myObject.intProperty == 789"), sTrue);

   816 

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

   818     QCOMPARE(evalJS("myObject.variantProperty === 'bar'"), sTrue);

   819     m_myObject->setVariantProperty(42);

   820     QCOMPARE(evalJS("myObject.variantProperty === 42"), sTrue);

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

   822 //XFAIL

   823 //  QCOMPARE(evalJS("typeof myObject.variantProperty"), sVariant);

   824 

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

   826     QCOMPARE(evalJS("myObject.stringProperty === 'baz'"), sTrue);

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

   828     QCOMPARE(evalJS("myObject.stringProperty === 'zab'"), sTrue);

   829 

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

   831     QCOMPARE(evalJS("myObject.intProperty = 123"), QLatin1String("123"));

   832     QCOMPARE(evalJS("myObject.intProperty == 123"), sTrue);

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

   834     QCOMPARE(evalJS("myObject.intProperty = 'ciao!';"

   835                     "myObject.intProperty == 0"), sTrue);

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

   837     QCOMPARE(evalJS("myObject.intProperty = '123';"

   838                     "myObject.intProperty == 123"), sTrue);

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

   840 

   841     QCOMPARE(evalJS("myObject.stringProperty = 'ciao'"), QLatin1String("ciao"));

   842     QCOMPARE(evalJS("myObject.stringProperty"), QLatin1String("ciao"));

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

   844     QCOMPARE(evalJS("myObject.stringProperty = 123;"

   845                     "myObject.stringProperty"), QLatin1String("123"));

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

   847     QCOMPARE(evalJS("myObject.stringProperty = null"), QString());

   848     QCOMPARE(evalJS("myObject.stringProperty"), QString());

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

   850     QCOMPARE(evalJS("myObject.stringProperty = undefined"), sUndefined);

   851     QCOMPARE(evalJS("myObject.stringProperty"), QString());

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

   853 

   854     QCOMPARE(evalJS("myObject.variantProperty = new Number(1234);"

   855                     "myObject.variantProperty").toDouble(), 1234.0);

   856     QCOMPARE(m_myObject->variantProperty().toDouble(), 1234.0);

   857 

   858     QCOMPARE(evalJS("myObject.variantProperty = new Boolean(1234);"

   859                     "myObject.variantProperty"), sTrue);

   860     QCOMPARE(m_myObject->variantProperty().toBool(), true);

   861 

   862     QCOMPARE(evalJS("myObject.variantProperty = null;"

   863                     "myObject.variantProperty.valueOf()"), sUndefined);

   864     QCOMPARE(m_myObject->variantProperty(), QVariant());

   865     QCOMPARE(evalJS("myObject.variantProperty = undefined;"

   866                     "myObject.variantProperty.valueOf()"), sUndefined);

   867     QCOMPARE(m_myObject->variantProperty(), QVariant());

   868 

   869     QCOMPARE(evalJS("myObject.variantProperty = 'foo';"

   870                     "myObject.variantProperty.valueOf()"), QLatin1String("foo"));

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

   872     QCOMPARE(evalJS("myObject.variantProperty = 42;"

   873                     "myObject.variantProperty").toDouble(), 42.0);

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

   875 

   876     QCOMPARE(evalJS("myObject.variantListProperty = [1, 'two', true];"

   877                     "myObject.variantListProperty.length == 3"), sTrue);

   878     QCOMPARE(evalJS("myObject.variantListProperty[0] === 1"), sTrue);

   879     QCOMPARE(evalJS("myObject.variantListProperty[1]"), QLatin1String("two"));

   880     QCOMPARE(evalJS("myObject.variantListProperty[2] === true"), sTrue);

   881 

   882     QCOMPARE(evalJS("myObject.stringListProperty = [1, 'two', true];"

   883                     "myObject.stringListProperty.length == 3"), sTrue);

   884     QCOMPARE(evalJS("typeof myObject.stringListProperty[0]"), sString);

   885     QCOMPARE(evalJS("myObject.stringListProperty[0] == '1'"), sTrue);

   886     QCOMPARE(evalJS("typeof myObject.stringListProperty[1]"), sString);

   887     QCOMPARE(evalJS("myObject.stringListProperty[1]"), QLatin1String("two"));

   888     QCOMPARE(evalJS("typeof myObject.stringListProperty[2]"), sString);

   889     QCOMPARE(evalJS("myObject.stringListProperty[2]"), QLatin1String("true"));

   890     evalJS("myObject.webElementProperty=document.body;");

   891     QCOMPARE(evalJS("myObject.webElementProperty.tagName"), QLatin1String("BODY"));

   892 

   893     // try to delete

   894     QCOMPARE(evalJS("delete myObject.intProperty"), sFalse);

   895     QCOMPARE(evalJS("myObject.intProperty == 123"), sTrue);

   896 

   897     QCOMPARE(evalJS("delete myObject.variantProperty"), sFalse);

   898     QCOMPARE(evalJS("myObject.variantProperty").toDouble(), 42.0);

   899 

   900     // custom property

   901     QCOMPARE(evalJS("myObject.customProperty"), sUndefined);

   902     QCOMPARE(evalJS("myObject.customProperty = 123;"

   903                     "myObject.customProperty == 123"), sTrue);

   904     QVariant v = m_page->mainFrame()->evaluateJavaScript("myObject.customProperty");

   905     QCOMPARE(v.type(), QVariant::Double);

   906     QCOMPARE(v.toInt(), 123);

   907 

   908     // non-scriptable property

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

   910     QCOMPARE(evalJS("myObject.hiddenProperty"), sUndefined);

   911     QCOMPARE(evalJS("myObject.hiddenProperty = 123;"

   912                     "myObject.hiddenProperty == 123"), sTrue);

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

   914 

   915     // write-only property

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

   917     QCOMPARE(evalJS("typeof myObject.writeOnlyProperty"), sUndefined);

   918     QCOMPARE(evalJS("myObject.writeOnlyProperty = 123;"

   919                     "typeof myObject.writeOnlyProperty"), sUndefined);

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

   921 

   922     // read-only property

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

   924     QCOMPARE(evalJS("myObject.readOnlyProperty == 987"), sTrue);

   925     QCOMPARE(evalJS("myObject.readOnlyProperty = 654;"

   926                     "myObject.readOnlyProperty == 987"), sTrue);

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

   928 

   929     // QObject* property

   930     m_myObject->setObjectStarProperty(0);

   931     QCOMPARE(m_myObject->objectStarProperty(), (QObject*)0);

   932     QCOMPARE(evalJS("myObject.objectStarProperty == null"), sTrue);

   933     QCOMPARE(evalJS("typeof myObject.objectStarProperty"), sObject);

   934     QCOMPARE(evalJS("Boolean(myObject.objectStarProperty)"), sFalse);

   935     QCOMPARE(evalJS("String(myObject.objectStarProperty) == 'null'"), sTrue);

   936     QCOMPARE(evalJS("myObject.objectStarProperty.objectStarProperty"),

   937         sUndefined);

   938     m_myObject->setObjectStarProperty(this);

   939     QCOMPARE(evalJS("myObject.objectStarProperty != null"), sTrue);

   940     QCOMPARE(evalJS("typeof myObject.objectStarProperty"), sObject);

   941     QCOMPARE(evalJS("Boolean(myObject.objectStarProperty)"), sTrue);

   942     QCOMPARE(evalJS("String(myObject.objectStarProperty) != 'null'"), sTrue);

   943 }

   944 

   945 void tst_QWebFrame::getSetDynamicProperty()

   946 {

   947     // initially the object does not have the property

   948     // In WebKit, RuntimeObjects do not inherit Object, so don't have hasOwnProperty

   949 

   950     //QCOMPARE(evalJS("myObject.hasOwnProperty('dynamicProperty')"), sFalse);

   951     QCOMPARE(evalJS("typeof myObject.dynamicProperty"), sUndefined);

   952 

   953     // add a dynamic property in C++

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

   955     //QCOMPARE(evalJS("myObject.hasOwnProperty('dynamicProperty')"), sTrue);

   956     QCOMPARE(evalJS("typeof myObject.dynamicProperty != 'undefined'"), sTrue);

   957     QCOMPARE(evalJS("myObject.dynamicProperty == 123"), sTrue);

   958 

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

   960     QCOMPARE(evalJS("myObject.dynamicProperty = 'foo';"

   961                     "myObject.dynamicProperty"), QLatin1String("foo"));

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

   963 

   964     // delete the property (XFAIL - can't delete properties)

   965     QEXPECT_FAIL("", "can't delete properties", Continue);

   966     QCOMPARE(evalJS("delete myObject.dynamicProperty"), sTrue);

   967     /*

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

   969     QCOMPARE(evalJS("typeof myObject.dynamicProperty"), sUndefined);

   970     //    QCOMPARE(evalJS("myObject.hasOwnProperty('dynamicProperty')"), sFalse);

   971     QCOMPARE(evalJS("typeof myObject.dynamicProperty"), sUndefined);

   972     */

   973 }

   974 

   975 void tst_QWebFrame::getSetChildren()

   976 {

   977     // initially the object does not have the child

   978     // (again, no hasOwnProperty)

   979 

   980     //QCOMPARE(evalJS("myObject.hasOwnProperty('child')"), sFalse);

   981     QCOMPARE(evalJS("typeof myObject.child"), sUndefined);

   982 

   983     // add a child

   984     MyQObject* child = new MyQObject(m_myObject);

   985     child->setObjectName("child");

   986 //  QCOMPARE(evalJS("myObject.hasOwnProperty('child')"), sTrue);

   987     QCOMPARE(evalJS("typeof myObject.child != 'undefined'"), sTrue);

   988 

   989     // add a grandchild

   990     MyQObject* grandChild = new MyQObject(child);

   991     grandChild->setObjectName("grandChild");

   992 //  QCOMPARE(evalJS("myObject.child.hasOwnProperty('grandChild')"), sTrue);

   993     QCOMPARE(evalJS("typeof myObject.child.grandChild != 'undefined'"), sTrue);

   994 

   995     // delete grandchild

   996     delete grandChild;

   997 //  QCOMPARE(evalJS("myObject.child.hasOwnProperty('grandChild')"), sFalse);

   998     QCOMPARE(evalJS("typeof myObject.child.grandChild == 'undefined'"), sTrue);

   999 

  1000     // delete child

  1001     delete child;

  1002 //  QCOMPARE(evalJS("myObject.hasOwnProperty('child')"), sFalse);

  1003     QCOMPARE(evalJS("typeof myObject.child == 'undefined'"), sTrue);

  1004 }

  1005 

  1006 Q_DECLARE_METATYPE(QVector<int>)

  1007 Q_DECLARE_METATYPE(QVector<double>)

  1008 Q_DECLARE_METATYPE(QVector<QString>)

  1009 

  1010 void tst_QWebFrame::callQtInvokable()

  1011 {

  1012     qRegisterMetaType<QObjectList>();

  1013 

  1014     m_myObject->resetQtFunctionInvoked();

  1015     QCOMPARE(evalJS("typeof myObject.myInvokable()"), sUndefined);

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

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

  1018 

  1019     // extra arguments should silently be ignored

  1020     m_myObject->resetQtFunctionInvoked();

  1021     QCOMPARE(evalJS("typeof myObject.myInvokable(10, 20, 30)"), sUndefined);

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

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

  1024 

  1025     m_myObject->resetQtFunctionInvoked();

  1026     QCOMPARE(evalJS("typeof myObject.myInvokableWithIntArg(123)"), sUndefined);

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

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

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

  1030 

  1031     m_myObject->resetQtFunctionInvoked();

  1032     QCOMPARE(evalJS("typeof myObject.myInvokableWithIntArg('123')"), sUndefined);

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

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

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

  1036 

  1037     m_myObject->resetQtFunctionInvoked();

  1038     QCOMPARE(evalJS("typeof myObject.myInvokableWithLonglongArg(123)"), sUndefined);

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

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

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

  1042 

  1043     m_myObject->resetQtFunctionInvoked();

  1044     QCOMPARE(evalJS("typeof myObject.myInvokableWithFloatArg(123.5)"), sUndefined);

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

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

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

  1048 

  1049     m_myObject->resetQtFunctionInvoked();

  1050     QCOMPARE(evalJS("typeof myObject.myInvokableWithDoubleArg(123.5)"), sUndefined);

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

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

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

  1054 

  1055     m_myObject->resetQtFunctionInvoked();

  1056     QCOMPARE(evalJS("typeof myObject.myInvokableWithDoubleArg(new Number(1234.5))"), sUndefined);

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

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

  1059     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toDouble(), 1234.5);

  1060 

  1061     m_myObject->resetQtFunctionInvoked();

  1062     QCOMPARE(evalJS("typeof myObject.myInvokableWithBoolArg(new Boolean(true))"), sUndefined);

  1063     QCOMPARE(m_myObject->qtFunctionInvoked(), 52);

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

  1065     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toBool(), true);

  1066 

  1067     m_myObject->resetQtFunctionInvoked();

  1068     QCOMPARE(evalJS("typeof myObject.myInvokableWithStringArg('ciao')"), sUndefined);

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

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

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

  1072 

  1073     m_myObject->resetQtFunctionInvoked();

  1074     QCOMPARE(evalJS("typeof myObject.myInvokableWithStringArg(123)"), sUndefined);

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

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

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

  1078 

  1079     m_myObject->resetQtFunctionInvoked();

  1080     QCOMPARE(evalJS("typeof myObject.myInvokableWithStringArg(null)"), sUndefined);

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

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

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

  1084     QVERIFY(m_myObject->qtFunctionActuals().at(0).toString().isEmpty());

  1085 

  1086     m_myObject->resetQtFunctionInvoked();

  1087     QCOMPARE(evalJS("typeof myObject.myInvokableWithStringArg(undefined)"), sUndefined);

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

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

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

  1091     QVERIFY(m_myObject->qtFunctionActuals().at(0).toString().isEmpty());

  1092 

  1093     m_myObject->resetQtFunctionInvoked();

  1094     QCOMPARE(evalJS("typeof myObject.myInvokableWithIntArgs(123, 456)"), sUndefined);

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

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

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

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

  1099 

  1100     m_myObject->resetQtFunctionInvoked();

  1101     QCOMPARE(evalJS("myObject.myInvokableReturningInt()"), QLatin1String("123"));

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

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

  1104 

  1105     m_myObject->resetQtFunctionInvoked();

  1106     QCOMPARE(evalJS("myObject.myInvokableReturningLongLong()"), QLatin1String("456"));

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

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

  1109 

  1110     m_myObject->resetQtFunctionInvoked();

  1111     QCOMPARE(evalJS("myObject.myInvokableReturningString()"), QLatin1String("ciao"));

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

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

  1114 

  1115     m_myObject->resetQtFunctionInvoked();

  1116     QCOMPARE(evalJS("typeof myObject.myInvokableWithIntArg(123, 456)"), sUndefined);

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

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

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

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

  1121 

  1122     m_myObject->resetQtFunctionInvoked();

  1123     QCOMPARE(evalJS("typeof myObject.myInvokableWithVoidStarArg(null)"), sUndefined);

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

  1125     m_myObject->resetQtFunctionInvoked();

  1126     {

  1127         QString type;

  1128         QString ret = evalJS("myObject.myInvokableWithVoidStarArg(123)", type);

  1129         QCOMPARE(type, sError);

  1130         QCOMPARE(ret, QLatin1String("TypeError: incompatible type of argument(s) in call to myInvokableWithVoidStarArg(); candidates were\n    myInvokableWithVoidStarArg(void*)"));

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

  1132     }

  1133 

  1134     m_myObject->resetQtFunctionInvoked();

  1135     {