void fromScriptValueEntityReference(const QScriptValue &obj, EntityReference &s)
{
if (obj.isString())
s.ref = obj.toString();
else
{
if (!obj.property("ref").isValid())
LogError("Can't convert QScriptValue to EntityReference! QScriptValue does not contain ref attribute!");
else
{
QScriptValue ref = obj.property("ref");
if (ref.isNull())
s.ref = ""; // Empty the reference
else if (ref.isString())
s.ref = ref.toString();
else if (ref.isQObject())
{
// If the object is an Entity, call EntityReference::Set() with it
Entity* entity = dynamic_cast<Entity*>(ref.toQObject());
s.Set(entity);
}
else if (ref.isNumber() || ref.isVariant())
s.ref = QString::number(ref.toInt32());
else
LogError("Can't convert QScriptValue to EntityReference! Ref attribute is not null, string, a number, or an entity");
}
}
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
MagicCore SomeMagicCoreClass;
QScriptEngine scriptEngine;
QScriptValue scriptMagicCore = scriptEngine.newQObject (&SomeMagicCoreClass);
Q_ASSERT (scriptMagicCore.isQObject());
scriptEngine.globalObject().setProperty("Core", scriptMagicCore);
ReadScriptsFromPath(QDir("./scripts/objects/"), scriptEngine);
ReadScriptsFromPath(QDir("./scripts/levels/"), scriptEngine);
char szLine[256];
strcpy(szLine, "");
std::cout << std::endl << "Entering scripting console: " << std::endl;
while (strcmp(szLine, "exit") != 0)
{
// evaluate script line and store return value
QScriptValue retVal = scriptEngine.evaluate(szLine);
if (retVal.isUndefined() == false)
std::cout << "ScriptEngine returns: " << retVal.toString().toStdString() << std::endl;
// read line
strcpy(szLine, "");
std::cin.getline(szLine, 256);
}
/* QScriptValue object = scriptEngine.globalObject().property("testObject");
Q_ASSERT(object.isValid());
QScriptValue SlotMethod = object.property("ExampleSlot1");
Q_ASSERT(SlotMethod.isFunction());
bool bOk = qScriptConnect(&SomeMagicCoreClass, SIGNAL(TestSignal()), object, SlotMethod);
Q_ASSERT(bOk);
QScriptValue object2 = scriptEngine.globalObject().property("testObject2");
Q_ASSERT(object2.isValid());
QScriptValue SlotMethod2 = object2.property("ExampleSlot2");
Q_ASSERT(SlotMethod2.isFunction());
bool bOk2 = qScriptConnect(&SomeMagicCoreClass, SIGNAL(TestSignal()), object2, SlotMethod2);
Q_ASSERT(bOk2);
SomeMagicCoreClass.TriggerSignal();*/
return 0;
/*a.exit(0);
return a.exec();*/
}
static JSAgentWatchData fromScriptValue(const QString &expression,
const QScriptValue &value)
{
static const QString arrayStr = QCoreApplication::translate
("Debugger::JSAgentWatchData", "[Array of length %1]");
static const QString undefinedStr = QCoreApplication::translate
("Debugger::JSAgentWatchData", "<undefined>");
JSAgentWatchData data;
data.exp = expression.toUtf8();
data.name = data.exp;
data.hasChildren = false;
data.value = value.toString().toUtf8();
data.objectId = value.objectId();
if (value.isArray()) {
data.type = "Array";
data.value = arrayStr.arg(value.property(QLatin1String("length")).toString()).toUtf8();
data.hasChildren = true;
} else if (value.isBool()) {
data.type = "Bool";
// data.value = value.toBool() ? "true" : "false";
} else if (value.isDate()) {
data.type = "Date";
data.value = value.toDateTime().toString().toUtf8();
} else if (value.isError()) {
data.type = "Error";
} else if (value.isFunction()) {
data.type = "Function";
} else if (value.isUndefined()) {
data.type = undefinedStr.toUtf8();
} else if (value.isNumber()) {
data.type = "Number";
} else if (value.isRegExp()) {
data.type = "RegExp";
} else if (value.isString()) {
data.type = "String";
} else if (value.isVariant()) {
data.type = "Variant";
} else if (value.isQObject()) {
const QObject *obj = value.toQObject();
data.type = "Object";
data.value += '[';
data.value += obj->metaObject()->className();
data.value += ']';
data.hasChildren = true;
} else if (value.isObject()) {
data.type = "Object";
data.hasChildren = true;
data.value = "[Object]";
} else if (value.isNull()) {
data.type = "<null>";
} else {
data.type = "<unknown>";
}
return data;
}
// Q_DECLARE_METATYPE(QGraphicsLayoutItem*)
QGraphicsLayoutItem *extractLayoutItem(QScriptContext *ctx, int index = 0, bool noExistingLayout = false)
{
QScriptValue v = ctx->argument(index);
if (ctx->argumentCount() == 0 || v.isQObject()) {
QObject *object = v.toQObject();
QGraphicsWidget *w = qobject_cast<QGraphicsWidget *>(object);
if (!w) {
AppletInterface *interface = qobject_cast<AppletInterface*>(object);
if (!interface) {
interface = qobject_cast<AppletInterface*>(ctx->engine()->globalObject().property("plasmoid").toQObject());
}
if (interface) {
w = interface->applet();
}
}
if (noExistingLayout && w->layout()) {
return 0;
}
return w;
}
QVariant variant = v.toVariant();
QGraphicsLayoutItem *item = variant.value<QGraphicsLayoutItem *>();
//this is horribly ugly code, but when a QLinearLayout* is stuffed into a QVariant,
//QVariant does not know that it is a QGraphicsLayoutItem. repeat for all subclasses
//of same
if (!item) {
item = variant.value<QGraphicsLayout *>();
if (!item) {
item = variant.value<QGraphicsLinearLayout *>();
if (!item) {
item = variant.value<QGraphicsGridLayout *>();
if (!item) {
item = variant.value<QGraphicsAnchorLayout *>();
}
}
}
}
QGraphicsWidget *w = dynamic_cast<QGraphicsWidget *>(item);
if (noExistingLayout && w && w->layout()) {
return 0;
}
return item;
}
bool init() {
if( m_script->action()->hadError() )
m_script->action()->clearError();
delete m_engine;
m_engine = new QScriptEngine();
// load the Qross QScriptExtensionPlugin plugin that provides
// us a bridge between Qross and QtScript. See here plugin.h
m_engine->importExtension("qross");
if( m_engine->hasUncaughtException() ) {
handleException();
delete m_engine;
m_engine = 0;
return false;
}
// the Qross QScriptExtensionPlugin exports the "Qross" property.
QScriptValue global = m_engine->globalObject();
m_qross = global.property("Qross");
Q_ASSERT( m_qross.isQObject() );
Q_ASSERT( ! m_engine->hasUncaughtException() );
// Attach our Qross::Action instance to be able to access it in
// scripts. Just like at the Kjs-backend we publish our own
// action as "self".
m_self = m_engine->newQObject( m_script->action() );
global.setProperty("self", m_self, QScriptValue::ReadOnly|QScriptValue::Undeletable);
{ // publish the global objects.
QHash< QString, QObject* > objects = Manager::self().objects();
QHash< QString, QObject* >::Iterator it(objects.begin()), end(objects.end());
for(; it != end; ++it)
global.setProperty(it.key(), m_engine->newQObject( it.value() ) );
}
{ // publish the local objects.
QHash< QString, QObject* > objects = m_script->action()->objects();
QHash< QString, QObject* >::Iterator it(objects.begin()), end(objects.end());
for(; it != end; ++it) {
copyEnumsToProperties( it.value() );
global.setProperty(it.key(), m_engine->newQObject( it.value() ) );
}
}
return ! m_engine->hasUncaughtException();
}
QScriptDeclarativeClass::Value MetaCallArgument::toValue(QDeclarativeEngine *e)
{
QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(e);
if (type == qMetaTypeId<QScriptValue>()) {
return QScriptDeclarativeClass::Value(engine, *qscriptValuePtr);
} else if (type == QMetaType::Int) {
return QScriptDeclarativeClass::Value(engine, int(intValue));
} else if (type == QMetaType::UInt) {
return QScriptDeclarativeClass::Value(engine, uint(intValue));
} else if (type == QMetaType::Bool) {
return QScriptDeclarativeClass::Value(engine, boolValue);
} else if (type == QMetaType::Double) {
return QScriptDeclarativeClass::Value(engine, doubleValue);
} else if (type == QMetaType::Float) {
return QScriptDeclarativeClass::Value(engine, floatValue);
} else if (type == QMetaType::QString) {
return QScriptDeclarativeClass::Value(engine, *qstringPtr);
} else if (type == QMetaType::QObjectStar) {
if (qobjectPtr)
QDeclarativeData::get(qobjectPtr, true)->setImplicitDestructible();
QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
return QScriptDeclarativeClass::Value(engine, priv->objectClass->newQObject(qobjectPtr));
} else if (type == qMetaTypeId<QList<QObject *> >()) {
QList<QObject *> &list = *qlistPtr;
QScriptValue rv = engine->newArray(list.count());
QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
for (int ii = 0; ii < list.count(); ++ii) {
QObject *object = list.at(ii);
QDeclarativeData::get(object, true)->setImplicitDestructible();
rv.setProperty(ii, priv->objectClass->newQObject(object));
}
return QScriptDeclarativeClass::Value(engine, rv);
} else if (type == -1 || type == qMetaTypeId<QVariant>()) {
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(e);
QScriptValue rv = ep->scriptValueFromVariant(*qvariantPtr);
if (rv.isQObject()) {
QObject *object = rv.toQObject();
if (object)
QDeclarativeData::get(object, true)->setImplicitDestructible();
}
return QScriptDeclarativeClass::Value(engine, rv);
} else {
return QScriptDeclarativeClass::Value();
}
}
void JavascriptInstance::GetObjectInformation(const QScriptValue &object, QSet<qint64> &ids, uint &valueCount, uint &objectCount, uint &nullCount, uint &numberCount,
uint &boolCount, uint &stringCount, uint &arrayCount, uint &funcCount, uint &qobjCount, uint &qobjMethodCount)
{
if (!ids.contains(object.objectId()))
ids << object.objectId();
QScriptValueIterator iter(object);
while(iter.hasNext())
{
iter.next();
QScriptValue v = iter.value();
if (ids.contains(v.objectId()))
continue;
ids << v.objectId();
valueCount++;
if (v.isNull())
nullCount++;
if (v.isNumber())
numberCount++;
else if (v.isBool())
boolCount++;
else if (v.isString())
stringCount++;
else if (v.isArray())
arrayCount++;
else if (v.isFunction())
funcCount++;
else if (v.isQObject())
qobjCount++;
if (v.isObject())
objectCount++;
if (v.isQMetaObject())
qobjMethodCount += v.toQMetaObject()->methodCount();
// Recurse
if ((v.isObject() || v.isArray()) && !v.isFunction() && !v.isString() && !v.isNumber() && !v.isBool() && !v.isQObject() && !v.isQMetaObject())
GetObjectInformation(v, ids, valueCount, objectCount, nullCount, numberCount, boolCount, stringCount, arrayCount, funcCount, qobjCount, qobjMethodCount);
}
}
void connectFunctions(ChildrenInterface* children) {
Q_ASSERT( m_engine );
Q_ASSERT( ! m_engine->hasUncaughtException() );
QString eval;
QScriptValue global = m_engine->globalObject();
QHashIterator< QString, ChildrenInterface::Options > it( children->objectOptions() );
while(it.hasNext()) {
it.next();
if( it.value() & ChildrenInterface::AutoConnectSignals ) {
QObject* sender = children->object(it.key());
if( ! sender )
continue;
QScriptValue obj = m_engine->globalObject().property(it.key());
if( ! obj.isQObject() )
continue;
const QMetaObject* mo = sender->metaObject();
const int count = mo->methodCount();
for(int i = 0; i < count; ++i) {
QMetaMethod mm = mo->method(i);
#if QT_VERSION < 0x050000
const QString signature = mm.signature();
#else
const QString signature = mm.methodSignature();
#endif
const QString name = signature.left(signature.indexOf('('));
if( mm.methodType() == QMetaMethod::Signal ) {
QScriptValue func = global.property(name);
if( ! func.isFunction() ) {
//qrossdebug( QString("EcmaScript::connectFunctions No function to connect with %1.%2").arg(it.key()).arg(name) );
continue;
}
qrossdebug( QString("EcmaScript::connectFunctions Connecting with %1.%2").arg(it.key()).arg(name) );
eval += QString("try { %1.%2.connect(%3); } catch(e) { print(e); }\n").arg(it.key()).arg(name).arg(name);
}
}
}
}
Q_ASSERT( ! m_engine->hasUncaughtException() );
if( ! eval.isNull() ) {
m_engine->evaluate(eval);
Q_ASSERT( ! m_engine->hasUncaughtException() );
}
}
bool operator==(const QScriptValue& first, const QScriptValue& second) {
if (first.isUndefined()) {
return second.isUndefined();
} else if (first.isNull()) {
return second.isNull();
} else if (first.isBool()) {
return second.isBool() && first.toBool() == second.toBool();
} else if (first.isNumber()) {
return second.isNumber() && first.toNumber() == second.toNumber();
} else if (first.isString()) {
return second.isString() && first.toString() == second.toString();
} else if (first.isVariant()) {
return second.isVariant() && first.toVariant() == second.toVariant();
} else if (first.isQObject()) {
return second.isQObject() && first.toQObject() == second.toQObject();
} else if (first.isQMetaObject()) {
return second.isQMetaObject() && first.toQMetaObject() == second.toQMetaObject();
} else if (first.isDate()) {
return second.isDate() && first.toDateTime() == second.toDateTime();
} else if (first.isRegExp()) {
return second.isRegExp() && first.toRegExp() == second.toRegExp();
} else if (first.isArray()) {
if (!second.isArray()) {
return false;
}
int length = first.property(ScriptCache::getInstance()->getLengthString()).toInt32();
if (second.property(ScriptCache::getInstance()->getLengthString()).toInt32() != length) {
return false;
}
for (int i = 0; i < length; i++) {
if (first.property(i) != second.property(i)) {
return false;
}
}
return true;
} else if (first.isObject()) {
if (!second.isObject()) {
return false;
}
int propertyCount = 0;
for (QScriptValueIterator it(first); it.hasNext(); ) {
it.next();
if (second.property(it.scriptName()) != it.value()) {
return false;
}
propertyCount++;
}
// make sure the second has exactly as many properties as the first
for (QScriptValueIterator it(second); it.hasNext(); ) {
it.next();
if (--propertyCount < 0) {
return false;
}
}
return true;
} else {
// if none of the above tests apply, first must be invalid
return !second.isValid();
}
}
/*!
Returns the match score for converting \a actual to be of type \a conversionType. A
zero score means "perfect match" whereas a higher score is worse.
The conversion table is copied out of the QtScript callQtMethod() function.
*/
int QDeclarativeObjectMethodScriptClass::matchScore(const QScriptValue &actual, int conversionType,
const QByteArray &conversionTypeName)
{
if (actual.isNumber()) {
switch (conversionType) {
case QMetaType::Double:
return 0;
case QMetaType::Float:
return 1;
case QMetaType::LongLong:
case QMetaType::ULongLong:
return 2;
case QMetaType::Long:
case QMetaType::ULong:
return 3;
case QMetaType::Int:
case QMetaType::UInt:
return 4;
case QMetaType::Short:
case QMetaType::UShort:
return 5;
break;
case QMetaType::Char:
case QMetaType::UChar:
return 6;
default:
return 10;
}
} else if (actual.isString()) {
switch (conversionType) {
case QMetaType::QString:
return 0;
default:
return 10;
}
} else if (actual.isBoolean()) {
switch (conversionType) {
case QMetaType::Bool:
return 0;
default:
return 10;
}
} else if (actual.isDate()) {
switch (conversionType) {
case QMetaType::QDateTime:
return 0;
case QMetaType::QDate:
return 1;
case QMetaType::QTime:
return 2;
default:
return 10;
}
} else if (actual.isRegExp()) {
switch (conversionType) {
case QMetaType::QRegExp:
return 0;
default:
return 10;
}
} else if (actual.isVariant()) {
if (conversionType == qMetaTypeId<QVariant>())
return 0;
else if (actual.toVariant().userType() == conversionType)
return 0;
else
return 10;
} else if (actual.isArray()) {
switch (conversionType) {
case QMetaType::QStringList:
case QMetaType::QVariantList:
return 5;
default:
return 10;
}
} else if (actual.isQObject()) {
switch (conversionType) {
case QMetaType::QObjectStar:
return 0;
default:
return 10;
}
} else if (actual.isNull()) {
switch (conversionType) {
case QMetaType::VoidStar:
case QMetaType::QObjectStar:
return 0;
default:
if (!conversionTypeName.endsWith('*'))
return 10;
else
return 0;
}
} else {
return 10;
}
}
void tst_QScriptClass::extension()
{
QScriptEngine eng;
{
TestClass cls(&eng);
cls.setCallableMode(TestClass::NotCallable);
QVERIFY(!cls.supportsExtension(QScriptClass::Callable));
QVERIFY(!cls.supportsExtension(QScriptClass::HasInstance));
QScriptValue obj = eng.newObject(&cls);
QVERIFY(!obj.call().isValid());
QCOMPARE((int)cls.lastExtensionType(), -1);
QVERIFY(!obj.instanceOf(obj));
QCOMPARE((int)cls.lastExtensionType(), -1);
}
// Callable
{
TestClass cls(&eng);
cls.setCallableMode(TestClass::CallableReturnsSum);
QVERIFY(cls.supportsExtension(QScriptClass::Callable));
QScriptValue obj = eng.newObject(&cls);
eng.globalObject().setProperty("obj", obj);
obj.setProperty("one", QScriptValue(&eng, 1));
obj.setProperty("two", QScriptValue(&eng, 2));
obj.setProperty("three", QScriptValue(&eng, 3));
// From C++
cls.clearReceivedArgs();
{
QScriptValueList args;
args << QScriptValue(&eng, 4) << QScriptValue(&eng, 5);
QScriptValue ret = obj.call(obj, args);
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isNumber());
QCOMPARE(ret.toNumber(), qsreal(15));
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("obj(4, 5)");
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isNumber());
QCOMPARE(ret.toNumber(), qsreal(15));
}
cls.setCallableMode(TestClass::CallableReturnsArgument);
// From C++
cls.clearReceivedArgs();
{
QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
cls.clearReceivedArgs();
{
QScriptValue ret = obj.call(obj, QScriptValueList() << true);
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isBoolean());
QCOMPARE(ret.toBoolean(), true);
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << QString::fromLatin1("ciao"));
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("ciao"));
}
{
QScriptValue objobj = eng.newObject();
QScriptValue ret = obj.call(obj, QScriptValueList() << objobj);
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(objobj));
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << QScriptValue());
QVERIFY(ret.isUndefined());
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("obj(123)");
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
cls.setCallableMode(TestClass::CallableReturnsInvalidVariant);
{
QScriptValue ret = obj.call(obj);
QVERIFY(ret.isUndefined());
}
cls.setCallableMode(TestClass::CallableReturnsThisObject);
// From C++
{
QScriptValue ret = obj.call(obj);
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(obj));
}
// From JS
{
QScriptValue ret = eng.evaluate("obj()");
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(eng.globalObject()));
}
cls.setCallableMode(TestClass::CallableReturnsCallee);
// From C++
{
QScriptValue ret = obj.call();
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(obj));
}
// From JS
{
QScriptValue ret = eng.evaluate("obj()");
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(obj));
}
cls.setCallableMode(TestClass::CallableReturnsArgumentsObject);
// From C++
{
QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
QVERIFY(ret.isObject());
QVERIFY(ret.property("length").isNumber());
QCOMPARE(ret.property("length").toInt32(), 1);
QVERIFY(ret.property(0).isNumber());
QCOMPARE(ret.property(0).toInt32(), 123);
}
// From JS
{
QScriptValue ret = eng.evaluate("obj(123)");
QVERIFY(ret.isObject());
QVERIFY(ret.property("length").isNumber());
QCOMPARE(ret.property("length").toInt32(), 1);
QVERIFY(ret.property(0).isNumber());
QCOMPARE(ret.property(0).toInt32(), 123);
}
// construct()
// From C++
cls.clearReceivedArgs();
cls.setCallableMode(TestClass::CallableReturnsGlobalObject);
{
QScriptValue ret = obj.construct();
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(eng.globalObject()));
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("new obj()");
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(eng.globalObject()));
}
// From C++
cls.clearReceivedArgs();
cls.setCallableMode(TestClass::CallableInitializesThisObject);
{
QScriptValue ret = obj.construct();
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isQObject());
QCOMPARE(ret.toQObject(), (QObject*)&eng);
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("new obj()");
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isQObject());
QCOMPARE(ret.toQObject(), (QObject*)&eng);
}
}
// HasInstance
{
TestClass cls(&eng);
cls.setHasInstance(true);
QVERIFY(cls.supportsExtension(QScriptClass::HasInstance));
QScriptValue obj = eng.newObject(&cls);
obj.setProperty("foo", QScriptValue(&eng, 123));
QScriptValue plain = eng.newObject();
QVERIFY(!plain.instanceOf(obj));
eng.globalObject().setProperty("HasInstanceTester", obj);
eng.globalObject().setProperty("hasInstanceValue", plain);
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QCOMPARE(cls.lastExtensionType(), QScriptClass::HasInstance);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptValueList>());
QScriptValueList lst = qvariant_cast<QScriptValueList>(cls.lastExtensionArgument());
QCOMPARE(lst.size(), 2);
QVERIFY(lst.at(0).strictlyEquals(obj));
QVERIFY(lst.at(1).strictlyEquals(plain));
QVERIFY(ret.isBoolean());
QVERIFY(!ret.toBoolean());
}
plain.setProperty("foo", QScriptValue(&eng, 456));
QVERIFY(!plain.instanceOf(obj));
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(!ret.toBoolean());
}
plain.setProperty("foo", obj.property("foo"));
QVERIFY(plain.instanceOf(obj));
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(ret.toBoolean());
}
}
}
void tst_QScriptValueGenerated::isQObject_test(const char*, const QScriptValue& value)
{
QFETCH(bool, expected);
QCOMPARE(value.isQObject(), expected);
QCOMPARE(value.isQObject(), expected);
}
