/****************************************************************************

**

** 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 <QtTest/QtTest>

#include <QtCore/qlocale.h>

#include <private/qmetaobjectbuilder_p.h>

class tst_QMetaObjectBuilder : public QObject

{

    Q_OBJECT

public:

    tst_QMetaObjectBuilder() {}

    ~tst_QMetaObjectBuilder() {}

private slots:

    void mocVersionCheck();

    void create();

    void className();

    void superClass();

    void flags();

    void method();

    void slot();

    void signal();

    void constructor();

    void property();

    void notifySignal();

    void enumerator();

    void classInfo();

    void relatedMetaObject();

    void staticMetacall();

    void copyMetaObject();

    void serialize();

    void removeNotifySignal();

private:

    static bool checkForSideEffects

        (const QMetaObjectBuilder& builder,

         QMetaObjectBuilder::AddMembers members);

    static bool sameMetaObject

        (const QMetaObject *meta1, const QMetaObject *meta2);

};

// Dummy class that has something of every type of thing moc can generate.

class SomethingOfEverything : public QObject

{

    Q_OBJECT

    Q_CLASSINFO("ci_foo", "ABC")

    Q_CLASSINFO("ci_bar", "DEF")

    Q_PROPERTY(QString prop READ prop WRITE setProp NOTIFY propChanged)

    Q_PROPERTY(QString prop2 READ prop WRITE setProp)

    Q_PROPERTY(SomethingEnum eprop READ eprop)

    Q_PROPERTY(SomethingFlagEnum fprop READ fprop)

    Q_PROPERTY(QLocale::Language language READ language)

    Q_ENUMS(SomethingEnum)

    Q_FLAGS(SomethingFlagEnum)

public:

    Q_INVOKABLE SomethingOfEverything() {}

    ~SomethingOfEverything() {}

    enum SomethingEnum

    {

        GHI,

        JKL = 10

    };

    enum SomethingFlagEnum

    {

        XYZ = 1,

        UVW = 8

    };

    Q_INVOKABLE Q_SCRIPTABLE void method1() {}

    QString prop() const { return QString(); }

    void setProp(const QString& v) { Q_UNUSED(v); }

    SomethingOfEverything::SomethingEnum eprop() const { return GHI; }

    SomethingOfEverything::SomethingFlagEnum fprop() const { return XYZ; }

    QLocale::Language language() const { return QLocale::English; }

public slots:

    void slot1(const QString&) {}

    void slot2(int, const QString&) {}

private slots:

    void slot3() {}

protected slots:

    Q_SCRIPTABLE void slot4(int) {}

    void slot5(int a, const QString& b) { Q_UNUSED(a); Q_UNUSED(b); }

signals:

    void sig1();

    void sig2(int x, const QString& y);

    void propChanged(const QString&);

};

void tst_QMetaObjectBuilder::mocVersionCheck()

{

    // This test will fail when the moc version number is changed.

    // It is intended as a reminder to also update QMetaObjectBuilder

    // whenenver moc changes.  Once QMetaObjectBuilder has been

    // updated, this test can be changed to check for the next version.

    int version = int(QObject::staticMetaObject.d.data[0]);

    QVERIFY(version == 4 || version == 5);

    version = int(staticMetaObject.d.data[0]);

    QVERIFY(version == 4 || version == 5);

}

void tst_QMetaObjectBuilder::create()

{

    QMetaObjectBuilder builder;

    QVERIFY(builder.className().isEmpty());

    QVERIFY(builder.superClass() == &QObject::staticMetaObject);

    QCOMPARE(builder.methodCount(), 0);

    QCOMPARE(builder.constructorCount(), 0);

    QCOMPARE(builder.propertyCount(), 0);

    QCOMPARE(builder.enumeratorCount(), 0);

    QCOMPARE(builder.classInfoCount(), 0);

    QCOMPARE(builder.relatedMetaObjectCount(), 0);

    QVERIFY(builder.staticMetacallFunction() == 0);

}

void tst_QMetaObjectBuilder::className()

{

    QMetaObjectBuilder builder;

    // Change the class name.

    builder.setClassName("Foo");

    QCOMPARE(builder.className(), QByteArray("Foo"));

    // Change it again.

    builder.setClassName("Bar");

    QCOMPARE(builder.className(), QByteArray("Bar"));

    // Clone the class name off a static QMetaObject.

    builder.addMetaObject(&QObject::staticMetaObject, QMetaObjectBuilder::ClassName);

    QCOMPARE(builder.className(), QByteArray("QObject"));

    // Check that nothing else changed.

    QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::ClassName));

}

void tst_QMetaObjectBuilder::superClass()

{

    QMetaObjectBuilder builder;

    // Change the super class.

    builder.setSuperClass(&QObject::staticMetaObject);

    QVERIFY(builder.superClass() == &QObject::staticMetaObject);

    // Change it again.

    builder.setSuperClass(&staticMetaObject);

    QVERIFY(builder.superClass() == &staticMetaObject);

    // Clone the super class off a static QMetaObject.

    builder.addMetaObject(&QObject::staticMetaObject, QMetaObjectBuilder::SuperClass);

    QVERIFY(builder.superClass() == 0);

    builder.addMetaObject(&staticMetaObject, QMetaObjectBuilder::SuperClass);

    QVERIFY(builder.superClass() == staticMetaObject.superClass());

    // Check that nothing else changed.

    QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::SuperClass));

}

void tst_QMetaObjectBuilder::flags()

{

    QMetaObjectBuilder builder;

    // Check default

    QVERIFY(builder.flags() == 0);

    // Set flags

    builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);

    QVERIFY(builder.flags() == QMetaObjectBuilder::DynamicMetaObject);

}

void tst_QMetaObjectBuilder::method()

{

    QMetaObjectBuilder builder;

    // Check null method

    QMetaMethodBuilder nullMethod;

    QCOMPARE(nullMethod.signature(), QByteArray());

    QVERIFY(nullMethod.methodType() == QMetaMethod::Method);

    QVERIFY(nullMethod.returnType().isEmpty());

    QVERIFY(nullMethod.parameterNames().isEmpty());

    QVERIFY(nullMethod.tag().isEmpty());

    QVERIFY(nullMethod.access() == QMetaMethod::Public);

    QCOMPARE(nullMethod.attributes(), 0);

    QCOMPARE(nullMethod.index(), 0);

    // Add a method and check its attributes.

    QMetaMethodBuilder method1 = builder.addMethod("foo(const QString&, int)");

    QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(method1.methodType() == QMetaMethod::Method);

    QVERIFY(method1.returnType().isEmpty());

    QVERIFY(method1.parameterNames().isEmpty());

    QVERIFY(method1.tag().isEmpty());

    QVERIFY(method1.access() == QMetaMethod::Public);

    QCOMPARE(method1.attributes(), 0);

    QCOMPARE(method1.index(), 0);

    QCOMPARE(builder.methodCount(), 1);

    // Add another method and check again.

    QMetaMethodBuilder method2 = builder.addMethod("bar(QString)", "int");

    QCOMPARE(method2.signature(), QByteArray("bar(QString)"));

    QVERIFY(method2.methodType() == QMetaMethod::Method);

    QCOMPARE(method2.returnType(), QByteArray("int"));

    QVERIFY(method2.parameterNames().isEmpty());

    QVERIFY(method2.tag().isEmpty());

    QVERIFY(method2.access() == QMetaMethod::Public);

    QCOMPARE(method2.attributes(), 0);

    QCOMPARE(method2.index(), 1);

    QCOMPARE(builder.methodCount(), 2);

    // Perform index-based lookup.

    QCOMPARE(builder.indexOfMethod("foo(const QString&, int)"), 0);

    QCOMPARE(builder.indexOfMethod("bar(QString)"), 1);

    QCOMPARE(builder.indexOfMethod("baz()"), -1);

    // Modify the attributes on method1.

    method1.setReturnType("int");

    method1.setParameterNames(QList<QByteArray>() << "a" << "b");

    method1.setTag("tag");

    method1.setAccess(QMetaMethod::Private);

    method1.setAttributes(42);

    // Check that method1 is changed, but method2 is not.

    QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(method1.methodType() == QMetaMethod::Method);

    QCOMPARE(method1.returnType(), QByteArray("int"));

    QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");

    QCOMPARE(method1.tag(), QByteArray("tag"));

    QVERIFY(method1.access() == QMetaMethod::Private);

    QCOMPARE(method1.attributes(), 42);

    QCOMPARE(method1.index(), 0);

    QCOMPARE(method2.signature(), QByteArray("bar(QString)"));

    QVERIFY(method2.methodType() == QMetaMethod::Method);

    QCOMPARE(method2.returnType(), QByteArray("int"));

    QVERIFY(method2.parameterNames().isEmpty());

    QVERIFY(method2.tag().isEmpty());

    QVERIFY(method2.access() == QMetaMethod::Public);

    QCOMPARE(method2.attributes(), 0);

    QCOMPARE(method2.index(), 1);

    QCOMPARE(builder.methodCount(), 2);

    // Modify the attributes on method2.

    method2.setReturnType("QString");

    method2.setParameterNames(QList<QByteArray>() << "c");

    method2.setTag("Q_FOO");

    method2.setAccess(QMetaMethod::Protected);

    method2.setAttributes(24);

    // This time check that only method2 changed.

    QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(method1.methodType() == QMetaMethod::Method);

    QCOMPARE(method1.returnType(), QByteArray("int"));

    QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");

    QCOMPARE(method1.tag(), QByteArray("tag"));

    QVERIFY(method1.access() == QMetaMethod::Private);

    QCOMPARE(method1.attributes(), 42);

    QCOMPARE(method1.index(), 0);

    QCOMPARE(method2.signature(), QByteArray("bar(QString)"));

    QVERIFY(method2.methodType() == QMetaMethod::Method);

    QCOMPARE(method2.returnType(), QByteArray("QString"));

    QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");

    QCOMPARE(method2.tag(), QByteArray("Q_FOO"));

    QVERIFY(method2.access() == QMetaMethod::Protected);

    QCOMPARE(method2.attributes(), 24);

    QCOMPARE(method2.index(), 1);

    QCOMPARE(builder.methodCount(), 2);

    // Remove method1 and check that method2 becomes index 0.

    builder.removeMethod(0);

    QCOMPARE(builder.methodCount(), 1);

    method2 = builder.method(0);

    QCOMPARE(method2.signature(), QByteArray("bar(QString)"));

    QVERIFY(method2.methodType() == QMetaMethod::Method);

    QCOMPARE(method2.returnType(), QByteArray("QString"));

    QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");

    QCOMPARE(method2.tag(), QByteArray("Q_FOO"));

    QVERIFY(method2.access() == QMetaMethod::Protected);

    QCOMPARE(method2.attributes(), 24);

    QCOMPARE(method2.index(), 0);

    // Perform index-based lookup again.

    QCOMPARE(builder.indexOfMethod("foo(const QString&, int)"), -1);

    QCOMPARE(builder.indexOfMethod("bar(QString)"), 0);

    QCOMPARE(builder.indexOfMethod("baz()"), -1);

    QCOMPARE(builder.method(0).signature(), QByteArray("bar(QString)"));

    QCOMPARE(builder.method(9).signature(), QByteArray());

    // Check that nothing else changed.

    QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Methods));

}

void tst_QMetaObjectBuilder::slot()

{

    QMetaObjectBuilder builder;

    // Add a slot and check its attributes.

    QMetaMethodBuilder method1 = builder.addSlot("foo(const QString&, int)");

    QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(method1.methodType() == QMetaMethod::Slot);

    QVERIFY(method1.returnType().isEmpty());

    QVERIFY(method1.parameterNames().isEmpty());

    QVERIFY(method1.tag().isEmpty());

    QVERIFY(method1.access() == QMetaMethod::Public);

    QCOMPARE(method1.attributes(), 0);

    QCOMPARE(method1.index(), 0);

    QCOMPARE(builder.methodCount(), 1);

    // Add another slot and check again.

    QMetaMethodBuilder method2 = builder.addSlot("bar(QString)");

    QCOMPARE(method2.signature(), QByteArray("bar(QString)"));

    QVERIFY(method2.methodType() == QMetaMethod::Slot);

    QVERIFY(method2.returnType().isEmpty());

    QVERIFY(method2.parameterNames().isEmpty());

    QVERIFY(method2.tag().isEmpty());

    QVERIFY(method2.access() == QMetaMethod::Public);

    QCOMPARE(method2.attributes(), 0);

    QCOMPARE(method2.index(), 1);

    QCOMPARE(builder.methodCount(), 2);

    // Perform index-based lookup

    QCOMPARE(builder.indexOfSlot("foo(const QString &, int)"), 0);

    QCOMPARE(builder.indexOfSlot("bar(QString)"), 1);

    QCOMPARE(builder.indexOfSlot("baz()"), -1);

    // Check that nothing else changed.

    QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Methods));

}

void tst_QMetaObjectBuilder::signal()

{

    QMetaObjectBuilder builder;

    // Add a signal and check its attributes.

    QMetaMethodBuilder method1 = builder.addSignal("foo(const QString&, int)");

    QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(method1.methodType() == QMetaMethod::Signal);

    QVERIFY(method1.returnType().isEmpty());

    QVERIFY(method1.parameterNames().isEmpty());

    QVERIFY(method1.tag().isEmpty());

    QVERIFY(method1.access() == QMetaMethod::Protected);

    QCOMPARE(method1.attributes(), 0);

    QCOMPARE(method1.index(), 0);

    QCOMPARE(builder.methodCount(), 1);

    // Add another signal and check again.

    QMetaMethodBuilder method2 = builder.addSignal("bar(QString)");

    QCOMPARE(method2.signature(), QByteArray("bar(QString)"));

    QVERIFY(method2.methodType() == QMetaMethod::Signal);

    QVERIFY(method2.returnType().isEmpty());

    QVERIFY(method2.parameterNames().isEmpty());

    QVERIFY(method2.tag().isEmpty());

    QVERIFY(method2.access() == QMetaMethod::Protected);

    QCOMPARE(method2.attributes(), 0);

    QCOMPARE(method2.index(), 1);

    QCOMPARE(builder.methodCount(), 2);

    // Perform index-based lookup

    QCOMPARE(builder.indexOfSignal("foo(const QString &, int)"), 0);

    QCOMPARE(builder.indexOfSignal("bar(QString)"), 1);

    QCOMPARE(builder.indexOfSignal("baz()"), -1);

    // Check that nothing else changed.

    QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Methods));

}

void tst_QMetaObjectBuilder::constructor()

{

    QMetaObjectBuilder builder;

    // Add a constructor and check its attributes.

    QMetaMethodBuilder ctor1 = builder.addConstructor("foo(const QString&, int)");

    QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);

    QVERIFY(ctor1.returnType().isEmpty());

    QVERIFY(ctor1.parameterNames().isEmpty());

    QVERIFY(ctor1.tag().isEmpty());

    QVERIFY(ctor1.access() == QMetaMethod::Public);

    QCOMPARE(ctor1.attributes(), 0);

    QCOMPARE(ctor1.index(), 0);

    QCOMPARE(builder.constructorCount(), 1);

    // Add another constructor and check again.

    QMetaMethodBuilder ctor2 = builder.addConstructor("bar(QString)");

    QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));

    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);

    QVERIFY(ctor2.returnType().isEmpty());

    QVERIFY(ctor2.parameterNames().isEmpty());

    QVERIFY(ctor2.tag().isEmpty());

    QVERIFY(ctor2.access() == QMetaMethod::Public);

    QCOMPARE(ctor2.attributes(), 0);

    QCOMPARE(ctor2.index(), 1);

    QCOMPARE(builder.constructorCount(), 2);

    // Perform index-based lookup.

    QCOMPARE(builder.indexOfConstructor("foo(const QString&, int)"), 0);

    QCOMPARE(builder.indexOfConstructor("bar(QString)"), 1);

    QCOMPARE(builder.indexOfConstructor("baz()"), -1);

    QCOMPARE(builder.constructor(1).signature(), QByteArray("bar(QString)"));

    QCOMPARE(builder.constructor(9).signature(), QByteArray());

    // Modify the attributes on ctor1.

    ctor1.setReturnType("int");

    ctor1.setParameterNames(QList<QByteArray>() << "a" << "b");

    ctor1.setTag("tag");

    ctor1.setAccess(QMetaMethod::Private);

    ctor1.setAttributes(42);

    // Check that ctor1 is changed, but ctor2 is not.

    QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);

    QCOMPARE(ctor1.returnType(), QByteArray("int"));

    QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");

    QCOMPARE(ctor1.tag(), QByteArray("tag"));

    QVERIFY(ctor1.access() == QMetaMethod::Private);

    QCOMPARE(ctor1.attributes(), 42);

    QCOMPARE(ctor1.index(), 0);

    QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));

    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);

    QVERIFY(ctor2.returnType().isEmpty());

    QVERIFY(ctor2.parameterNames().isEmpty());

    QVERIFY(ctor2.tag().isEmpty());

    QVERIFY(ctor2.access() == QMetaMethod::Public);

    QCOMPARE(ctor2.attributes(), 0);

    QCOMPARE(ctor2.index(), 1);

    QCOMPARE(builder.constructorCount(), 2);

    // Modify the attributes on ctor2.

    ctor2.setReturnType("QString");

    ctor2.setParameterNames(QList<QByteArray>() << "c");

    ctor2.setTag("Q_FOO");

    ctor2.setAccess(QMetaMethod::Protected);

    ctor2.setAttributes(24);

    // This time check that only ctor2 changed.

    QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));

    QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);

    QCOMPARE(ctor1.returnType(), QByteArray("int"));

    QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");

    QCOMPARE(ctor1.tag(), QByteArray("tag"));

    QVERIFY(ctor1.access() == QMetaMethod::Private);

    QCOMPARE(ctor1.attributes(), 42);

    QCOMPARE(ctor1.index(), 0);

    QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));

    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);

    QCOMPARE(ctor2.returnType(), QByteArray("QString"));

    QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");

    QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));

    QVERIFY(ctor2.access() == QMetaMethod::Protected);

    QCOMPARE(ctor2.attributes(), 24);

    QCOMPARE(ctor2.index(), 1);

    QCOMPARE(builder.constructorCount(), 2);

    // Remove ctor1 and check that ctor2 becomes index 0.

    builder.removeConstructor(0);

    QCOMPARE(builder.constructorCount(), 1);

    ctor2 = builder.constructor(0);

    QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));

    QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);

    QCOMPARE(ctor2.returnType(), QByteArray("QString"));

    QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");

    QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));

    QVERIFY(ctor2.access() == QMetaMethod::Protected);

    QCOMPARE(ctor2.attributes(), 24);

    QCOMPARE(ctor2.index(), 0);

    // Perform index-based lookup again.

    QCOMPARE(builder.indexOfConstructor("foo(const QString&, int)"), -1);

    QCOMPARE(builder.indexOfConstructor("bar(QString)"), 0);

    QCOMPARE(builder.indexOfConstructor("baz()"), -1);

    // Add constructor from prototype

    QMetaMethod prototype = SomethingOfEverything::staticMetaObject.constructor(0);

    QMetaMethodBuilder prototypeConstructor = builder.addMethod(prototype);

    QCOMPARE(builder.constructorCount(), 2);

    QCOMPARE(prototypeConstructor.signature(), QByteArray("SomethingOfEverything()"));

    QVERIFY(prototypeConstructor.methodType() == QMetaMethod::Constructor);

    QCOMPARE(prototypeConstructor.returnType(), QByteArray());

    QVERIFY(prototypeConstructor.access() == QMetaMethod::Public);

    QCOMPARE(prototypeConstructor.index(), 1);

    // Check that nothing else changed.

    QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Constructors));

}