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

**

** 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 Qt Mobility Components.

**

** $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 <qservicemanager.h>

#include <qservicecontext.h>

#include <qabstractsecuritysession.h>

#include <qserviceinterfacedescriptor_p.h>

#include "../../sampleserviceplugin/sampleserviceplugin.h"

#include "../qsfwtestutil.h"

#include <QtTest/QtTest>

#include <QtCore>

#include <QSettings>

#include <QFileInfo>

#include <QDir>

#include <QPair>

#define QTRY_COMPARE(a,e)                       \

    for (int _i = 0; _i < 5000; _i += 100) {    \

        if ((a) == (e)) break;                  \

        QTest::qWait(100);                      \

    }                                           \

    QCOMPARE(a, e)

#define QTRY_VERIFY(a)                       \

    for (int _i = 0; _i < 5000; _i += 100) {    \

        if (a) break;                  \

        QTest::qWait(100);                      \

    }                                           \

    QVERIFY(a)

#define PRINT_ERR(a) qPrintable(QString("error = %1").arg(a.error()))

typedef QList<QtMobility::QServiceInterfaceDescriptor> ServiceInterfaceDescriptorList;

Q_DECLARE_METATYPE(QtMobility::QServiceFilter)

Q_DECLARE_METATYPE(QtMobility::QServiceInterfaceDescriptor)

Q_DECLARE_METATYPE(ServiceInterfaceDescriptorList)

Q_DECLARE_METATYPE(QSet<QString>)

Q_DECLARE_METATYPE(QList<QByteArray>)

Q_DECLARE_METATYPE(QtMobility::QService::Scope)

QTM_BEGIN_NAMESPACE

typedef QHash<QtMobility::QServiceInterfaceDescriptor::Attribute, QVariant> DescriptorAttributes;

inline uint qHash(const QtMobility::QServiceInterfaceDescriptor &desc)

{

    return qHash(desc.serviceName()) + qHash(desc.interfaceName()) + desc.majorVersion() * 7 + desc.minorVersion() * 7;

}

QTM_END_NAMESPACE

QTM_USE_NAMESPACE

static DescriptorAttributes defaultDescriptorAttributes()

{

    DescriptorAttributes props;

    //props[QServiceInterfaceDescriptor::Capabilities] = QStringList();

    props[QServiceInterfaceDescriptor::Location] = "";

    props[QServiceInterfaceDescriptor::ServiceDescription] = "";

    props[QServiceInterfaceDescriptor::InterfaceDescription] = "";

    return props;

}

static const DescriptorAttributes DEFAULT_DESCRIPTOR_PROPERTIES = defaultDescriptorAttributes();

static QStringList validPluginFiles()

{

    // these are the plugins under tests/ which point to real service plugins

    // that can be used for testing (i.e. plugins that can be loaded, invoked)

    QStringList files;

    files << "plugins/tst_sfw_sampleserviceplugin" << "plugins/tst_sfw_sampleserviceplugin2";

    return files;

}

static const QStringList VALID_PLUGIN_FILES = validPluginFiles();

// Helper function for debugging. Useful e.g. for checking what is difference between

// two descriptors (in addition to attributes printed below, the \

// QServiceInterfaceDescriptor::== operator also compares

// attributes.

static void printDescriptor (QServiceInterfaceDescriptor &desc) {

    qDebug("***QServiceInterfaceDescriptor printed:");

    qDebug() << "***majorVersion:" << desc.majorVersion();

    qDebug() << "***minorVersion:" << desc.minorVersion();

    qDebug() << "***interfaceName:" << desc.interfaceName();

    qDebug() << "***serviceName:" << desc.serviceName();

    qDebug() << "***customAttributes:" << desc.customAttributes();

    qDebug() << "***isValid(): " << desc.isValid();

    qDebug() << "***scope (user:0, system:1): " << desc.scope();

}

class MySecuritySession : public QAbstractSecuritySession

{

public:

    MySecuritySession() {}

    virtual ~MySecuritySession() {}

    virtual bool isAllowed(const QStringList&) { return true; }

};

class MyServiceContext : public QServiceContext

{

public:

    MyServiceContext() {}

    ~MyServiceContext() {}

    virtual void notify(ContextType, const QVariant&) {}

};

class ServicesListener : public QObject

{

    Q_OBJECT

public slots:

    void serviceAdded(const QString &name , QService::Scope scope) {

        params.append(qMakePair(name, scope));

    }

    void serviceRemoved(const QString &name, QService::Scope scope) {

        params.append(qMakePair(name, scope));

    }

public:

    QList<QPair<QString, QService::Scope> > params;

};

class tst_QServiceManager: public QObject

{

    Q_OBJECT

private:

    QString xmlTestDataPath(const QString &xmlFileName)

    {

        // On Symbian applicationDirPath returns application's private directory

        return QCoreApplication::applicationDirPath() + "/plugins/xmldata/" + xmlFileName;

    }

    QByteArray createServiceXml(const QString &serviceName, const QByteArray &interfaceXml, const QString &path, const QString &description = QString()) const

    {

        QString xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";

        xml += "<service>\n";

        xml += "<name>" + serviceName + "</name>\n";

        xml += "<filepath>" + path + "</filepath>\n";

        xml += "<description>" + description + "</description>\n";

        xml += interfaceXml;

        xml += "</service>\n";

        return xml.toLatin1();

    }

    QByteArray createServiceXml(const QString &serviceName, const QList<QServiceInterfaceDescriptor> &descriptors) const

    {

        Q_ASSERT(descriptors.count() > 0);

        return createServiceXml(serviceName, createInterfaceXml(descriptors),

                descriptors[0].attribute(QServiceInterfaceDescriptor::Location).toString(),

                descriptors[0].attribute(QServiceInterfaceDescriptor::ServiceDescription).toString());

    }

    QByteArray createInterfaceXml(const QList<QServiceInterfaceDescriptor> &descriptors) const

    {

        QByteArray interfacesXml;

        foreach (const QServiceInterfaceDescriptor &desc, descriptors) {

            QString version = QString("%1.%2").arg(desc.majorVersion()).arg(desc.minorVersion());

            interfacesXml += createInterfaceXml(desc.interfaceName(), version,

                    desc.attribute(QServiceInterfaceDescriptor::InterfaceDescription).toString());

        }

        return interfacesXml;

    }

    QByteArray createInterfaceXml(const QString &name, const QString &version = "1.0", const QString &description = QString()) const

    {

       QString xml = "<interface>\n";

        xml += "<name>" + name + "</name>\n";

        xml += "<version>" + version + "</version>\n";

        xml += " <description>" + description + "</description>\n";

        xml += "</interface>\n";

        return xml.toLatin1();

    }

    QServiceInterfaceDescriptor createDescriptor(const QString &interfaceName, int major, int minor, const QString &serviceName, const DescriptorAttributes &attributes = DescriptorAttributes(), QService::Scope scope = QService::UserScope) const

    {

        QString version = QString("%1.%2").arg(major).arg(minor);

        QServiceInterfaceDescriptorPrivate *priv = new QServiceInterfaceDescriptorPrivate;

        priv->serviceName = serviceName;

        priv->interfaceName = interfaceName;

        priv->major = major;

        priv->minor = minor;

        priv->scope = scope;

        priv->attributes = attributes;

        foreach (QServiceInterfaceDescriptor::Attribute key, DEFAULT_DESCRIPTOR_PROPERTIES.keys()) {

            if (!priv->attributes.contains(key))

                priv->attributes[key] = DEFAULT_DESCRIPTOR_PROPERTIES[key];

        }

        QServiceInterfaceDescriptor desc;

        QServiceInterfaceDescriptorPrivate::setPrivate(&desc, priv);

        return desc;

    }

    void deleteTestDatabasesAndWaitUntilDone()

    {

        QSfwTestUtil::removeTempUserDb();

        QSfwTestUtil::removeTempSystemDb();

        QTRY_VERIFY(!QFile::exists(QSfwTestUtil::tempUserDbDir()));

        QTRY_VERIFY(!QFile::exists(QSfwTestUtil::tempSystemDbDir()));

    }

private slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void constructor();

    void constructor_scope();

    void constructor_scope_data();

    void findServices();

    void findServices_data();

    void findServices_scope();

    void findServices_scope_data();

    void findInterfaces_filter();

    void findInterfaces_filter_data();

    void findInterfaces_scope();

    void findInterfaces_scope_data();

    void loadInterface_string();

    void loadInterface_descriptor();

    void loadInterface_descriptor_data();

    void loadInterface_testLoadedObjectAttributes();

    void loadLocalTypedInterface();

    void addService();

    void addService_data();

    void addService_testInvalidServiceXml();

    void addService_testPluginLoading();

    void addService_testPluginLoading_data();

    void addService_testInstallService();

    void removeService();

    void setInterfaceDefault_strings();

    void setInterfaceDefault_strings_multipleInterfaces();

    void setInterfaceDefault_descriptor();

    void setInterfaceDefault_descriptor_data();

    void interfaceDefault();

    void serviceAdded();

    void serviceAdded_data();

    void serviceRemoved();

    void serviceRemoved_data();

};

void tst_QServiceManager::initTestCase()

{

    qRegisterMetaType<QService::Scope>("QService::Scope");

    QSfwTestUtil::setupTempUserDb();

    QSfwTestUtil::setupTempSystemDb();

#if defined(Q_OS_SYMBIAN)

    QSfwTestUtil::removeDatabases_symbian();

#endif

}

void tst_QServiceManager::init()

{

#if defined(Q_OS_SYMBIAN)

    // Wait a millisecond so that QServiceManagers are destroyed and release

    // the database file (otherwise QFile::remove will get a permission denied -->

    // in next case, the isEmpty() check fails).

    QTest::qWait(1);

#endif

    QSfwTestUtil::removeTempUserDb();

    QSfwTestUtil::removeTempSystemDb();

#if defined(Q_OS_SYMBIAN)

    QSfwTestUtil::removeDatabases_symbian();

#endif

    QSettings settings("com.nokia.qt.serviceframework.tests", "SampleServicePlugin");

    settings.setValue("installed", false);

}

void tst_QServiceManager::cleanupTestCase()

{

    QSfwTestUtil::removeTempUserDb();

    QSfwTestUtil::removeTempSystemDb();

#if defined(Q_OS_SYMBIAN)

    QSfwTestUtil::removeDatabases_symbian();

#endif

    //use QEventLopp::DeferredDeletion

    //QServiceManager::loadInterface makes use of deleteLater() when

    //cleaning up service objects and their respective QPluginLoader

    //we want to force the testcase to run the cleanup code

    QCoreApplication::processEvents(QEventLoop::AllEvents|QEventLoop::DeferredDeletion);

}

void tst_QServiceManager::constructor()

{

    QObject o;

    QServiceManager mgr(&o);

    QCOMPARE(mgr.scope(), QService::UserScope);

    QCOMPARE(mgr.parent(), &o);

}

void tst_QServiceManager::constructor_scope()

{

    QFETCH(QService::Scope, scope);

    QObject o;

    QServiceManager mgr(scope, &o);

    QCOMPARE(mgr.scope(), scope);

    QCOMPARE(mgr.parent(), &o);

}

void tst_QServiceManager::constructor_scope_data()

{

    QTest::addColumn<QService::Scope>("scope");

    QTest::newRow("user") << QService::UserScope;

    QTest::newRow("system") << QService::SystemScope;

}

void tst_QServiceManager::findServices()

{

    QFETCH(QList<QByteArray>, xmlBlocks);

    QFETCH(QStringList, interfaceNames);

    QFETCH(QSet<QString>, searchByInterfaceResult);

    QFETCH(QSet<QString>, searchAllResult);

    QServiceManager mgr;

    QServiceFilter wildcardFilter;

    // Check that nothing is found neither with default search or interface-search

    QVERIFY(mgr.findServices().isEmpty());

    foreach (const QString &interface, interfaceNames)

        QVERIFY(mgr.findServices(interface).isEmpty());

    QCOMPARE(mgr.findInterfaces(wildcardFilter).count(), 0);

    // Add all services from the xmlBlocks list

    foreach (const QByteArray &xml, xmlBlocks) {

        QBuffer buffer;

        buffer.setData(xml);

        QVERIFY2(mgr.addService(&buffer), PRINT_ERR(mgr));

    }

    // Check that all services are found with default search

    QCOMPARE(mgr.findServices().toSet(), searchAllResult);

    // Check that all services are found based on interface search

    foreach (const QString &interface, interfaceNames)

        QCOMPARE(mgr.findServices(interface).toSet(), searchByInterfaceResult);

    // Check that nothing is found with empty interface

    QCOMPARE(mgr.findServices("com.invalid.interface") , QStringList());

}

void tst_QServiceManager::findServices_data()

{

    QTest::addColumn< QList<QByteArray> >("xmlBlocks");

    QTest::addColumn<QStringList>("interfaceNames");

    QTest::addColumn< QSet<QString> >("searchByInterfaceResult");

    QTest::addColumn< QSet<QString> >("searchAllResult");

    QStringList interfaces;

    interfaces << "com.nokia.qt.TestInterfaceA";

    interfaces << "com.nokia.qt.TestInterfaceB";

    QByteArray interfacesXml;

    for (int i=0; i<interfaces.count(); i++)

        interfacesXml += "\n" + createInterfaceXml(interfaces[i]);

    QTest::newRow("one service")

            << (QList<QByteArray>() << createServiceXml("SomeTestService", interfacesXml, VALID_PLUGIN_FILES.first()))

            << interfaces

            << (QSet<QString>() << "SomeTestService")

            << (QSet<QString>() << "SomeTestService");

    QTest::newRow("multiple services with same interfaces")

            << (QList<QByteArray>() << createServiceXml("SomeTestService", interfacesXml, VALID_PLUGIN_FILES[0])

                                    << createServiceXml("SomeSimilarTestService", interfacesXml, VALID_PLUGIN_FILES[1]))

            << interfaces

            << (QSet<QString>() << "SomeTestService" << "SomeSimilarTestService")

            << (QSet<QString>() << "SomeTestService" << "SomeSimilarTestService");

    QStringList interfaces2;

    interfaces2 << "com.nokia.qt.TestInterfaceY";

    interfaces2 << "com.nokia.qt.TestInterfaceZ";

    QByteArray interfacesXml2;

    for (int i=0; i<interfaces2.count(); i++)

        interfacesXml2 += "\n" + createInterfaceXml(interfaces2[i]);

    QTest::newRow("multiple services with different interfaces")

            << (QList<QByteArray>() << createServiceXml("SomeTestService", interfacesXml, VALID_PLUGIN_FILES[0])

                                    << createServiceXml("TestServiceWithOtherInterfaces", interfacesXml2, VALID_PLUGIN_FILES[1]))

            << interfaces2

            << (QSet<QString>() << "TestServiceWithOtherInterfaces")

            << (QSet<QString>() << "SomeTestService" << "TestServiceWithOtherInterfaces");

}

void tst_QServiceManager::findServices_scope()

{

#if defined(Q_OS_SYMBIAN)

    QSKIP("There is no difference between user and system scope in symbian", SkipAll);

#endif

    QFETCH(QService::Scope, scope_add);

    QFETCH(QService::Scope, scope_find);

    QFETCH(bool, expectFound);

    QByteArray xml = createServiceXml("SomeTestService",

            createInterfaceXml("com.nokia.qt.TestInterface"), VALID_PLUGIN_FILES[0]);

    QBuffer buffer(&xml);

    QServiceManager mgrUser(QService::UserScope);

    QServiceManager mgrSystem(QService::SystemScope);

    QServiceManager &mgrAdd = scope_add == QService::UserScope ? mgrUser : mgrSystem;

    QServiceManager &mgrFind = scope_find == QService::UserScope ? mgrUser : mgrSystem;

    QVERIFY2(mgrAdd.addService(&buffer), PRINT_ERR(mgrAdd));

    QStringList result = mgrFind.findServices();

    QCOMPARE(!result.isEmpty(), expectFound);

}

void tst_QServiceManager::findServices_scope_data()

{

    QTest::addColumn<QService::Scope>("scope_add");

    QTest::addColumn<QService::Scope>("scope_find");

    QTest::addColumn<bool>("expectFound");

    QTest::newRow("user scope")

            << QService::UserScope << QService::UserScope << true;

    QTest::newRow("system scope")

            << QService::SystemScope << QService::SystemScope << true;

    QTest::newRow("user scope - add, system scope - find")

            << QService::UserScope << QService::SystemScope << false;

    QTest::newRow("system scope - add, user scope - find")

            << QService::SystemScope << QService::UserScope << true;

}

void tst_QServiceManager::findInterfaces_filter()

{

    QFETCH(QByteArray, xml);

    QFETCH(QServiceFilter, filter);

    QFETCH(QList<QServiceInterfaceDescriptor>, expectedInterfaces);

    QServiceManager mgr;

    QBuffer buffer(&xml);

    QVERIFY2(mgr.addService(&buffer), PRINT_ERR(mgr));

    QList<QServiceInterfaceDescriptor> result = mgr.findInterfaces(filter);

    QCOMPARE(result.toSet(), expectedInterfaces.toSet());

}

void tst_QServiceManager::findInterfaces_filter_data()

{

    QTest::addColumn<QByteArray>("xml");

    QTest::addColumn<QServiceFilter>("filter");

    QTest::addColumn<ServiceInterfaceDescriptorList>("expectedInterfaces");

    QString serviceName = "SomeTestService";

    DescriptorAttributes attributes;

    attributes[QServiceInterfaceDescriptor::Location] = VALID_PLUGIN_FILES.first();

    QList<QServiceInterfaceDescriptor> descriptors;

    descriptors << createDescriptor("com.nokia.qt.TestInterfaceA", 1, 0, serviceName, attributes);

    descriptors << createDescriptor("com.nokia.qt.TestInterfaceB", 1, 0, serviceName, attributes);

    descriptors << createDescriptor("com.nokia.qt.TestInterfaceB", 2, 0, serviceName, attributes);

    descriptors << createDescriptor("com.nokia.qt.TestInterfaceB", 2, 3, serviceName, attributes);

    QByteArray serviceXml = createServiceXml(serviceName, descriptors);

    QServiceFilter filter;

    QTest::newRow("empty/wildcard filter")

            << serviceXml

            << QServiceFilter()

            << descriptors;

    filter = QServiceFilter();

    filter.setInterface("com.nokia.qt.TestInterfaceA");

    QTest::newRow("by interface name (A)")

            << serviceXml

            << filter

            << descriptors.mid(0, 1);

    filter = QServiceFilter();

    filter.setInterface("com.nokia.qt.TestInterfaceB");