**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
+** Contact: http://www.qt-project.org/
**
** This file is part of the test suite of the Qt Toolkit.
**
{
QScriptValue fun = eng.newFunction(myFunction);
QCOMPARE(fun.isValid(), true);
- QCOMPARE(fun.isFunction(), true);
+ QCOMPARE(fun.isCallable(), true);
QCOMPARE(fun.isObject(), true);
QCOMPARE(fun.scriptClass(), (QScriptClass*)0);
// a prototype property is automatically constructed
}
// prototype should be Function.prototype
QCOMPARE(fun.prototype().isValid(), true);
- QCOMPARE(fun.prototype().isFunction(), true);
+ QCOMPARE(fun.prototype().isCallable(), true);
QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true);
QCOMPARE(fun.call().isNull(), true);
- QCOMPARE(fun.construct().isObject(), true);
+ QCOMPARE(fun.callAsConstructor().isObject(), true);
}
}
QScriptEngine eng;
{
QScriptValue fun = eng.newFunction(myFunctionWithVoidArg, (void*)this);
- QVERIFY(fun.isFunction());
+ QVERIFY(fun.isCallable());
QCOMPARE(fun.scriptClass(), (QScriptClass*)0);
// a prototype property is automatically constructed
{
}
// prototype should be Function.prototype
QCOMPARE(fun.prototype().isValid(), true);
- QCOMPARE(fun.prototype().isFunction(), true);
+ QCOMPARE(fun.prototype().isCallable(), true);
QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true);
QCOMPARE(fun.call().isNull(), true);
- QCOMPARE(fun.construct().isObject(), true);
+ QCOMPARE(fun.callAsConstructor().isObject(), true);
}
}
QScriptValue proto = eng.newObject();
QScriptValue fun = eng.newFunction(myFunction, proto);
QCOMPARE(fun.isValid(), true);
- QCOMPARE(fun.isFunction(), true);
+ QCOMPARE(fun.isCallable(), true);
QCOMPARE(fun.isObject(), true);
// internal prototype should be Function.prototype
QCOMPARE(fun.prototype().isValid(), true);
- QCOMPARE(fun.prototype().isFunction(), true);
+ QCOMPARE(fun.prototype().isCallable(), true);
QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true);
// public prototype should be the one we passed
QCOMPARE(fun.property("prototype").strictlyEquals(proto), true);
QCOMPARE(proto.propertyFlags("constructor"), QScriptValue::SkipInEnumeration);
QCOMPARE(fun.call().isNull(), true);
- QCOMPARE(fun.construct().isObject(), true);
+ QCOMPARE(fun.callAsConstructor().isObject(), true);
}
// whether the return value is correct
{
QScriptValue fun = eng.newFunction(myFunctionThatReturns);
QCOMPARE(fun.isValid(), true);
- QCOMPARE(fun.isFunction(), true);
+ QCOMPARE(fun.isCallable(), true);
QCOMPARE(fun.isObject(), true);
QScriptValue result = fun.call();
{
QScriptValue fun = eng.newFunction(myFunctionThatReturnsWithoutEngine);
QCOMPARE(fun.isValid(), true);
- QCOMPARE(fun.isFunction(), true);
+ QCOMPARE(fun.isCallable(), true);
QCOMPARE(fun.isObject(), true);
QScriptValue result = fun.call();
QScriptValue fun = eng.newFunction(myFunctionThatReturnsWrongEngine, reinterpret_cast<void *>(&wrongEngine));
QCOMPARE(fun.isValid(), true);
- QCOMPARE(fun.isFunction(), true);
+ QCOMPARE(fun.isCallable(), true);
QCOMPARE(fun.isObject(), true);
QTest::ignoreMessage(QtWarningMsg, "QScriptValue::call(): Value from different engine returned from native function, returning undefined value instead.");
QScriptValue fun = eng.newFunction(sumFunction);
QCOMPARE(fun.isValid(), true);
- QCOMPARE(fun.isFunction(), true);
+ QCOMPARE(fun.isCallable(), true);
QCOMPARE(fun.isObject(), true);
QScriptValue result = fun.call();
QJSValue object = eng.newObject();
QCOMPARE(object.isValid(), true);
QCOMPARE(object.isObject(), true);
- QCOMPARE(object.isFunction(), false);
+ QCOMPARE(object.isCallable(), false);
// ###FIXME: No QScriptClass QCOMPARE(object.scriptClass(), (QScriptClass*)0);
// prototype should be Object.prototype
QCOMPARE(object.prototype().isValid(), true);
QCOMPARE(array.isValid(), true);
QCOMPARE(array.isArray(), true);
QCOMPARE(array.isObject(), true);
- QVERIFY(!array.isFunction());
+ QVERIFY(!array.isCallable());
// ###FIXME: No QScriptClass QCOMPARE(array.scriptClass(), (QScriptClass*)0);
// prototype should be Array.prototype
QCOMPARE(array.prototype().isValid(), true);
QJSValue opaque = eng.newVariant(QVariant());
QCOMPARE(opaque.isValid(), true);
QCOMPARE(opaque.isVariant(), true);
- QVERIFY(!opaque.isFunction());
+ QVERIFY(!opaque.isCallable());
QCOMPARE(opaque.isObject(), true);
QCOMPARE(opaque.prototype().isValid(), true);
QEXPECT_FAIL("", "FIXME: newly created QObject's prototype is an JS Object", Continue);
QCOMPARE(opaque.prototype().isVariant(), true);
- QVERIFY(opaque.property("valueOf").call(opaque).isUndefined());
+ QVERIFY(opaque.property("valueOf").callWithInstance(opaque).isUndefined());
}
}
QJSEngine eng;
{
QJSValue object = eng.newVariant(QVariant(123));
- QJSValue value = object.property("valueOf").call(object);
+ QJSValue value = object.property("valueOf").callWithInstance(object);
QVERIFY(value.isNumber());
QCOMPARE(value.toInt(), 123);
QCOMPARE(object.toString(), QString::fromLatin1("123"));
}
{
QJSValue object = eng.newVariant(QVariant(QString::fromLatin1("hello")));
- QJSValue value = object.property("valueOf").call(object);
+ QJSValue value = object.property("valueOf").callWithInstance(object);
QVERIFY(value.isString());
QCOMPARE(value.toString(), QString::fromLatin1("hello"));
QCOMPARE(object.toString(), QString::fromLatin1("hello"));
}
{
QJSValue object = eng.newVariant(QVariant(false));
- QJSValue value = object.property("valueOf").call(object);
+ QJSValue value = object.property("valueOf").callWithInstance(object);
QVERIFY(value.isBool());
QCOMPARE(value.toBool(), false);
QCOMPARE(object.toString(), QString::fromLatin1("false"));
}
{
QJSValue object = eng.newVariant(QVariant(QPoint(10, 20)));
- QJSValue value = object.property("valueOf").call(object);
+ QJSValue value = object.property("valueOf").callWithInstance(object);
QVERIFY(value.isObject());
QVERIFY(value.strictlyEquals(object));
QCOMPARE(object.toString(), QString::fromLatin1("QVariant(QPoint)"));
QCOMPARE(rexp.isValid(), true);
QCOMPARE(rexp.isRegExp(), true);
QCOMPARE(rexp.isObject(), true);
- QVERIFY(rexp.isFunction()); // in JSC, RegExp objects are callable
+ QVERIFY(rexp.isCallable()); // in JSC, RegExp objects are callable
// prototype should be RegExp.prototype
QCOMPARE(rexp.prototype().isValid(), true);
QCOMPARE(rexp.prototype().isObject(), true);
QCOMPARE(r.toString(), QString::fromLatin1("/foo/gim"));
QJSValue rxCtor = eng.globalObject().property("RegExp");
- QJSValue r2 = rxCtor.call(QJSValue(), QJSValueList() << r);
+ QJSValue r2 = rxCtor.call(QJSValueList() << r);
QVERIFY(r2.isRegExp());
QVERIFY(r2.strictlyEquals(r));
- QJSValue r3 = rxCtor.call(QJSValue(), QJSValueList() << r << "gim");
+ QJSValue r3 = rxCtor.call(QJSValueList() << r << "gim");
QVERIFY(r3.isError());
QVERIFY(r3.toString().contains(QString::fromLatin1("TypeError"))); // Cannot supply flags when constructing one RegExp from another
- QJSValue r4 = rxCtor.call(QJSValue(), QJSValueList() << "foo" << "gim");
+ QJSValue r4 = rxCtor.call(QJSValueList() << "foo" << "gim");
QVERIFY(r4.isRegExp());
- QJSValue r5 = rxCtor.construct(QJSValueList() << r);
+ QJSValue r5 = rxCtor.callAsConstructor(QJSValueList() << r);
QVERIFY(r5.isRegExp());
QCOMPARE(r5.toString(), QString::fromLatin1("/foo/gim"));
// In JSC, constructing a RegExp from another produces the same identical object.
QVERIFY(!r5.strictlyEquals(r));
QEXPECT_FAIL("", "V8 and jsc ignores invalid flags", Continue); //https://bugs.webkit.org/show_bug.cgi?id=41614
- QJSValue r6 = rxCtor.construct(QJSValueList() << "foo" << "bar");
+ QJSValue r6 = rxCtor.callAsConstructor(QJSValueList() << "foo" << "bar");
QVERIFY(r6.isError());
// QVERIFY(r6.toString().contains(QString::fromLatin1("SyntaxError"))); // Invalid regular expression flag
QVERIFY(r8.isRegExp());
QCOMPARE(r8.toString(), QString::fromLatin1("/foo/gim"));
- QJSValue r9 = rxCtor.construct();
+ QJSValue r9 = rxCtor.callAsConstructor();
QVERIFY(r9.isRegExp());
QCOMPARE(r9.toString(), QString::fromLatin1("/(?:)/"));
- QJSValue r10 = rxCtor.construct(QJSValueList() << "" << "gim");
+ QJSValue r10 = rxCtor.callAsConstructor(QJSValueList() << "" << "gim");
QVERIFY(r10.isRegExp());
QCOMPARE(r10.toString(), QString::fromLatin1("/(?:)/gim"));
- QJSValue r11 = rxCtor.construct(QJSValueList() << "{1.*}" << "g");
+ QJSValue r11 = rxCtor.callAsConstructor(QJSValueList() << "{1.*}" << "g");
QVERIFY(r11.isRegExp());
QCOMPARE(r11.toString(), QString::fromLatin1("/{1.*}/g"));
}
QCOMPARE(date.isValid(), true);
QCOMPARE(date.isDate(), true);
QCOMPARE(date.isObject(), true);
- QVERIFY(!date.isFunction());
+ QVERIFY(!date.isCallable());
// prototype should be Date.prototype
QCOMPARE(date.prototype().isValid(), true);
QCOMPARE(date.prototype().isDate(), true);
QCOMPARE(qobject.isQObject(), true);
QCOMPARE(qobject.isObject(), true);
QCOMPARE(qobject.toQObject(), (QObject *)this);
- QVERIFY(!qobject.isFunction());
+ QVERIFY(!qobject.isCallable());
// prototype should be QObject.prototype
QCOMPARE(qobject.prototype().isValid(), true);
QEXPECT_FAIL("", "FIXME: newly created QObject's prototype is an JS Object", Continue);
static QScriptValue instanceofJS(const QScriptValue &inst, const QScriptValue &ctor)
{
return inst.engine()->evaluate("(function(inst, ctor) { return inst instanceof ctor; })")
- .call(QScriptValue(), QScriptValueList() << inst << ctor);
+ .call(QScriptValueList() << inst << ctor);
}
void tst_QJSEngine::newQMetaObject()
QCOMPARE(qclass.isValid(), true);
QCOMPARE(qclass.isQMetaObject(), true);
QCOMPARE(qclass.toQMetaObject(), &QObject::staticMetaObject);
- QCOMPARE(qclass.isFunction(), true);
+ QCOMPARE(qclass.isCallable(), true);
QVERIFY(qclass.property("prototype").isObject());
QCOMPARE(qclass2.isValid(), true);
QCOMPARE(qclass2.isQMetaObject(), true);
QCOMPARE(qclass2.toQMetaObject(), &QWidget::staticMetaObject);
- QCOMPARE(qclass2.isFunction(), true);
+ QCOMPARE(qclass2.isCallable(), true);
QVERIFY(qclass2.property("prototype").isObject());
// prototype should be QMetaObject.prototype
QCOMPARE(qclass.prototype().isObject(), true);
QCOMPARE(qclass2.prototype().isObject(), true);
- QScriptValue instance = qclass.construct();
+ QScriptValue instance = qclass.callAsConstructor();
QCOMPARE(instance.isQObject(), true);
QCOMPARE(instance.toQObject()->metaObject(), qclass.toQMetaObject());
QEXPECT_FAIL("", "FIXME: newQMetaObject not implemented properly yet", Abort);
QVERIFY(instance.instanceOf(qclass));
QVERIFY(instanceofJS(instance, qclass).strictlyEquals(true));
- QScriptValue instance2 = qclass2.construct();
+ QScriptValue instance2 = qclass2.callAsConstructor();
QCOMPARE(instance2.isQObject(), true);
QCOMPARE(instance2.toQObject()->metaObject(), qclass2.toQMetaObject());
QVERIFY(instance2.instanceOf(qclass2));
QScriptValueList args;
args << instance;
- QScriptValue instance3 = qclass.construct(args);
+ QScriptValue instance3 = qclass.callAsConstructor(args);
QCOMPARE(instance3.isQObject(), true);
QCOMPARE(instance3.toQObject()->parent(), instance.toQObject());
QVERIFY(instance3.instanceOf(qclass));
QVERIFY(instanceofJS(ret, qclass).strictlyEquals(false));
}
{
- QScriptValue ret = qclass3.construct();
+ QScriptValue ret = qclass3.callAsConstructor();
QVERIFY(ret.isObject());
QVERIFY(ret.property("isCalledAsConstructor").isBool());
QVERIFY(ret.property("isCalledAsConstructor").toBool());
}
// subclassing
- qclass2.setProperty("prototype", qclass.construct());
- QVERIFY(qclass2.construct().instanceOf(qclass));
- QVERIFY(instanceofJS(qclass2.construct(), qclass).strictlyEquals(true));
+ qclass2.setProperty("prototype", qclass.callAsConstructor());
+ QVERIFY(qclass2.callAsConstructor().instanceOf(qclass));
+ QVERIFY(instanceofJS(qclass2.callAsConstructor(), qclass).strictlyEquals(true));
// with meta-constructor
QScriptValue qclass4 = eng.newQMetaObject(&QObject::staticMetaObject);
{
- QScriptValue inst = qclass4.construct();
+ QScriptValue inst = qclass4.callAsConstructor();
QVERIFY(inst.isQObject());
QVERIFY(inst.toQObject() != 0);
QCOMPARE(inst.toQObject()->parent(), (QObject*)0);
QVERIFY(instanceofJS(inst, qclass3).strictlyEquals(false));
}
{
- QScriptValue inst = qclass4.construct(QScriptValueList() << eng.newQObject(this));
+ QScriptValue inst = qclass4.callAsConstructor(QScriptValueList() << eng.newQObject(this));
QVERIFY(inst.isQObject());
QVERIFY(inst.toQObject() != 0);
QCOMPARE(inst.toQObject()->parent(), (QObject*)this);
QCOMPARE(act.isValid(), true);
QEXPECT_FAIL("", "", Continue);
QCOMPARE(act.isObject(), true);
- QVERIFY(!act.isFunction());
+ QVERIFY(!act.isCallable());
QScriptValue v(&eng, 123);
act.setProperty("prop", v);
QEXPECT_FAIL("", "", Continue);
glob = eng.globalObject();
QCOMPARE(glob.isValid(), true);
QCOMPARE(glob.isObject(), true);
- QVERIFY(!glob.isFunction());
+ QVERIFY(!glob.isCallable());
QVERIFY(eng.currentContext()->thisObject().strictlyEquals(glob));
QVERIFY(eng.currentContext()->activationObject().strictlyEquals(glob));
QEXPECT_FAIL("", "FIXME: Do we really want to enforce this? ECMA standard says that it is implementation dependent, skipping for now", Continue);
//the custom global object have an interceptor
QVERIFY(eng.evaluate("this.__defineGetter__('oof', function() { return this.bar; })").isUndefined());
QVERIFY(eng.evaluate("this.__defineSetter__('oof', function(v) { this.bar = v; })").isUndefined());
- QVERIFY(eng.evaluate("this.__lookupGetter__('oof')").isFunction());
- QVERIFY(eng.evaluate("this.__lookupSetter__('oof')").isFunction());
+ QVERIFY(eng.evaluate("this.__lookupGetter__('oof')").isCallable());
+ QVERIFY(eng.evaluate("this.__lookupSetter__('oof')").isCallable());
eng.evaluate("oof = 123");
QVERIFY(eng.evaluate("oof").equals(obj.property("bar")));
QVERIFY(global.property("undefined").isUndefined());
QCOMPARE(global.propertyFlags("undefined"), QJSValue::SkipInEnumeration | QJSValue::Undeletable);
- QVERIFY(global.property("eval").isFunction());
+ QVERIFY(global.property("eval").isCallable());
QCOMPARE(global.propertyFlags("eval"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("parseInt").isFunction());
+ QVERIFY(global.property("parseInt").isCallable());
QCOMPARE(global.propertyFlags("parseInt"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("parseFloat").isFunction());
+ QVERIFY(global.property("parseFloat").isCallable());
QCOMPARE(global.propertyFlags("parseFloat"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("isNaN").isFunction());
+ QVERIFY(global.property("isNaN").isCallable());
QCOMPARE(global.propertyFlags("isNaN"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("isFinite").isFunction());
+ QVERIFY(global.property("isFinite").isCallable());
QCOMPARE(global.propertyFlags("isFinite"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("decodeURI").isFunction());
+ QVERIFY(global.property("decodeURI").isCallable());
QCOMPARE(global.propertyFlags("decodeURI"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("decodeURIComponent").isFunction());
+ QVERIFY(global.property("decodeURIComponent").isCallable());
QCOMPARE(global.propertyFlags("decodeURIComponent"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("encodeURI").isFunction());
+ QVERIFY(global.property("encodeURI").isCallable());
QCOMPARE(global.propertyFlags("encodeURI"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("encodeURIComponent").isFunction());
+ QVERIFY(global.property("encodeURIComponent").isCallable());
QCOMPARE(global.propertyFlags("encodeURIComponent"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Object").isFunction());
+ QVERIFY(global.property("Object").isCallable());
QCOMPARE(global.propertyFlags("Object"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Function").isFunction());
+ QVERIFY(global.property("Function").isCallable());
QCOMPARE(global.propertyFlags("Function"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Array").isFunction());
+ QVERIFY(global.property("Array").isCallable());
QCOMPARE(global.propertyFlags("Array"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("String").isFunction());
+ QVERIFY(global.property("String").isCallable());
QCOMPARE(global.propertyFlags("String"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Boolean").isFunction());
+ QVERIFY(global.property("Boolean").isCallable());
QCOMPARE(global.propertyFlags("Boolean"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Number").isFunction());
+ QVERIFY(global.property("Number").isCallable());
QCOMPARE(global.propertyFlags("Number"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Date").isFunction());
+ QVERIFY(global.property("Date").isCallable());
QCOMPARE(global.propertyFlags("Date"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("RegExp").isFunction());
+ QVERIFY(global.property("RegExp").isCallable());
QCOMPARE(global.propertyFlags("RegExp"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("Error").isFunction());
+ QVERIFY(global.property("Error").isCallable());
QCOMPARE(global.propertyFlags("Error"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("EvalError").isFunction());
+ QVERIFY(global.property("EvalError").isCallable());
QCOMPARE(global.propertyFlags("EvalError"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("RangeError").isFunction());
+ QVERIFY(global.property("RangeError").isCallable());
QCOMPARE(global.propertyFlags("RangeError"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("ReferenceError").isFunction());
+ QVERIFY(global.property("ReferenceError").isCallable());
QCOMPARE(global.propertyFlags("ReferenceError"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("SyntaxError").isFunction());
+ QVERIFY(global.property("SyntaxError").isCallable());
QCOMPARE(global.propertyFlags("SyntaxError"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("TypeError").isFunction());
+ QVERIFY(global.property("TypeError").isCallable());
QCOMPARE(global.propertyFlags("TypeError"), QJSValue::SkipInEnumeration);
- QVERIFY(global.property("URIError").isFunction());
+ QVERIFY(global.property("URIError").isCallable());
QCOMPARE(global.propertyFlags("URIError"), QJSValue::SkipInEnumeration);
QVERIFY(global.property("Math").isObject());
- QVERIFY(!global.property("Math").isFunction());
+ QVERIFY(!global.property("Math").isCallable());
QCOMPARE(global.propertyFlags("Math"), QJSValue::SkipInEnumeration);
}
}
{
QScriptValue ret = engine.evaluate("print");
- QVERIFY(ret.isFunction());
+ QVERIFY(ret.isCallable());
QVERIFY(ret.strictlyEquals(wrap.property("print")));
}
{
QScriptValue ret = engine.evaluate("this.print");
- QVERIFY(ret.isFunction());
+ QVERIFY(ret.isCallable());
QVERIFY(ret.strictlyEquals(wrap.property("print")));
}
{
global.setPrototype(anotherProto);
{
QScriptValue ret = engine.evaluate("print");
- QVERIFY(ret.isFunction());
+ QVERIFY(ret.isCallable());
QVERIFY(ret.strictlyEquals(wrap.property("print")));
}
{
}
{
QScriptValue ret = engine.evaluate("print");
- QVERIFY(ret.isFunction());
+ QVERIFY(ret.isCallable());
QVERIFY(ret.strictlyEquals(global.property("print")));
}
QVERIFY(!anotherProto.property("print").isValid());
}
// From QScriptValue::call()
{
- QScriptValue result = fun.call(eng.evaluate("p = { id:'foo' }") , QScriptValueList() );
+ QScriptValue result = fun.callWithInstance(eng.evaluate("p = { id:'foo' }") , QScriptValueList() );
QCOMPARE(result.property("local_bar").toString(), QString("local"));
QCOMPARE(result.property("thisObjectIdBefore").toString(), QString("foo"));
QCOMPARE(result.property("thisObjectIdAfter").toString(), QString("foo"));
static QScriptValue recurse2(QScriptContext *ctx, QScriptEngine *eng)
{
Q_UNUSED(eng);
- return ctx->callee().construct();
+ return ctx->callee().callAsConstructor();
}
void tst_QJSEngine::infiniteRecursion()
}
{
QScriptValue fun = eng.newFunction(recurse2);
- QScriptValue ret = fun.construct();
+ QScriptValue ret = fun.callAsConstructor();
QCOMPARE(ret.isError(), true);
QCOMPARE(ret.toString(), stackOverflowError);
}
Zoo zoo;
QScriptValue scriptZoo = eng.newQObject(&zoo);
QScriptValue toBaz = scriptZoo.property("toBaz");
- QVERIFY(toBaz.isFunction());
+ QVERIFY(toBaz.isCallable());
// no relation between Bar and Baz's proto --> casting fails
{
}
{
- QScriptValue ret = toBaz.call(scriptZoo, QScriptValueList() << baz2Value);
+ QScriptValue ret = toBaz.callWithInstance(scriptZoo, QScriptValueList() << baz2Value);
QVERIFY(ret.isError());
QCOMPARE(ret.toString(), QLatin1String("TypeError: incompatible type of argument(s) in call to toBaz(); candidates were\n toBaz(Bar*)"));
}
}
{
- QScriptValue ret = toBaz.call(scriptZoo, QScriptValueList() << baz2Value);
+ QScriptValue ret = toBaz.callWithInstance(scriptZoo, QScriptValueList() << baz2Value);
QEXPECT_FAIL("", "Cannot convert Baz* to Bar*", Continue);
QVERIFY(!ret.isError());
QEXPECT_FAIL("", "Cannot convert Baz* to Bar*", Continue);
QCOMPARE(eng.processEventsInterval(), 100);
if (x) script.call();
- else script.construct();
+ else script.callAsConstructor();
QVERIFY(!eng.hasUncaughtException());
QVERIFY(receiver.received);
// This behavior is not documented.
QJSEngine eng;
QtMsgHandler oldHandler = qInstallMsgHandler(myMsgHandler);
- QVERIFY(eng.globalObject().property("print").isFunction());
+ QVERIFY(eng.globalObject().property("print").isCallable());
theMessageType = QtSystemMsg;
QVERIFY(theMessage.isEmpty());
QCOMPARE(ret.toNumber(), qreal(456));
}
- QVERIFY(proto.property("toString").isFunction());
+ QVERIFY(proto.property("toString").isCallable());
{
QJSValue ret = eng.evaluate("new Number(123).toString()");
QVERIFY(ret.isString());
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("7b"));
}
- QVERIFY(proto.property("toLocaleString").isFunction());
+ QVERIFY(proto.property("toLocaleString").isCallable());
{
QJSValue ret = eng.evaluate("new Number(123).toLocaleString()");
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("123"));
}
- QVERIFY(proto.property("valueOf").isFunction());
+ QVERIFY(proto.property("valueOf").isCallable());
{
QJSValue ret = eng.evaluate("new Number(123).valueOf()");
QVERIFY(ret.isNumber());
QCOMPARE(ret.toNumber(), qreal(123));
}
- QVERIFY(proto.property("toExponential").isFunction());
+ QVERIFY(proto.property("toExponential").isCallable());
{
QJSValue ret = eng.evaluate("new Number(123).toExponential()");
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("1.23e+2"));
}
- QVERIFY(proto.property("toFixed").isFunction());
+ QVERIFY(proto.property("toFixed").isCallable());
{
QJSValue ret = eng.evaluate("new Number(123).toFixed()");
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("123"));
}
- QVERIFY(proto.property("toPrecision").isFunction());
+ QVERIFY(proto.property("toPrecision").isCallable());
{
QJSValue ret = eng.evaluate("new Number(123).toPrecision()");
QVERIFY(ret.isString());
"}");
QVERIFY(!eng.globalObject().property("bar").isValid());
QVERIFY(!eng.globalObject().property("baz").isValid());
- QVERIFY(eng.evaluate("foo").isFunction());
+ QVERIFY(eng.evaluate("foo").isCallable());
{
QJSValue ret = eng.evaluate("foo('bar')");
- QVERIFY(ret.isFunction());
- QJSValue ret2 = ret.call(QJSValue());
+ QVERIFY(ret.isCallable());
+ QJSValue ret2 = ret.call();
QCOMPARE(ret2.toString(), QString::fromLatin1("bar"));
QVERIFY(!eng.globalObject().property("bar").isValid());
QVERIFY(!eng.globalObject().property("baz").isValid());
}
{
QJSValue ret = eng.evaluate("foo('baz')");
- QVERIFY(ret.isFunction());
- QJSValue ret2 = ret.call(QJSValue());
+ QVERIFY(ret.isCallable());
+ QJSValue ret2 = ret.call();
QCOMPARE(ret2.toString(), QString::fromLatin1("baz"));
QVERIFY(!eng.globalObject().property("bar").isValid());
QVERIFY(!eng.globalObject().property("baz").isValid());
QVERIFY(!global.property("String").property("prototype").property("arg").isValid());
eng.installTranslatorFunctions();
- QVERIFY(global.property("qsTranslate").isFunction());
- QVERIFY(global.property("QT_TRANSLATE_NOOP").isFunction());
- QVERIFY(global.property("qsTr").isFunction());
- QVERIFY(global.property("QT_TR_NOOP").isFunction());
- QVERIFY(global.property("qsTrId").isFunction());
- QVERIFY(global.property("QT_TRID_NOOP").isFunction());
- QVERIFY(global.property("String").property("prototype").property("arg").isFunction());
+ QVERIFY(global.property("qsTranslate").isCallable());
+ QVERIFY(global.property("QT_TRANSLATE_NOOP").isCallable());
+ QVERIFY(global.property("qsTr").isCallable());
+ QVERIFY(global.property("QT_TR_NOOP").isCallable());
+ QVERIFY(global.property("qsTrId").isCallable());
+ QVERIFY(global.property("QT_TRID_NOOP").isCallable());
+ QVERIFY(global.property("String").property("prototype").property("arg").isCallable());
{
QScriptValue ret = eng.evaluate("qsTr('foo')");
static QScriptValue callQsTr(QScriptContext *ctx, QScriptEngine *eng)
{
- return eng->globalObject().property("qsTr").call(ctx->thisObject(), ctx->argumentsObject());
+ return eng->globalObject().property("qsTr").callWithInstance(ctx->thisObject(), ctx->argumentsObject());
}
void tst_QJSEngine::translateScript_callQsTrFromNative()
// There is no context, but it shouldn't crash
QCOMPARE(engine.globalObject().property("qsTr").call(
- QScriptValue(), QScriptValueList() << "One").toString(), QString::fromLatin1("One"));
+ QScriptValueList() << "One").toString(), QString::fromLatin1("One"));
}
void tst_QJSEngine::translateWithInvalidArgs_data()
{
// top-level functions have only the global object in their scope
QScriptValue fun = eng.evaluate("(function() {})");
- QVERIFY(fun.isFunction());
+ QVERIFY(fun.isCallable());
QEXPECT_FAIL("", "QScriptValue::scope() is internal, not implemented", Abort);
QVERIFY(fun.scope().isObject());
QVERIFY(fun.scope().strictlyEquals(eng.globalObject()));
}
{
QScriptValue fun = eng.globalObject().property("Object");
- QVERIFY(fun.isFunction());
+ QVERIFY(fun.isCallable());
// native built-in functions don't have scope
QVERIFY(!fun.scope().isValid());
}
{
// closure
QScriptValue fun = eng.evaluate("(function(arg) { var foo = arg; return function() { return foo; }; })(123)");
- QVERIFY(fun.isFunction());
+ QVERIFY(fun.isCallable());
{
QScriptValue ret = fun.call();
QVERIFY(ret.isNumber());
QScriptEngine eng;
{
QScriptValue fun = eng.newFunction(counter);
- QScriptValue cnt = fun.call(QScriptValue(), QScriptValueList() << 123);
- QVERIFY(cnt.isFunction());
+ QScriptValue cnt = fun.call(QScriptValueList() << 123);
+ QVERIFY(cnt.isCallable());
{
QScriptValue ret = cnt.call();
QVERIFY(ret.isNumber());
}
{
QScriptValue fun = eng.newFunction(counter_hybrid);
- QScriptValue cnt = fun.call(QScriptValue(), QScriptValueList() << 123);
- QVERIFY(cnt.isFunction());
+ QScriptValue cnt = fun.call(QScriptValueList() << 123);
+ QVERIFY(cnt.isCallable());
{
QScriptValue ret = cnt.call();
QVERIFY(ret.isNumber());
QScriptProgram program("(function() { var count = 0; return function() { return count++; }; })");
QVERIFY(!program.isNull());
QScriptValue createCounter = eng.evaluate(program);
- QVERIFY(createCounter.isFunction());
+ QVERIFY(createCounter.isCallable());
QScriptValue counter = createCounter.call();
- QVERIFY(counter.isFunction());
+ QVERIFY(counter.isCallable());
{
QScriptValue ret = counter.call();
QVERIFY(ret.isNumber());
}
QScriptValue counter2 = createCounter.call();
- QVERIFY(counter2.isFunction());
+ QVERIFY(counter2.isCallable());
QVERIFY(!counter2.equals(counter));
{
QScriptValue ret = counter2.call();
{
QScriptValue fun = eng.newFunction(createProgram);
QScriptProgram program = qscriptvalue_cast<QScriptProgram>(
- fun.call(QScriptValue(), QScriptValueList() << "a + 1"));
+ fun.call(QScriptValueList() << "a + 1"));
QVERIFY(!program.isNull());
eng.globalObject().setProperty("a", QScriptValue());
{
QVERIFY(object.isQObject());
QVERIFY(object.toQObject() != 0);
QVERIFY(object.property("objectName").isString());
- QVERIFY(object.property("deleteLater").isFunction());
+ QVERIFY(object.property("deleteLater").isCallable());
}
#endif
QCOMPARE(rexp.isValid(), true);
QCOMPARE(rexp.isRegExp(), true);
- QVERIFY(rexp.isFunction());
+ QVERIFY(rexp.isCallable());
QJSValue func = eng.evaluate("(function(string, regexp) { return string.match(regexp); })");
- QJSValue result = func.call(QJSValue(), QJSValueList() << string << rexp);
+ QJSValue result = func.call(QJSValueList() << string << rexp);
rx.indexIn(string);
for (int i = 0; i <= rx.captureCount(); i++) {
QJSValue jsDate = eng.evaluate(QString::fromLatin1("new Date(%0)").arg(secs * 1000.0));
QDateTime qtDate = jsDate.toDateTime();
QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate);
- QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString();
+ QString jsUTCDateStr = jsDate.property("toISOString").callWithInstance(jsDate).toString();
jsUTCDateStr.remove(jsUTCDateStr.length() - 5, 4); // get rid of milliseconds (".000")
if (qtUTCDateStr != jsUTCDateStr)
QFAIL(qPrintable(jsDate.toString()));
QJSEngine eng;
for (int i = 0; i < 8000; ++i) {
QJSValue jsDate = eng.newDate(qtDate);
- QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString();
+ QString jsUTCDateStr = jsDate.property("toISOString").callWithInstance(jsDate).toString();
jsUTCDateStr.remove(jsUTCDateStr.length() - 5, 4); // get rid of milliseconds (".000")
QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate);
if (jsUTCDateStr != qtUTCDateStr)
}
QScriptValue fun = eng.evaluate("(function() { return foo; })");
- QVERIFY(fun.isFunction());
+ QVERIFY(fun.isCallable());
eng.popContext();
// Function's scope chain persists after popContext().
QVERIFY(fun.call().equals(scope.property("foo")));
// Function declarations will create properties on the scope.
eng.evaluate("function fun() { return baz; }");
- QVERIFY(scope.property("fun").isFunction());
+ QVERIFY(scope.property("fun").isCallable());
QVERIFY(scope.property("fun").call().equals(scope.property("baz")));
// Demonstrate the limitation of a growable static scope: Once a function that
// to the scope later.
{
QScriptValue fun = eng.evaluate("(function() { return futureProperty; })");
- QVERIFY(fun.isFunction());
+ QVERIFY(fun.isCallable());
QVERIFY(fun.call().toString().contains(QString::fromLatin1("ReferenceError")));
scope.setProperty("futureProperty", "added after the function was compiled");
// If scope were dynamic, this would return the new property.
QCOMPARE(meta.toQMetaObject(), &QScriptEngine::staticMetaObject);
// Because of missing Q_SCRIPT_DECLARE_QMETAOBJECT() for QScriptEngine.
QEXPECT_FAIL("", "FIXME: because construct never returns invalid values", Continue);
- QVERIFY(!meta.construct().isValid());
+ QVERIFY(!meta.callAsConstructor().isValid());
}
{
QScriptValue meta = eng.scriptValueFromQMetaObject<QStandardItemModel>();
QVERIFY(meta.isQMetaObject());
QCOMPARE(meta.toQMetaObject(), &QStandardItemModel::staticMetaObject);
- QScriptValue obj = meta.construct(QScriptValueList() << eng.newQObject(&eng));
+ QScriptValue obj = meta.callAsConstructor(QScriptValueList() << eng.newQObject(&eng));
QVERIFY(obj.isQObject());
QStandardItemModel *model = qobject_cast<QStandardItemModel*>(obj.toQObject());
QVERIFY(model != 0);
// QJS adds connect and disconnect properties to Function.prototype.
QJSEngine eng;
QJSValue funProto = eng.globalObject().property("Function").property("prototype");
- QVERIFY(funProto.isFunction());
- QVERIFY(funProto.property("connect").isFunction());
+ QVERIFY(funProto.isCallable());
+ QVERIFY(funProto.property("connect").isCallable());
QCOMPARE(funProto.propertyFlags("connect"), QJSValue::SkipInEnumeration);
- QVERIFY(funProto.property("disconnect").isFunction());
+ QVERIFY(funProto.property("disconnect").isCallable());
QCOMPARE(funProto.propertyFlags("disconnect"), QJSValue::SkipInEnumeration);
// No properties should appear in for-in statements.