Add benchmarks for QtScript's QObject binding

The benchmarks cover the following:
- Reading and writing meta-object-defined properties.
- Reading and writing dynamic properties.
- Reading child objects.
- Reading script-defined (wrapper object) properties.
- Reading prototype-inherited properties.
- Calling slots (overloaded and non-overloaded, with
  or without implicit argument conversion).
- Signal handling.

Both "simple" and "complex" objects are tested. A "simple" object
is an object that inherits directly from QObject, i.e. it doesn't
drag with it a lot of stuff. A "complex" object is an object that
has many properties and a relatively long inheritance chain
(currently QPushButton is used).

Reviewed-by: Jedrzej Nowacki

2 files changed, 1244 insertions, 0 deletions

diff --git a/tests/benchmarks/script/qscriptqobject/qscriptqobject.pro b/tests/benchmarks/script/qscriptqobject/qscriptqobject.pro
new file mode 100644
index 0000000..30bc447
--- /dev/null
+++ b/tests/benchmarks/script/qscriptqobject/qscriptqobject.pro
@@ -0,0 +1,7 @@
+load(qttest_p4)
+TEMPLATE = app
+TARGET = tst_bench_qscriptqobject
+
+SOURCES += tst_qscriptqobject.cpp
+
+QT += script
diff --git a/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp b/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp
new file mode 100644
index 0000000..e68db06
--- /dev/null
+++ b/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp
@@ -0,0 +1,1237 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qtest.h>
+#include <QtGui>
+#include <QtScript>
+
+#define ITERATION_COUNT 1e4
+
+struct CustomType
+{
+    int a;
+};
+Q_DECLARE_METATYPE(CustomType)
+
+class PropertyTestObject : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(EnumType)
+    Q_FLAGS(FlagsType)
+    Q_PROPERTY(bool boolProperty READ boolProperty WRITE setBoolProperty)
+    Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty)
+    Q_PROPERTY(double doubleProperty READ doubleProperty WRITE setDoubleProperty)
+    Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty)
+    Q_PROPERTY(QVariant variantProperty READ variantProperty WRITE setVariantProperty)
+    Q_PROPERTY(QObject* qobjectProperty READ qobjectProperty WRITE setQObjectProperty)
+    Q_PROPERTY(CustomType customProperty READ customProperty WRITE setCustomProperty)
+    Q_PROPERTY(EnumType enumProperty READ enumProperty WRITE setEnumProperty)
+    Q_PROPERTY(FlagsType flagsProperty READ flagsProperty WRITE setFlagsProperty)
+public:
+    enum EnumType {
+        NoEnumValue = 0,
+        FirstEnumValue = 1,
+        SecondEnumValue = 2,
+        ThirdEnumValue = 4
+    };
+    Q_DECLARE_FLAGS(FlagsType, EnumType)
+
+    PropertyTestObject(QObject *parent = 0)
+        : QObject(parent),
+        m_boolProperty(false),
+        m_intProperty(123),
+        m_doubleProperty(123),
+        m_stringProperty("hello"),
+        m_variantProperty(double(123)),
+        m_qobjectProperty(this),
+        m_enumProperty(SecondEnumValue),
+        m_flagsProperty(FirstEnumValue | ThirdEnumValue)
+        { }
+
+    bool boolProperty() const
+        { return m_boolProperty; }
+    void setBoolProperty(bool value)
+        { m_boolProperty = value; }
+
+    int intProperty() const
+        { return m_intProperty; }
+    void setIntProperty(int value)
+        { m_intProperty = value; }
+
+    int doubleProperty() const
+        { return m_doubleProperty; }
+    void setDoubleProperty(double value)
+        { m_doubleProperty = value; }
+
+    QString stringProperty() const
+        { return m_stringProperty; }
+    void setStringProperty(const QString &value)
+        { m_stringProperty = value; }
+
+    QVariant variantProperty() const
+        { return m_variantProperty; }
+    void setVariantProperty(const QVariant &value)
+        { m_variantProperty = value; }
+
+    QObject *qobjectProperty() const
+        { return m_qobjectProperty; }
+    void setQObjectProperty(QObject *qobject)
+        { m_qobjectProperty = qobject;  }
+
+    CustomType customProperty() const
+        { return m_customProperty; }
+    void setCustomProperty(const CustomType &value)
+        { m_customProperty = value; }
+
+    EnumType enumProperty() const
+        { return m_enumProperty; }
+    void setEnumProperty(EnumType value)
+        { m_enumProperty = value; }
+
+    FlagsType flagsProperty() const
+        { return m_flagsProperty; }
+    void setFlagsProperty(FlagsType value)
+        { m_flagsProperty = value; }
+
+private:
+    bool m_boolProperty;
+    int m_intProperty;
+    double m_doubleProperty;
+    QString m_stringProperty;
+    QVariant m_variantProperty;
+    QObject *m_qobjectProperty;
+    CustomType m_customProperty;
+    EnumType m_enumProperty;
+    FlagsType m_flagsProperty;
+};
+
+class SlotTestObject : public QObject
+{
+    Q_OBJECT
+public:
+    SlotTestObject(QObject *parent = 0)
+        : QObject(parent),
+          m_string(QString::fromLatin1("hello")),
+          m_variant(123)
+        { }
+
+public Q_SLOTS:
+    void voidSlot() { }
+    void boolSlot(bool) { }
+    void intSlot(int) { }
+    void doubleSlot(double) { }
+    void stringSlot(const QString &) { }
+    void variantSlot(const QVariant &) { }
+    void qobjectSlot(QObject *) { }
+    void customTypeSlot(const CustomType &) { }
+
+    bool returnBoolSlot() { return true; }
+    int returnIntSlot() { return 123; }
+    double returnDoubleSlot() { return 123.0; }
+    QString returnStringSlot() { return m_string; }
+    QVariant returnVariantSlot() { return m_variant; }
+    QObject *returnQObjectSlot() { return this; }
+    CustomType returnCustomTypeSlot() { return m_custom; }
+
+    void fourDoubleSlot(double, double, double, double) { }
+    void sixDoubleSlot(double, double, double, double, double, double) { }
+    void eightDoubleSlot(double, double, double, double, double, double, double, double) { }
+
+    void fourStringSlot(const QString &, const QString &, const QString &, const QString &) { }
+    void sixStringSlot(const QString &, const QString &, const QString &, const QString &,
+                       const QString &, const QString &) { }
+    void eightStringSlot(const QString &, const QString &, const QString &, const QString &,
+        const QString &, const QString &, const QString &, const QString &) { }
+
+private:
+    QString m_string;
+    QVariant m_variant;
+    CustomType m_custom;
+};
+
+class SignalTestObject : public QObject
+{
+    Q_OBJECT
+public:
+    SignalTestObject(QObject *parent = 0)
+        : QObject(parent)
+        { }
+
+    void emitVoidSignal()
+        { emit voidSignal(); }
+    void emitBoolSignal(bool value)
+        { emit boolSignal(value); }
+    void emitIntSignal(int value)
+        { emit intSignal(value); }
+    void emitDoubleSignal(double value)
+        { emit doubleSignal(value); }
+    void emitStringSignal(const QString &value)
+        { emit stringSignal(value); }
+    void emitVariantSignal(const QVariant &value)
+        { emit variantSignal(value); }
+    void emitQObjectSignal(QObject *object)
+        { emit qobjectSignal(object); }
+    void emitCustomTypeSignal(const CustomType &value)
+        { emit customTypeSignal(value); }
+
+Q_SIGNALS:
+    void voidSignal();
+    void boolSignal(bool);
+    void intSignal(int);
+    void doubleSignal(double);
+    void stringSignal(const QString &);
+    void variantSignal(const QVariant &);
+    void qobjectSignal(QObject *);
+    void customTypeSignal(const CustomType &);
+};
+
+class OverloadedSlotTestObject : public QObject
+{
+    Q_OBJECT
+public:
+    OverloadedSlotTestObject(QObject *parent = 0)
+        : QObject(parent)
+        { }
+
+public Q_SLOTS:
+    void overloadedSlot() { }
+    void overloadedSlot(bool) { }
+    void overloadedSlot(double) { }
+    void overloadedSlot(const QString &) { }
+};
+
+class QtScriptablePropertyTestObject
+    : public PropertyTestObject, public QScriptable
+{
+};
+
+class QtScriptableSlotTestObject
+    : public SlotTestObject, public QScriptable
+{
+};
+
+class tst_QScriptQObject : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QScriptQObject();
+    virtual ~tst_QScriptQObject();
+
+private slots:
+    void initTestCase();
+
+    void readMetaProperty_data();
+    void readMetaProperty();
+
+    void writeMetaProperty_data();
+    void writeMetaProperty();
+
+    void readDynamicProperty_data();
+    void readDynamicProperty();
+
+    void writeDynamicProperty_data();
+    void writeDynamicProperty();
+
+    void readMethodByName_data();
+    void readMethodByName();
+
+    void readMethodBySignature_data();
+    void readMethodBySignature();
+
+    void readChild_data();
+    void readChild();
+
+    void readOneOfManyChildren_data();
+    void readOneOfManyChildren();
+
+    void readPrototypeProperty_data();
+    void readPrototypeProperty();
+
+    void readScriptProperty_data();
+    void readScriptProperty();
+
+    void readNoSuchProperty_data();
+    void readNoSuchProperty();
+
+    void readAllMetaProperties();
+
+    void callSlot_data();
+    void callSlot();
+
+    void callOverloadedSlot_data();
+    void callOverloadedSlot();
+
+    void voidSignalHandler();
+    void boolSignalHandler();
+    void intSignalHandler();
+    void doubleSignalHandler();
+    void stringSignalHandler();
+    void variantSignalHandler();
+    void qobjectSignalHandler();
+    void customTypeSignalHandler();
+
+    void readButtonMetaProperty_data();
+    void readButtonMetaProperty();
+
+    void writeButtonMetaProperty_data();
+    void writeButtonMetaProperty();
+
+    void readDynamicButtonProperty_data();
+    void readDynamicButtonProperty();
+
+    void writeDynamicButtonProperty_data();
+    void writeDynamicButtonProperty();
+
+    void readButtonMethodByName_data();
+    void readButtonMethodByName();
+
+    void readButtonMethodBySignature_data();
+    void readButtonMethodBySignature();
+
+    void readButtonChild_data();
+    void readButtonChild();
+
+    void readButtonPrototypeProperty_data();
+    void readButtonPrototypeProperty();
+
+    void readButtonScriptProperty_data();
+    void readButtonScriptProperty();
+
+    void readNoSuchButtonProperty_data();
+    void readNoSuchButtonProperty();
+
+    void callButtonMethod_data();
+    void callButtonMethod();
+
+    void readAllButtonMetaProperties();
+
+    void readQScriptableMetaProperty_data();
+    void readQScriptableMetaProperty();
+
+    void writeQScriptableMetaProperty_data();
+    void writeQScriptableMetaProperty();
+
+    void callQScriptableSlot_data();
+    void callQScriptableSlot();
+
+private:
+    void readMetaProperty_dataHelper(const QMetaObject *mo);
+    void readMethodByName_dataHelper(const QMetaObject *mo);
+    void readMethodBySignature_dataHelper(const QMetaObject *mo);
+    void readAllMetaPropertiesHelper(QObject *o);
+
+    void readPropertyHelper(QScriptEngine &engine, const QScriptValue &object,
+        const QString &propertyName, const QString &argTemplate = ".%0");
+    void writePropertyHelper(QScriptEngine &engine, const QScriptValue &object,
+        const QString &propertyName, const QScriptValue &value,
+        const QString &argTemplate = ".%0");
+
+    void callMethodHelper(QScriptEngine &engine, QObject *object,
+                          const QString &propertyName, const QString &arguments);
+    void signalHandlerHelper(QScriptEngine &engine, QObject *object, const char *signal);
+};
+
+tst_QScriptQObject::tst_QScriptQObject()
+{
+}
+
+tst_QScriptQObject::~tst_QScriptQObject()
+{
+}
+
+void tst_QScriptQObject::initTestCase()
+{
+    qMetaTypeId<CustomType>();
+}
+
+void tst_QScriptQObject::readMetaProperty_dataHelper(const QMetaObject *mo)
+{
+    QTest::addColumn<QString>("propertyName");
+
+    for (int i = 0; i < mo->propertyCount(); ++i) {
+        QMetaProperty prop = mo->property(i);
+        if (!qstrcmp(prop.name(), "default"))
+            continue; // skip reserved word
+        QTest::newRow(prop.name()) << prop.name();
+    }
+}
+
+void tst_QScriptQObject::readMethodByName_dataHelper(const QMetaObject *mo)
+{
+    QTest::addColumn<QString>("propertyName");
+
+    QSet<QByteArray> uniqueNames;
+    for (int i = 0; i < mo->methodCount(); ++i) {
+        QMetaMethod method = mo->method(i);
+        if (method.access() == QMetaMethod::Private)
+            continue;
+        QByteArray signature = method.signature();
+        QByteArray name = signature.left(signature.indexOf('('));
+        if (uniqueNames.contains(name))
+            continue;
+        QTest::newRow(name) << QString::fromLatin1(name);
+        uniqueNames.insert(name);
+    }
+}
+
+void tst_QScriptQObject::readMethodBySignature_dataHelper(const QMetaObject *mo)
+{
+    QTest::addColumn<QString>("propertyName");
+
+    for (int i = 0; i < mo->methodCount(); ++i) {
+        QMetaMethod method = mo->method(i);
+        if (method.access() == QMetaMethod::Private)
+            continue;
+        QTest::newRow(method.signature()) << QString::fromLatin1(method.signature());
+    }
+}
+
+void tst_QScriptQObject::readAllMetaPropertiesHelper(QObject *o)
+{
+    QString code = QString::fromLatin1(
+        "(function() {\n"
+        "  for (var i = 0; i < 100; ++i) {\n");
+    const QMetaObject *mo = o->metaObject();
+    for (int i = 0; i < mo->propertyCount(); ++i) {
+        QMetaProperty prop = mo->property(i);
+        if (!qstrcmp(prop.name(), "default"))
+            continue; // skip reserved word
+        code.append(QString::fromLatin1("    this.%0;\n").arg(prop.name()));
+    }
+    code.append(
+        "  }\n"
+        "})");
+
+    QScriptEngine engine;
+    QScriptValue fun = engine.evaluate(code);
+    QVERIFY(fun.isFunction());
+
+    QScriptValue wrapper = engine.newQObject(o);
+    QBENCHMARK {
+        fun.call(wrapper);
+    }
+    QVERIFY(!engine.hasUncaughtException());
+}
+
+void tst_QScriptQObject::readPropertyHelper(
+    QScriptEngine &engine, const QScriptValue &object,
+    const QString &propertyName, const QString &argTemplate)
+{
+    QString code = QString::fromLatin1(
+        "(function() {\n"
+        "  for (var i = 0; i < %0; ++i)\n"
+        "    this%1;\n"
+        "})").arg(ITERATION_COUNT).arg(argTemplate.arg(propertyName));
+    QScriptValue fun = engine.evaluate(code);
+    QVERIFY(fun.isFunction());
+
+    QBENCHMARK {
+        fun.call(object);
+    }
+    QVERIFY(!engine.hasUncaughtException());
+}
+
+void tst_QScriptQObject::writePropertyHelper(
+    QScriptEngine &engine, const QScriptValue &object,
+    const QString &propertyName, const QScriptValue &value,
+    const QString &argTemplate)
+{
+    QVERIFY(value.isValid());
+    QString code = QString::fromLatin1(
+        "(function(v) {\n"
+        "  for (var i = 0; i < %0; ++i)\n"
+        "    this%1 = v;\n"
+        "})").arg(ITERATION_COUNT).arg(argTemplate.arg(propertyName));
+    QScriptValue fun = engine.evaluate(code);
+    QVERIFY(fun.isFunction());
+
+    QScriptValueList args;
+    args << value;
+    QBENCHMARK {
+        fun.call(object, args);
+    }
+    QVERIFY(!engine.hasUncaughtException());
+}
+
+void tst_QScriptQObject::callMethodHelper(
+    QScriptEngine &engine, QObject *object,
+    const QString &propertyName, const QString &arguments)
+{
+    QScriptValue wrapper = engine.newQObject(object);
+    QScriptValue method = wrapper.property(propertyName);
+    QVERIFY(method.isFunction());
+
+    // Generate code that calls the function directly; in this way
+    // only function call performance is measured, not function lookup
+    // as well.
+    QString code = QString::fromLatin1(
+        "(function(f) {\n"
+        "  for (var i = 0; i < %0; ++i)\n"
+        "    f(%1);\n"
+        "})").arg(ITERATION_COUNT).arg(arguments);
+    QScriptValue fun = engine.evaluate(code);
+    QVERIFY(fun.isFunction());
+
+    QScriptValueList args;
+    args << method;
+    QBENCHMARK {
+        fun.call(wrapper, args);
+    }
+    QVERIFY(!engine.hasUncaughtException());
+}
+
+void tst_QScriptQObject::signalHandlerHelper(
+    QScriptEngine &engine, QObject *object, const char *signal)
+{
+    QScriptValue handler = engine.evaluate("(function(a) { return a; })");
+    QVERIFY(handler.isFunction());
+    QVERIFY(qScriptConnect(object, signal, QScriptValue(), handler));
+}
+
+void tst_QScriptQObject::readMetaProperty_data()
+{
+    readMetaProperty_dataHelper(&PropertyTestObject::staticMetaObject);
+}
+
+// Reads a meta-object-defined property from JS. The purpose of this
+// benchmark is to measure the overhead of reading a property from JS
+// compared to calling the property getter directly from C++ without
+// introspection or value conversion (that's the fastest we could
+// possibly hope to get).
+void tst_QScriptQObject::readMetaProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    PropertyTestObject testObject;
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName);
+}
+
+void tst_QScriptQObject::writeMetaProperty_data()
+{
+    readMetaProperty_data();
+}
+
+// Writes a meta-object-defined property from JS. The purpose of this
+// benchmark is to measure the overhead of writing a property from JS
+// compared to calling the property setter directly from C++ without
+// introspection or value conversion (that's the fastest we could
+// possibly hope to get).
+void tst_QScriptQObject::writeMetaProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    PropertyTestObject testObject;
+    QScriptValue wrapper = engine.newQObject(&testObject);
+    QScriptValue value = wrapper.property(propertyName);
+    writePropertyHelper(engine, wrapper, propertyName, value);
+}
+
+void tst_QScriptQObject::readDynamicProperty_data()
+{
+    QTest::addColumn<QVariant>("value");
+
+    QTest::newRow("bool") << QVariant(false);
+    QTest::newRow("int") << QVariant(123);
+    QTest::newRow("double") << QVariant(double(123.0));
+    QTest::newRow("string") << QVariant(QString::fromLatin1("hello"));
+    QTest::newRow("QObject*") << qVariantFromValue((QObject*)this);
+    QTest::newRow("CustomType") << qVariantFromValue(CustomType());
+}
+
+// Reads a dynamic property from JS. The purpose of this benchmark is
+// to measure the overhead of reading a dynamic property from JS
+// versus calling QObject::property(aDynamicProperty) directly from
+// C++.
+void tst_QScriptQObject::readDynamicProperty()
+{
+    QFETCH(QVariant, value);
+
+    QObject testObject;
+    const char *propertyName = "dynamicProperty";
+    testObject.setProperty(propertyName, value);
+    QVERIFY(testObject.dynamicPropertyNames().contains(propertyName));
+
+    QScriptEngine engine;
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName);
+}
+
+void tst_QScriptQObject::writeDynamicProperty_data()
+{
+    readDynamicProperty_data();
+}
+
+// Writes an existing dynamic property from JS. The purpose of this
+// benchmark is to measure the overhead of writing a dynamic property
+// from JS versus calling QObject::setProperty(aDynamicProperty,
+// aVariant) directly from C++.
+void tst_QScriptQObject::writeDynamicProperty()
+{
+    QFETCH(QVariant, value);
+
+    QObject testObject;
+    const char *propertyName = "dynamicProperty";
+    testObject.setProperty(propertyName, value);
+    QVERIFY(testObject.dynamicPropertyNames().contains(propertyName));
+
+    QScriptEngine engine;
+    writePropertyHelper(engine, engine.newQObject(&testObject), propertyName,
+                        qScriptValueFromValue(&engine, value));
+}
+
+void tst_QScriptQObject::readMethodByName_data()
+{
+    readMethodByName_dataHelper(&SlotTestObject::staticMetaObject);
+}
+
+// Reads a meta-object-defined method from JS by name. The purpose of
+// this benchmark is to measure the overhead of resolving a method
+// from JS (effectively, creating and returning a JS wrapper function
+// object for a C++ method).
+void tst_QScriptQObject::readMethodByName()
+{
+    readMetaProperty();
+}
+
+void tst_QScriptQObject::readMethodBySignature_data()
+{
+    readMethodBySignature_dataHelper(&SlotTestObject::staticMetaObject);
+}
+
+// Reads a meta-object-defined method from JS by signature. The
+// purpose of this benchmark is to measure the overhead of resolving a
+// method from JS (effectively, creating and returning a JS wrapper
+// function object for a C++ method).
+void tst_QScriptQObject::readMethodBySignature()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    SlotTestObject testObject;
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName, "['%0']");
+}
+
+void tst_QScriptQObject::readChild_data()
+{
+    QTest::addColumn<QString>("propertyName");
+
+    QTest::newRow("child") << "child";
+}
+
+// Reads a child object from JS. The purpose of this benchmark is to
+// measure the overhead of reading a child object from JS compared to
+// calling e.g. qFindChild() directly from C++, when the test object
+// is a plain QObject with only one child.
+void tst_QScriptQObject::readChild()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QObject testObject;
+    QObject *child = new QObject(&testObject);
+    child->setObjectName(propertyName);
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName);
+}
+
+void tst_QScriptQObject::readOneOfManyChildren_data()
+{
+    QTest::addColumn<QString>("propertyName");
+
+    QTest::newRow("child0") << "child0";
+    QTest::newRow("child50") << "child50";
+    QTest::newRow("child99") << "child99";
+}
+
+// Reads a child object from JS for an object that has many
+// children. The purpose of this benchmark is to measure the overhead
+// of reading a child object from JS compared to calling
+// e.g. qFindChild() directly from C++.
+void tst_QScriptQObject::readOneOfManyChildren()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QObject testObject;
+    for (int i = 0; i < 100; ++i) {
+        QObject *child = new QObject(&testObject);
+        child->setObjectName(QString::fromLatin1("child%0").arg(i));
+    }
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName);
+}
+
+void tst_QScriptQObject::readPrototypeProperty_data()
+{
+    QTest::addColumn<QString>("propertyName");
+
+    // Inherited from Object.prototype.
+    QTest::newRow("hasOwnProperty") << "hasOwnProperty";
+    QTest::newRow("isPrototypeOf") << "isPrototypeOf";
+    QTest::newRow("propertyIsEnumerable") << "propertyIsEnumerable";
+    QTest::newRow("valueOf") << "valueOf";
+}
+
+// Reads a property that's inherited from a prototype object. The
+// purpose of this benchmark is to measure the overhead of resolving a
+// prototype property (i.e., how long it takes the binding to
+// determine that the QObject doesn't have the property itself).
+void tst_QScriptQObject::readPrototypeProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    PropertyTestObject testObject;
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName);
+}
+
+void tst_QScriptQObject::readScriptProperty_data()
+{
+    QTest::addColumn<QString>("propertyName");
+
+    QTest::newRow("scriptProperty") << "scriptProperty";
+}
+
+// Reads a JS (non-Qt) property of a wrapper object. The purpose of
+// this benchmark is to measure the overhead of reading a property
+// that only exists on the wrapper object, not on the underlying
+// QObject.
+void tst_QScriptQObject::readScriptProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    PropertyTestObject testObject;
+    QScriptValue wrapper = engine.newQObject(&testObject);
+    wrapper.setProperty(propertyName, 123);
+    QVERIFY(wrapper.property(propertyName).isValid());
+    QVERIFY(!testObject.property(propertyName.toLatin1()).isValid());
+
+    readPropertyHelper(engine, wrapper, propertyName);
+}
+
+void tst_QScriptQObject::readNoSuchProperty_data()
+{
+    QTest::addColumn<QString>("propertyName");
+
+    QTest::newRow("noSuchProperty") << "noSuchProperty";
+}
+
+// Reads a non-existing (undefined) property of a wrapper object. The
+// purpose of this benchmark is to measure the overhead of reading a
+// property that doesn't exist (i.e., how long it takes the binding to
+// determine this).
+void tst_QScriptQObject::readNoSuchProperty()
+{
+    readMetaProperty();
+}
+
+// Reads all meta-object-defined properties from JS. The purpose of
+// this benchmark is to measure the overhead of reading different
+// properties in sequence, not just the same one repeatedly (like
+// readMetaProperty() does).
+void tst_QScriptQObject::readAllMetaProperties()
+{
+    PropertyTestObject testObject;
+    readAllMetaPropertiesHelper(&testObject);
+}
+
+void tst_QScriptQObject::callSlot_data()
+{
+    QTest::addColumn<QString>("propertyName");
+    QTest::addColumn<QString>("arguments");
+
+    QTest::newRow("voidSlot()") << "voidSlot" << "";
+
+    QTest::newRow("boolSlot(true)") << "boolSlot" << "true";
+    QTest::newRow("intSlot(123)") << "intSlot" << "123";
+    QTest::newRow("doubleSlot(123)") << "doubleSlot" << "123";
+    QTest::newRow("stringSlot('hello')") << "stringSlot" << "'hello'";
+    QTest::newRow("variantSlot(123)") << "variantSlot" << "123";
+    QTest::newRow("qobjectSlot(this)") << "qobjectSlot" << "this"; // assumes 'this' is a QObject
+
+    QTest::newRow("returnBoolSlot()") << "returnBoolSlot" << "";
+    QTest::newRow("returnIntSlot()") << "returnIntSlot" << "";
+    QTest::newRow("returnDoubleSlot()") << "returnDoubleSlot" << "";
+    QTest::newRow("returnStringSlot()") << "returnStringSlot" << "";
+    QTest::newRow("returnVariantSlot()") << "returnVariantSlot" << "";
+    QTest::newRow("returnQObjectSlot()") << "returnQObjectSlot" << "";
+    QTest::newRow("returnCustomTypeSlot()") << "returnCustomTypeSlot" << "";
+
+    // Implicit conversion.
+    QTest::newRow("boolSlot(0)") << "boolSlot" << "0";
+    QTest::newRow("intSlot('123')") << "intSlot" << "'123'";
+    QTest::newRow("doubleSlot('123')") << "doubleSlot" << "'123'";
+    QTest::newRow("stringSlot(123)") << "stringSlot" << "123";
+
+    // Many arguments.
+    QTest::newRow("fourDoubleSlot(1,2,3,4)") << "fourDoubleSlot" << "1,2,3,4";
+    QTest::newRow("sixDoubleSlot(1,2,3,4,5,6)") << "sixDoubleSlot" << "1,2,3,4,5,6";
+    QTest::newRow("eightDoubleSlot(1,2,3,4,5,6,7,8)") << "eightDoubleSlot" << "1,2,3,4,5,6,7,8";
+
+    QTest::newRow("fourStringSlot('a','b','c','d')") << "fourStringSlot" << "'a','b','c','d'";
+    QTest::newRow("sixStringSlot('a','b','c','d','e','f')") << "sixStringSlot" << "'a','b','c','d','e','f'";
+    QTest::newRow("eightStringSlot('a','b','c','d','e','f','g','h')") << "eightStringSlot" << "'a','b','c','d','e','f','g','h'";
+}
+
+// Calls a slot from JS. The purpose of this benchmark is to measure
+// the overhead of calling a slot from JS compared to calling the slot
+// directly from C++ without introspection or value conversion (that's
+// the fastest we could possibly hope to get). The slots themselves
+// don't do any work.
+void tst_QScriptQObject::callSlot()
+{
+    QFETCH(QString, propertyName);
+    QFETCH(QString, arguments);
+
+    QScriptEngine engine;
+    SlotTestObject testObject;
+    callMethodHelper(engine, &testObject, propertyName, arguments);
+}
+
+void tst_QScriptQObject::callOverloadedSlot_data()
+{
+    QTest::addColumn<QString>("propertyName");
+    QTest::addColumn<QString>("arguments");
+
+    QTest::newRow("overloadedSlot()") << "overloadedSlot" << "";
+    QTest::newRow("overloadedSlot(true)") << "overloadedSlot" << "true";
+    QTest::newRow("overloadedSlot(123)") << "overloadedSlot" << "123";
+    QTest::newRow("overloadedSlot('hello')") << "overloadedSlot" << "'hello'";
+}
+
+// Calls an overloaded slot from JS. The purpose of this benchmark is
+// to measure the overhead of calling an overloaded slot from JS
+// compared to calling the overloaded slot directly from C++ without
+// introspection or value conversion (that's the fastest we could
+// possibly hope to get).
+void tst_QScriptQObject::callOverloadedSlot()
+{
+    QFETCH(QString, propertyName);
+    QFETCH(QString, arguments);
+
+    QScriptEngine engine;
+    OverloadedSlotTestObject testObject;
+    callMethodHelper(engine, &testObject, propertyName, arguments);
+}
+
+// Benchmarks for JS signal handling. The purpose of these benchmarks
+// is to measure the overhead of dispatching a Qt signal to JS code
+// compared to a normal C++ signal-to-slot dispatch.
+
+void tst_QScriptQObject::voidSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(voidSignal()));
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitVoidSignal();
+    }
+}
+
+void tst_QScriptQObject::boolSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(boolSignal(bool)));
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitBoolSignal(true);
+    }
+}
+
+void tst_QScriptQObject::intSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(intSignal(int)));
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitIntSignal(123);
+    }
+}
+
+void tst_QScriptQObject::doubleSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(doubleSignal(double)));
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitDoubleSignal(123.0);
+    }
+}
+
+void tst_QScriptQObject::stringSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(stringSignal(QString)));
+    QString value = QString::fromLatin1("hello");
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitStringSignal(value);
+    }
+}
+
+void tst_QScriptQObject::variantSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(variantSignal(QVariant)));
+    QVariant value = 123;
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitVariantSignal(value);
+    }
+}
+
+void tst_QScriptQObject::qobjectSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(qobjectSignal(QObject*)));
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitQObjectSignal(this);
+    }
+}
+
+void tst_QScriptQObject::customTypeSignalHandler()
+{
+    SignalTestObject testObject;
+    QScriptEngine engine;
+    signalHandlerHelper(engine, &testObject, SIGNAL(customTypeSignal(CustomType)));
+    CustomType value;
+    QBENCHMARK {
+        for (int i = 0; i < ITERATION_COUNT; ++i)
+            testObject.emitCustomTypeSignal(value);
+    }
+}
+
+void tst_QScriptQObject::readButtonMetaProperty_data()
+{
+    readMetaProperty_dataHelper(&QPushButton::staticMetaObject);
+}
+
+// Reads a meta-object-defined property from JS. The purpose of this
+// benchmark is to measure the overhead of reading a property from JS
+// compared to calling the property getter directly from C++ without
+// introspection or value conversion (that's the fastest we could
+// possibly hope to get).
+void tst_QScriptQObject::readButtonMetaProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    readPropertyHelper(engine, engine.newQObject(&pb), propertyName);
+}
+
+void tst_QScriptQObject::writeButtonMetaProperty_data()
+{
+    readButtonMetaProperty_data();
+}
+
+// Writes a meta-object-defined property from JS. The purpose of this
+// benchmark is to measure the overhead of writing a property from JS
+// compared to calling the property setter directly from C++ without
+// introspection or value conversion (that's the fastest we could
+// possibly hope to get).
+void tst_QScriptQObject::writeButtonMetaProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    QVariant value = pb.property(propertyName.toLatin1());
+    writePropertyHelper(engine, engine.newQObject(&pb), propertyName,
+                        qScriptValueFromValue(&engine, value));
+}
+
+void tst_QScriptQObject::readDynamicButtonProperty_data()
+{
+    readDynamicProperty_data();
+}
+
+// Reads a dynamic property from JS. The purpose of this benchmark is
+// to measure the overhead of reading a dynamic property from JS
+// versus calling QObject::property(aDynamicProperty) directly from
+// C++.
+void tst_QScriptQObject::readDynamicButtonProperty()
+{
+    QFETCH(QVariant, value);
+
+    QPushButton pb;
+    const char *propertyName = "dynamicProperty";
+    pb.setProperty(propertyName, value);
+    QVERIFY(pb.dynamicPropertyNames().contains(propertyName));
+
+    QScriptEngine engine;
+    readPropertyHelper(engine, engine.newQObject(&pb), propertyName);
+}
+
+void tst_QScriptQObject::writeDynamicButtonProperty_data()
+{
+    readDynamicButtonProperty_data();
+}
+
+// Writes an existing dynamic property from JS. The purpose of this
+// benchmark is to measure the overhead of writing a dynamic property
+// from JS versus calling QObject::setProperty(aDynamicProperty,
+// aVariant) directly from C++.
+void tst_QScriptQObject::writeDynamicButtonProperty()
+{
+    QFETCH(QVariant, value);
+
+    QPushButton pb;
+    const char *propertyName = "dynamicProperty";
+    pb.setProperty(propertyName, value);
+    QVERIFY(pb.dynamicPropertyNames().contains(propertyName));
+
+    QScriptEngine engine;
+    writePropertyHelper(engine, engine.newQObject(&pb), propertyName,
+                        qScriptValueFromValue(&engine, value));
+}
+
+void tst_QScriptQObject::readButtonMethodByName_data()
+{
+    readMethodByName_dataHelper(&QPushButton::staticMetaObject);
+}
+
+// Reads a meta-object-defined method from JS by name. The purpose of
+// this benchmark is to measure the overhead of resolving a method
+// from JS (effectively, creating and returning a JS wrapper function
+// object for a C++ method).
+void tst_QScriptQObject::readButtonMethodByName()
+{
+    readButtonMetaProperty();
+}
+
+void tst_QScriptQObject::readButtonMethodBySignature_data()
+{
+    readMethodBySignature_dataHelper(&QPushButton::staticMetaObject);
+}
+
+// Reads a meta-object-defined method from JS by signature. The
+// purpose of this benchmark is to measure the overhead of resolving a
+// method from JS (effectively, creating and returning a JS wrapper
+// function object for a C++ method).
+void tst_QScriptQObject::readButtonMethodBySignature()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    readPropertyHelper(engine, engine.newQObject(&pb), propertyName, "['%0']");
+}
+
+void tst_QScriptQObject::readButtonChild_data()
+{
+    QTest::addColumn<QString>("propertyName");
+
+    QTest::newRow("child") << "child";
+}
+
+// Reads a child object from JS. The purpose of this benchmark is to
+// measure the overhead of reading a child object from JS compared to
+// calling e.g. qFindChild() directly from C++.
+void tst_QScriptQObject::readButtonChild()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    QObject *child = new QObject(&pb);
+    child->setObjectName(propertyName);
+    readPropertyHelper(engine, engine.newQObject(&pb), propertyName);
+}
+
+void tst_QScriptQObject::readButtonPrototypeProperty_data()
+{
+    readPrototypeProperty_data();
+}
+
+// Reads a property that's inherited from a prototype object. The
+// purpose of this benchmark is to measure the overhead of resolving a
+// prototype property (i.e., how long does it take the binding to
+// determine that the QObject doesn't have the property itself).
+void tst_QScriptQObject::readButtonPrototypeProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    readPropertyHelper(engine, engine.newQObject(&pb), propertyName);
+}
+
+void tst_QScriptQObject::readButtonScriptProperty_data()
+{
+    readScriptProperty_data();
+}
+
+// Reads a JS (non-Qt) property of a wrapper object. The purpose of
+// this benchmark is to measure the overhead of reading a property
+// that only exists on the wrapper object, not on the underlying
+// QObject.
+void tst_QScriptQObject::readButtonScriptProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    QScriptValue wrapper = engine.newQObject(&pb);
+    wrapper.setProperty(propertyName, 123);
+    QVERIFY(wrapper.property(propertyName).isValid());
+    QVERIFY(!pb.property(propertyName.toLatin1()).isValid());
+
+    readPropertyHelper(engine, wrapper, propertyName);
+}
+
+void tst_QScriptQObject::readNoSuchButtonProperty_data()
+{
+    readNoSuchProperty_data();
+}
+
+// Reads a non-existing (undefined) property of a wrapper object. The
+// purpose of this benchmark is to measure the overhead of reading a
+// property that doesn't exist (i.e., how long does it take the
+// binding to determine that it doesn't exist).
+void tst_QScriptQObject::readNoSuchButtonProperty()
+{
+    readButtonMetaProperty();
+}
+
+void tst_QScriptQObject::callButtonMethod_data()
+{
+    QTest::addColumn<QString>("propertyName");
+    QTest::addColumn<QString>("arguments");
+
+    QTest::newRow("click()") << "click" << "";
+    QTest::newRow("animateClick(50)") << "animateClick" << "10";
+    QTest::newRow("setChecked(true)") << "setChecked" << "true";
+    QTest::newRow("close()") << "close" << "";
+    QTest::newRow("setWindowTitle('foo')") << "setWindowTitle" << "'foo'";
+}
+
+// Calls a slot from JS. The purpose of this benchmark is to measure
+// the overhead of calling a slot from JS compared to calling the slot
+// directly from C++ without introspection or value conversion (that's
+// the fastest we could possibly hope to get).
+void tst_QScriptQObject::callButtonMethod()
+{
+    QFETCH(QString, propertyName);
+    QFETCH(QString, arguments);
+
+    QScriptEngine engine;
+    QPushButton pb;
+    callMethodHelper(engine, &pb, propertyName, arguments);
+}
+
+// Reads all meta-object-defined properties from JS. The purpose of
+// this benchmark is to measure the overhead of reading different
+// properties in sequence, not just the same one repeatedly (like
+// readButtonMetaProperty() does).
+void tst_QScriptQObject::readAllButtonMetaProperties()
+{
+    QPushButton pb;
+    readAllMetaPropertiesHelper(&pb);
+}
+
+void tst_QScriptQObject::readQScriptableMetaProperty_data()
+{
+    readMetaProperty_dataHelper(&QtScriptablePropertyTestObject::staticMetaObject);
+}
+
+// Reads a meta-object-defined property from JS for an object that
+// subclasses QScriptable. The purpose of this benchmark is to measure
+// the overhead compared to reading a property of a non-QScriptable
+// (see readMetaProperty()).
+void tst_QScriptQObject::readQScriptableMetaProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QtScriptablePropertyTestObject testObject;
+    readPropertyHelper(engine, engine.newQObject(&testObject), propertyName);
+}
+
+void tst_QScriptQObject::writeQScriptableMetaProperty_data()
+{
+    readMetaProperty_data();
+}
+
+// Writes a meta-object-defined property from JS for an object that
+// subclasses QScriptable. The purpose of this benchmark is to measure
+// the overhead compared to writing a property of a non-QScriptable
+// object (see writeMetaProperty()).
+void tst_QScriptQObject::writeQScriptableMetaProperty()
+{
+    QFETCH(QString, propertyName);
+
+    QScriptEngine engine;
+    QtScriptablePropertyTestObject testObject;
+    QVariant value = testObject.property(propertyName.toLatin1());
+    writePropertyHelper(engine, engine.newQObject(&testObject), propertyName,
+                        qScriptValueFromValue(&engine, value));
+}
+
+void tst_QScriptQObject::callQScriptableSlot_data()
+{
+    callSlot_data();
+}
+
+// Calls a slot from JS for an object that subclasses QScriptable. The
+// purpose of this benchmark is to measure the overhead compared to
+// calling a slot of a non-QScriptable object (see callSlot()).
+void tst_QScriptQObject::callQScriptableSlot()
+{
+    QFETCH(QString, propertyName);
+    QFETCH(QString, arguments);
+
+    QScriptEngine engine;
+    QtScriptableSlotTestObject testObject;
+    callMethodHelper(engine, &testObject, propertyName, arguments);
+}
+
+QTEST_MAIN(tst_QScriptQObject)
+#include "tst_qscriptqobject.moc"