tests/auto/qscriptclass/tst_qscriptclass.cpp
changeset 19 fcece45ef507
parent 18 2f34d5167611
child 30 5dc02b23752f
equal deleted inserted replaced
18:2f34d5167611 19:fcece45ef507
    96 
    96 
    97     enum CallableMode {
    97     enum CallableMode {
    98         NotCallable,
    98         NotCallable,
    99         CallableReturnsSum,
    99         CallableReturnsSum,
   100         CallableReturnsArgument,
   100         CallableReturnsArgument,
   101         CallableReturnsInvalidVariant
   101         CallableReturnsInvalidVariant,
       
   102         CallableReturnsGlobalObject,
       
   103         CallableReturnsThisObject,
       
   104         CallableReturnsCallee,
       
   105         CallableReturnsArgumentsObject,
       
   106         CallableInitializesThisObject
   102     };
   107     };
   103 
   108 
   104     TestClass(QScriptEngine *engine);
   109     TestClass(QScriptEngine *engine);
   105     ~TestClass();
   110     ~TestClass();
   106 
   111 
   346         QScriptContext *ctx = qvariant_cast<QScriptContext*>(argument);
   351         QScriptContext *ctx = qvariant_cast<QScriptContext*>(argument);
   347         if (m_callableMode == CallableReturnsSum) {
   352         if (m_callableMode == CallableReturnsSum) {
   348             qsreal sum = 0;
   353             qsreal sum = 0;
   349             for (int i = 0; i < ctx->argumentCount(); ++i)
   354             for (int i = 0; i < ctx->argumentCount(); ++i)
   350                 sum += ctx->argument(i).toNumber();
   355                 sum += ctx->argument(i).toNumber();
   351             QScriptValueIterator it(ctx->thisObject());
   356             QScriptValueIterator it(ctx->callee());
   352             while (it.hasNext()) {
   357             while (it.hasNext()) {
   353                 it.next();
   358                 it.next();
   354                 sum += it.value().toNumber();
   359                 sum += it.value().toNumber();
   355             }
   360             }
   356             return sum;
   361             return sum;
   357         } else if (m_callableMode == CallableReturnsArgument) {
   362         } else if (m_callableMode == CallableReturnsArgument) {
   358             return qVariantFromValue(ctx->argument(0));
   363             return qVariantFromValue(ctx->argument(0));
   359         } else if (m_callableMode == CallableReturnsInvalidVariant) {
   364         } else if (m_callableMode == CallableReturnsInvalidVariant) {
       
   365             return QVariant();
       
   366         } else if (m_callableMode == CallableReturnsGlobalObject) {
       
   367             return qVariantFromValue(engine()->globalObject());
       
   368         } else if (m_callableMode == CallableReturnsThisObject) {
       
   369             return qVariantFromValue(ctx->thisObject());
       
   370         } else if (m_callableMode == CallableReturnsCallee) {
       
   371             return qVariantFromValue(ctx->callee());
       
   372         } else if (m_callableMode == CallableReturnsArgumentsObject) {
       
   373             return qVariantFromValue(ctx->argumentsObject());
       
   374         } else if (m_callableMode == CallableInitializesThisObject) {
       
   375             engine()->newQObject(ctx->thisObject(), engine());
   360             return QVariant();
   376             return QVariant();
   361         }
   377         }
   362     } else if (extension == HasInstance) {
   378     } else if (extension == HasInstance) {
   363         Q_ASSERT(m_hasInstance);
   379         Q_ASSERT(m_hasInstance);
   364         QScriptValueList args = qvariant_cast<QScriptValueList>(argument);
   380         QScriptValueList args = qvariant_cast<QScriptValueList>(argument);
   794         TestClass cls(&eng);
   810         TestClass cls(&eng);
   795         cls.setCallableMode(TestClass::CallableReturnsSum);
   811         cls.setCallableMode(TestClass::CallableReturnsSum);
   796         QVERIFY(cls.supportsExtension(QScriptClass::Callable));
   812         QVERIFY(cls.supportsExtension(QScriptClass::Callable));
   797 
   813 
   798         QScriptValue obj = eng.newObject(&cls);
   814         QScriptValue obj = eng.newObject(&cls);
       
   815         eng.globalObject().setProperty("obj", obj);
   799         obj.setProperty("one", QScriptValue(&eng, 1));
   816         obj.setProperty("one", QScriptValue(&eng, 1));
   800         obj.setProperty("two", QScriptValue(&eng, 2));
   817         obj.setProperty("two", QScriptValue(&eng, 2));
   801         obj.setProperty("three", QScriptValue(&eng, 3));
   818         obj.setProperty("three", QScriptValue(&eng, 3));
       
   819         // From C++
   802         cls.clearReceivedArgs();
   820         cls.clearReceivedArgs();
   803         {
   821         {
   804             QScriptValueList args;
   822             QScriptValueList args;
   805             args << QScriptValue(&eng, 4) << QScriptValue(&eng, 5);
   823             args << QScriptValue(&eng, 4) << QScriptValue(&eng, 5);
   806             QScriptValue ret = obj.call(obj, args);
   824             QScriptValue ret = obj.call(obj, args);
   807             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
   825             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
   808             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
   826             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
   809             QVERIFY(ret.isNumber());
   827             QVERIFY(ret.isNumber());
   810             QCOMPARE(ret.toNumber(), qsreal(15));
   828             QCOMPARE(ret.toNumber(), qsreal(15));
   811         }
   829         }
       
   830         // From JS
       
   831         cls.clearReceivedArgs();
       
   832         {
       
   833             QScriptValue ret = eng.evaluate("obj(4, 5)");
       
   834             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
       
   835             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
       
   836             QVERIFY(ret.isNumber());
       
   837             QCOMPARE(ret.toNumber(), qsreal(15));
       
   838         }
   812 
   839 
   813         cls.setCallableMode(TestClass::CallableReturnsArgument);
   840         cls.setCallableMode(TestClass::CallableReturnsArgument);
       
   841         // From C++
   814         cls.clearReceivedArgs();
   842         cls.clearReceivedArgs();
   815         {
   843         {
   816             QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
   844             QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
   817             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
   845             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
   818             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
   846             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
   840         }
   868         }
   841         {
   869         {
   842             QScriptValue ret = obj.call(obj, QScriptValueList() << QScriptValue());
   870             QScriptValue ret = obj.call(obj, QScriptValueList() << QScriptValue());
   843             QVERIFY(ret.isUndefined());
   871             QVERIFY(ret.isUndefined());
   844         }
   872         }
       
   873         // From JS
       
   874         cls.clearReceivedArgs();
       
   875         {
       
   876             QScriptValue ret = eng.evaluate("obj(123)");
       
   877             QVERIFY(ret.isNumber());
       
   878             QCOMPARE(ret.toInt32(), 123);
       
   879         }
   845 
   880 
   846         cls.setCallableMode(TestClass::CallableReturnsInvalidVariant);
   881         cls.setCallableMode(TestClass::CallableReturnsInvalidVariant);
   847         {
   882         {
   848             QScriptValue ret = obj.call(obj);
   883             QScriptValue ret = obj.call(obj);
   849             QVERIFY(ret.isUndefined());
   884             QVERIFY(ret.isUndefined());
   850         }
   885         }
   851 
   886 
       
   887         cls.setCallableMode(TestClass::CallableReturnsThisObject);
       
   888         // From C++
       
   889         {
       
   890             QScriptValue ret = obj.call(obj);
       
   891             QVERIFY(ret.isObject());
       
   892             QVERIFY(ret.strictlyEquals(obj));
       
   893         }
       
   894         // From JS
       
   895         {
       
   896             QScriptValue ret = eng.evaluate("obj()");
       
   897             QVERIFY(ret.isObject());
       
   898             QVERIFY(ret.strictlyEquals(eng.globalObject()));
       
   899         }
       
   900 
       
   901         cls.setCallableMode(TestClass::CallableReturnsCallee);
       
   902         // From C++
       
   903         {
       
   904             QScriptValue ret = obj.call();
       
   905             QVERIFY(ret.isObject());
       
   906             QVERIFY(ret.strictlyEquals(obj));
       
   907         }
       
   908         // From JS
       
   909         {
       
   910             QScriptValue ret = eng.evaluate("obj()");
       
   911             QVERIFY(ret.isObject());
       
   912             QVERIFY(ret.strictlyEquals(obj));
       
   913         }
       
   914 
       
   915         cls.setCallableMode(TestClass::CallableReturnsArgumentsObject);
       
   916         // From C++
       
   917         {
       
   918             QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
       
   919             QVERIFY(ret.isObject());
       
   920             QVERIFY(ret.property("length").isNumber());
       
   921             QCOMPARE(ret.property("length").toInt32(), 1);
       
   922             QVERIFY(ret.property(0).isNumber());
       
   923             QCOMPARE(ret.property(0).toInt32(), 123);
       
   924         }
       
   925         // From JS
       
   926         {
       
   927             QScriptValue ret = eng.evaluate("obj(123)");
       
   928             QVERIFY(ret.isObject());
       
   929             QVERIFY(ret.property("length").isNumber());
       
   930             QCOMPARE(ret.property("length").toInt32(), 1);
       
   931             QVERIFY(ret.property(0).isNumber());
       
   932             QCOMPARE(ret.property(0).toInt32(), 123);
       
   933         }
       
   934 
   852         // construct()
   935         // construct()
   853         cls.clearReceivedArgs();
   936         // From C++
       
   937         cls.clearReceivedArgs();
       
   938         cls.setCallableMode(TestClass::CallableReturnsGlobalObject);
   854         {
   939         {
   855             QScriptValue ret = obj.construct();
   940             QScriptValue ret = obj.construct();
   856             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
   941             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
   857             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
   942             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
   858             QVERIFY(ret.isObject());
   943             QVERIFY(ret.isObject());
       
   944             QVERIFY(ret.strictlyEquals(eng.globalObject()));
       
   945         }
       
   946         // From JS
       
   947         cls.clearReceivedArgs();
       
   948         {
       
   949             QScriptValue ret = eng.evaluate("new obj()");
       
   950             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
       
   951             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
       
   952             QVERIFY(ret.isObject());
       
   953             QVERIFY(ret.strictlyEquals(eng.globalObject()));
       
   954         }
       
   955         // From C++
       
   956         cls.clearReceivedArgs();
       
   957         cls.setCallableMode(TestClass::CallableInitializesThisObject);
       
   958         {
       
   959             QScriptValue ret = obj.construct();
       
   960             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
       
   961             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
       
   962             QVERIFY(ret.isQObject());
       
   963             QCOMPARE(ret.toQObject(), (QObject*)&eng);
       
   964         }
       
   965         // From JS
       
   966         cls.clearReceivedArgs();
       
   967         {
       
   968             QScriptValue ret = eng.evaluate("new obj()");
       
   969             QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
       
   970             QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
       
   971             QVERIFY(ret.isQObject());
       
   972             QCOMPARE(ret.toQObject(), (QObject*)&eng);
   859         }
   973         }
   860     }
   974     }
   861     // HasInstance
   975     // HasInstance
   862     {
   976     {
   863         TestClass cls(&eng);
   977         TestClass cls(&eng);