diff options
Diffstat (limited to 'tests')
8 files changed, 1579 insertions, 0 deletions
diff --git a/tests/benchmarks/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/benchmarks/corelib/kernel/qmetatype/tst_qmetatype.cpp index 36399af..ebeea84 100644 --- a/tests/benchmarks/corelib/kernel/qmetatype/tst_qmetatype.cpp +++ b/tests/benchmarks/corelib/kernel/qmetatype/tst_qmetatype.cpp @@ -71,6 +71,11 @@ private slots: void isRegisteredBuiltin(); void isRegisteredCustom(); void isRegisteredNotRegistered(); + + void constructCoreType_data(); + void constructCoreType(); + void constructCoreTypeCopy_data(); + void constructCoreTypeCopy(); }; tst_QMetaType::tst_QMetaType() @@ -229,5 +234,52 @@ void tst_QMetaType::isRegisteredNotRegistered() } } +void tst_QMetaType::constructCoreType_data() +{ + QTest::addColumn<int>("typeId"); + for (int i = 0; i <= QMetaType::LastCoreType; ++i) + QTest::newRow(QMetaType::typeName(i)) << i; + for (int i = QMetaType::FirstCoreExtType; i <= QMetaType::LastCoreExtType; ++i) + QTest::newRow(QMetaType::typeName(i)) << i; + // GUI types are tested in tst_QGuiMetaType. +} + +// Tests how fast QMetaType can default-construct and destroy a Qt +// core type. The purpose of this benchmark is to measure the overhead +// of using type id-based creation compared to creating the type +// directly (i.e. "T *t = new T(); delete t;"). +void tst_QMetaType::constructCoreType() +{ + QFETCH(int, typeId); + QBENCHMARK { + for (int i = 0; i < 100000; ++i) { + void *data = QMetaType::construct(typeId, (void *)0); + QMetaType::destroy(typeId, data); + } + } +} + +void tst_QMetaType::constructCoreTypeCopy_data() +{ + constructCoreType_data(); +} + +// Tests how fast QMetaType can copy-construct and destroy a Qt core +// type. The purpose of this benchmark is to measure the overhead of +// using type id-based creation compared to creating the type directly +// (i.e. "T *t = new T(other); delete t;"). +void tst_QMetaType::constructCoreTypeCopy() +{ + QFETCH(int, typeId); + QVariant other(typeId, (void *)0); + const void *copy = other.constData(); + QBENCHMARK { + for (int i = 0; i < 100000; ++i) { + void *data = QMetaType::construct(typeId, copy); + QMetaType::destroy(typeId, data); + } + } +} + QTEST_MAIN(tst_QMetaType) #include "tst_qmetatype.moc" diff --git a/tests/benchmarks/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/benchmarks/corelib/kernel/qvariant/tst_qvariant.cpp index 58cec4f..5e19c1b 100644 --- a/tests/benchmarks/corelib/kernel/qvariant/tst_qvariant.cpp +++ b/tests/benchmarks/corelib/kernel/qvariant/tst_qvariant.cpp @@ -71,6 +71,11 @@ private slots: void floatVariantValue(); void rectVariantValue(); void stringVariantValue(); + + void createCoreType_data(); + void createCoreType(); + void createCoreTypeCopy_data(); + void createCoreTypeCopy(); }; void tst_qvariant::testBound() @@ -220,6 +225,48 @@ void tst_qvariant::stringVariantValue() } } +void tst_qvariant::createCoreType_data() +{ + QTest::addColumn<int>("typeId"); + for (int i = 0; i <= QMetaType::LastCoreType; ++i) + QTest::newRow(QMetaType::typeName(i)) << i; + for (int i = QMetaType::FirstCoreExtType; i <= QMetaType::LastCoreExtType; ++i) + QTest::newRow(QMetaType::typeName(i)) << i; +} + +// Tests how fast a Qt core type can be default-constructed by a +// QVariant. The purpose of this benchmark is to measure the overhead +// of creating (and destroying) a QVariant compared to creating the +// type directly. +void tst_qvariant::createCoreType() +{ + QFETCH(int, typeId); + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) + QVariant(typeId, (void *)0); + } +} + +void tst_qvariant::createCoreTypeCopy_data() +{ + createCoreType_data(); +} + +// Tests how fast a Qt core type can be copy-constructed by a +// QVariant. The purpose of this benchmark is to measure the overhead +// of creating (and destroying) a QVariant compared to creating the +// type directly. +void tst_qvariant::createCoreTypeCopy() +{ + QFETCH(int, typeId); + QVariant other(typeId, (void *)0); + const void *copy = other.constData(); + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) + QVariant(typeId, copy); + } +} + QTEST_MAIN(tst_qvariant) #include "tst_qvariant.moc" diff --git a/tests/benchmarks/gui/kernel/qguimetatype/qguimetatype.pro b/tests/benchmarks/gui/kernel/qguimetatype/qguimetatype.pro new file mode 100644 index 0000000..7ef99e4 --- /dev/null +++ b/tests/benchmarks/gui/kernel/qguimetatype/qguimetatype.pro @@ -0,0 +1,6 @@ +load(qttest_p4) +TEMPLATE = app +TARGET = tst_bench_qguimetatype + +SOURCES += tst_qguimetatype.cpp + diff --git a/tests/benchmarks/gui/kernel/qguimetatype/tst_qguimetatype.cpp b/tests/benchmarks/gui/kernel/qguimetatype/tst_qguimetatype.cpp new file mode 100644 index 0000000..f94767b --- /dev/null +++ b/tests/benchmarks/gui/kernel/qguimetatype/tst_qguimetatype.cpp @@ -0,0 +1,113 @@ +/**************************************************************************** +** +** 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 <QtCore/qmetatype.h> + +class tst_QGuiMetaType : public QObject +{ + Q_OBJECT + +public: + tst_QGuiMetaType(); + virtual ~tst_QGuiMetaType(); + +private slots: + void constructGuiType_data(); + void constructGuiType(); + void constructGuiTypeCopy_data(); + void constructGuiTypeCopy(); +}; + +tst_QGuiMetaType::tst_QGuiMetaType() +{ +} + +tst_QGuiMetaType::~tst_QGuiMetaType() +{ +} + +void tst_QGuiMetaType::constructGuiType_data() +{ + QTest::addColumn<int>("typeId"); + for (int i = QMetaType::FirstGuiType; i <= QMetaType::LastGuiType; ++i) + QTest::newRow(QMetaType::typeName(i)) << i; +} + +// Tests how fast QMetaType can default-construct and destroy a Qt GUI +// type. The purpose of this benchmark is to measure the overhead of +// using type id-based creation compared to creating the type directly +// (i.e. "T *t = new T(); delete t;"). +void tst_QGuiMetaType::constructGuiType() +{ + QFETCH(int, typeId); + QBENCHMARK { + for (int i = 0; i < 100000; ++i) { + void *data = QMetaType::construct(typeId, (void *)0); + QMetaType::destroy(typeId, data); + } + } +} + +void tst_QGuiMetaType::constructGuiTypeCopy_data() +{ + constructGuiType_data(); +} + +// Tests how fast QMetaType can copy-construct and destroy a Qt GUI +// type. The purpose of this benchmark is to measure the overhead of +// using type id-based creation compared to creating the type directly +// (i.e. "T *t = new T(other); delete t;"). +void tst_QGuiMetaType::constructGuiTypeCopy() +{ + QFETCH(int, typeId); + QVariant other(typeId, (void *)0); + const void *copy = other.constData(); + QBENCHMARK { + for (int i = 0; i < 100000; ++i) { + void *data = QMetaType::construct(typeId, copy); + QMetaType::destroy(typeId, data); + } + } +} + +QTEST_MAIN(tst_QGuiMetaType) +#include "tst_qguimetatype.moc" diff --git a/tests/benchmarks/gui/kernel/qguivariant/qguivariant.pro b/tests/benchmarks/gui/kernel/qguivariant/qguivariant.pro new file mode 100644 index 0000000..4e05dd7 --- /dev/null +++ b/tests/benchmarks/gui/kernel/qguivariant/qguivariant.pro @@ -0,0 +1,6 @@ +load(qttest_p4) +TEMPLATE = app +TARGET = tst_bench_qguivariant + +SOURCES += tst_qguivariant.cpp + diff --git a/tests/benchmarks/gui/kernel/qguivariant/tst_qguivariant.cpp b/tests/benchmarks/gui/kernel/qguivariant/tst_qguivariant.cpp new file mode 100644 index 0000000..4016be1 --- /dev/null +++ b/tests/benchmarks/gui/kernel/qguivariant/tst_qguivariant.cpp @@ -0,0 +1,111 @@ +/**************************************************************************** +** +** 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 <QtCore/qvariant.h> + +#define ITERATION_COUNT 1e5 + +class tst_QGuiVariant : public QObject +{ + Q_OBJECT + +public: + tst_QGuiVariant(); + virtual ~tst_QGuiVariant(); + +private slots: + void createGuiType_data(); + void createGuiType(); + void createGuiTypeCopy_data(); + void createGuiTypeCopy(); +}; + +tst_QGuiVariant::tst_QGuiVariant() +{ +} + +tst_QGuiVariant::~tst_QGuiVariant() +{ +} + +void tst_QGuiVariant::createGuiType_data() +{ + QTest::addColumn<int>("typeId"); + for (int i = QMetaType::FirstGuiType; i <= QMetaType::LastGuiType; ++i) + QTest::newRow(QMetaType::typeName(i)) << i; +} + +// Tests how fast a Qt GUI type can be default-constructed by a +// QVariant. The purpose of this benchmark is to measure the overhead +// of creating (and destroying) a QVariant compared to creating the +// type directly. +void tst_QGuiVariant::createGuiType() +{ + QFETCH(int, typeId); + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) + QVariant(typeId, (void *)0); + } +} + +void tst_QGuiVariant::createGuiTypeCopy_data() +{ + createGuiType_data(); +} + +// Tests how fast a Qt GUI type can be copy-constructed by a +// QVariant. The purpose of this benchmark is to measure the overhead +// of creating (and destroying) a QVariant compared to creating the +// type directly. +void tst_QGuiVariant::createGuiTypeCopy() +{ + QFETCH(int, typeId); + QVariant other(typeId, (void *)0); + const void *copy = other.constData(); + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) + QVariant(typeId, copy); + } +} + +QTEST_MAIN(tst_QGuiVariant) +#include "tst_qguivariant.moc" 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" |