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

**

** 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 <qcoreapplication.h>

#include <qdebug.h>

#include <QtTest/QtTest>

#include <QtDBus>

#include "../qdbusmarshall/common.h"

const char *slotSpy;

QString valueSpy;

QT_BEGIN_NAMESPACE

namespace QTest {

    char *toString(QDBusMessage::MessageType t)

    {

        switch (t)

        {

        case QDBusMessage::InvalidMessage:

            return qstrdup("InvalidMessage");

        case QDBusMessage::MethodCallMessage:

            return qstrdup("MethodCallMessage");

        case QDBusMessage::ReplyMessage:

            return qstrdup("ReplyMessage");

        case QDBusMessage::ErrorMessage:

            return qstrdup("ErrorMessage");

        case QDBusMessage::SignalMessage:

            return qstrdup("SignalMessage");

        default:

            return 0;

        }

    }

}

QT_END_NAMESPACE

class tst_QDBusAbstractAdaptor: public QObject

{

    Q_OBJECT

private slots:

    void initTestCase() { commonInit(); }

    void methodCalls_data();

    void methodCalls();

    void methodCallScriptable();

    void signalEmissions_data();

    void signalEmissions();

    void sameSignalDifferentPaths();

    void sameObjectDifferentPaths();

    void scriptableSignalOrNot();

    void overloadedSignalEmission_data();

    void overloadedSignalEmission();

    void readProperties();

    void readPropertiesInvalidInterface();

    void readPropertiesEmptyInterface_data();

    void readPropertiesEmptyInterface();

    void readAllProperties();

    void readAllPropertiesInvalidInterface();

    void readAllPropertiesEmptyInterface_data();

    void readAllPropertiesEmptyInterface();

    void writeProperties();

    void typeMatching_data();

    void typeMatching();

    void methodWithMoreThanOneReturnValue();

};

class QDBusSignalSpy: public QObject

{

    Q_OBJECT

public slots:

    void slot(const QDBusMessage &msg)

    {

        ++count;

        interface = msg.interface();

        name = msg.member();

        signature = msg.signature();

        path = msg.path();

        value.clear();

        if (msg.arguments().count())

            value = msg.arguments().at(0);

    }

public:

    QDBusSignalSpy() : count(0) { }

    int count;

    QString interface;

    QString name;

    QString signature;

    QString path;

    QVariant value;

};

class Interface1: public QDBusAbstractAdaptor

{

    Q_OBJECT

    Q_CLASSINFO("D-Bus Interface", "local.Interface1")

public:

    Interface1(QObject *parent) : QDBusAbstractAdaptor(parent)

    { }

};

class Interface2: public QDBusAbstractAdaptor

{

    Q_OBJECT

    Q_CLASSINFO("D-Bus Interface", "local.Interface2")

    Q_PROPERTY(QString prop1 READ prop1)

    Q_PROPERTY(QString prop2 READ prop2 WRITE setProp2 SCRIPTABLE true)

    Q_PROPERTY(QUrl nonDBusProperty READ nonDBusProperty)

public:

    Interface2(QObject *parent) : QDBusAbstractAdaptor(parent)

    { setAutoRelaySignals(true); }

    QString prop1() const

    { return QLatin1String("QString Interface2::prop1() const"); }

    QString prop2() const

    { return QLatin1String("QString Interface2::prop2() const"); }

    void setProp2(const QString &value)

    {

        slotSpy = "void Interface2::setProp2(const QString &)";

        valueSpy = value;

    }

    QUrl nonDBusProperty() const

    { return QUrl(); }

    void emitSignal(const QString &, const QVariant &)

    { emit signal(); }

public slots:

    void method()

    {

        slotSpy = "void Interface2::method()";

    }

    Q_SCRIPTABLE void scriptableMethod()

    {

        slotSpy = "void Interface2::scriptableMethod()";

    }

signals:

    void signal();

};

class Interface3: public QDBusAbstractAdaptor

{

    Q_OBJECT

    Q_CLASSINFO("D-Bus Interface", "local.Interface3")

    Q_PROPERTY(QString prop1 READ prop1)

    Q_PROPERTY(QString prop2 READ prop2 WRITE setProp2)

    Q_PROPERTY(QString interface3prop READ interface3prop)

public:

    Interface3(QObject *parent) : QDBusAbstractAdaptor(parent)

    { setAutoRelaySignals(true); }

    QString prop1() const

    { return QLatin1String("QString Interface3::prop1() const"); }

    QString prop2() const

    { return QLatin1String("QString Interface3::prop2() const"); }

    void setProp2(const QString &value)

    {

        slotSpy = "void Interface3::setProp2(const QString &)";

        valueSpy = value;

    }

    QString interface3prop() const

    { return QLatin1String("QString Interface3::interface3prop() const"); }

    void emitSignal(const QString &name, const QVariant &value)

    {

        if (name == "signalVoid")

            emit signalVoid();

        else if (name == "signalInt")

            emit signalInt(value.toInt());

        else if (name == "signalString")

            emit signalString(value.toString());

    }

public slots:

    void methodVoid() { slotSpy = "void Interface3::methodVoid()"; }

    void methodInt(int) { slotSpy = "void Interface3::methodInt(int)"; }

    void methodString(QString) { slotSpy = "void Interface3::methodString(QString)"; }

    int methodStringString(const QString &s, QString &out)

    {

        slotSpy = "int Interface3::methodStringString(const QString &, QString &)";

        out = s;

        return 42;

    }

signals:

    void signalVoid();

    void signalInt(int);

    void signalString(const QString &);

};

class Interface4: public QDBusAbstractAdaptor

{

    Q_OBJECT

    Q_CLASSINFO("D-Bus Interface", "local.Interface4")

    Q_PROPERTY(QString prop1 READ prop1)

    Q_PROPERTY(QString prop2 READ prop2 WRITE setProp2)

    Q_PROPERTY(QString interface4prop READ interface4prop)

public:

    Interface4(QObject *parent) : QDBusAbstractAdaptor(parent)

    { setAutoRelaySignals(true); }

    QString prop1() const

    { return QLatin1String("QString Interface4::prop1() const"); }

    QString prop2() const

    { return QLatin1String("QString Interface4::prop2() const"); }

    QString interface4prop() const

    { return QLatin1String("QString Interface4::interface4prop() const"); }

    void setProp2(const QString &value)

    {

        slotSpy = "void Interface4::setProp2(const QString &)";

        valueSpy = value;

    }

    void emitSignal(const QString &, const QVariant &value)

    {

        switch (value.type())

        {

        case QVariant::Invalid:

            emit signal();

            break;

        case QVariant::Int:

            emit signal(value.toInt());

            break;

        case QVariant::String:

            emit signal(value.toString());

            break;

        default:

            break;

        }

    }

public slots:

    void method() { slotSpy = "void Interface4::method()"; }

    void method(int) { slotSpy = "void Interface4::method(int)"; }

    void method(QString) { slotSpy = "void Interface4::method(QString)"; }

signals:

    void signal();

    void signal(int);

    void signal(const QString &);

};

class MyObject: public QObject

{

    Q_OBJECT

    Q_CLASSINFO("D-Bus Interface", "local.MyObject")

public:

    Interface1 *if1;

    Interface2 *if2;

    Interface3 *if3;

    Interface4 *if4;

    MyObject(int n = 4)

        : if1(0), if2(0), if3(0), if4(0)

    {

        switch (n)

        {

        case 4:

            if4 = new Interface4(this);

        case 3:

            if3 = new Interface3(this);

        case 2:

            if2 = new Interface2(this);

        case 1:

            if1 = new Interface1(this);

        }

    }

    void emitSignal(const QString &name, const QVariant &value)

    {

        if (name == "scriptableSignalVoid")

            emit scriptableSignalVoid();

        else if (name == "scriptableSignalInt")

            emit scriptableSignalInt(value.toInt());

        else if (name == "scriptableSignalString")

            emit scriptableSignalString(value.toString());

        else if (name == "nonScriptableSignalVoid")

            emit nonScriptableSignalVoid();

    }

signals:

    Q_SCRIPTABLE void scriptableSignalVoid();

    Q_SCRIPTABLE void scriptableSignalInt(int);

    Q_SCRIPTABLE void scriptableSignalString(QString);

    void nonScriptableSignalVoid();

};

class TypesInterface: public QDBusAbstractAdaptor

{

    Q_OBJECT

    Q_CLASSINFO("D-Bus Interface", "local.TypesInterface")

public:

    TypesInterface(QObject *parent)

        : QDBusAbstractAdaptor(parent)

    { }

    union

    {

        bool b;

        uchar uc;

        short s;

        ushort us;

        int i;

        uint ui;

        qlonglong ll;

        qulonglong ull;

        double d;

    } dataSpy;

    QVariant variantSpy;

    QString stringSpy;

    QVariantList listSpy;

    QStringList stringlistSpy;

    QByteArray bytearraySpy;

    QVariantMap mapSpy;

    StringStringMap ssmapSpy;

    LLDateTimeMap lldtmapSpy;

    MyStruct structSpy;

public slots:

    void methodBool(bool b)

    {

        slotSpy = "void TypesInterface::methodBool(bool)";

        dataSpy.b = b;

    }

    void methodUChar(uchar uc)

    {

        slotSpy = "void TypesInterface::methodUChar(uchar)";

        dataSpy.uc = uc;

    }

    void methodShort(short s)

    {

        slotSpy = "void TypesInterface::methodShort(short)";

        dataSpy.s = s;

    }

    void methodUShort(ushort us)

    {

        slotSpy = "void TypesInterface::methodUShort(ushort)";

        dataSpy.us = us;

    }

    void methodInt(int i)

    {

        slotSpy = "void TypesInterface::methodInt(int)";

        dataSpy.i = i;

    }

    void methodUInt(uint ui)

    {

        slotSpy = "void TypesInterface::methodUInt(uint)";

        dataSpy.ui = ui;

    }

    void methodLongLong(qlonglong ll)

    {

        slotSpy = "void TypesInterface::methodLongLong(qlonglong)";

        dataSpy.ll = ll;

    }

    void methodULongLong(qulonglong ull)

    {

        slotSpy = "void TypesInterface::methodULongLong(qulonglong)";

        dataSpy.ull = ull;

    }

    void methodDouble(double d)

    {

        slotSpy = "void TypesInterface::methodDouble(double)";

        dataSpy.d = d;

    }

    void methodString(const QString &s)

    {

        slotSpy = "void TypesInterface::methodString(const QString &)";

        stringSpy = s;

    }

    void methodObjectPath(const QDBusObjectPath &op)

    {

        slotSpy = "void TypesInterface::methodObjectPath(const QDBusObjectPath &)";

        stringSpy = op.path();

    }

    void methodSignature(const QDBusSignature &s)

    {

        slotSpy = "void TypesInterface::methodSignature(const QDBusSignature &)";

        stringSpy = s.signature();

    }

    void methodVariant(const QDBusVariant &v)

    {

        slotSpy = "void TypesInterface::methodVariant(const QDBusVariant &)";

        variantSpy = v.variant();

    }

    void methodList(const QVariantList &l)

    {

        slotSpy = "void TypesInterface::methodList(const QVariantList &)";

        listSpy = l;

    }

    void methodStringList(const QStringList &sl)

    {

        slotSpy = "void TypesInterface::methodStringList(const QStringList &)";

        stringlistSpy = sl;

    }

    void methodByteArray(const QByteArray &ba)

    {

        slotSpy = "void TypesInterface::methodByteArray(const QByteArray &)";

        bytearraySpy = ba;

    }

    void methodMap(const QVariantMap &m)

    {

        slotSpy = "void TypesInterface::methodMap(const QVariantMap &)";

        mapSpy = m;

    }

    void methodSSMap(const StringStringMap &ssmap)

    {

        slotSpy = "void TypesInterface::methodSSMap(const StringStringMap &)";

        ssmapSpy = ssmap;

    }

    void methodLLDateTimeMap(const LLDateTimeMap &lldtmap)

    {

        slotSpy = "void TypesInterface::methodLLDateTimeMap(const LLDateTimeMap &)";

        lldtmapSpy = lldtmap;

    }

    void methodStruct(const MyStruct &s)

    {

        slotSpy = "void TypesInterface::methodStruct(const MyStruct &)";

        structSpy = s;

    }

    bool retrieveBool()

    {

        return dataSpy.b;

    }

    uchar retrieveUChar()

    {

        return dataSpy.uc;

    }

    short retrieveShort()

    {

        return dataSpy.s;

    }

    ushort retrieveUShort()

    {

        return dataSpy.us;

    }

    int retrieveInt()

    {

        return dataSpy.i;

    }

    uint retrieveUInt()

    {

        return dataSpy.ui;

    }

    qlonglong retrieveLongLong()

    {

        return dataSpy.ll;

    }