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

**

** 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 "tst_qvaluespacesubscribershared.h"

#include <qvaluespacesubscriber.h>

#include <qvaluespacepublisher.h>

#include <qvaluespacemanager_p.h>

#include <QTest>

#include <QSet>

#include <QSignalSpy>

#include <QProcess>

#include <QFile>

#include <QThread>

#include <QTimer>

#include <math.h>

#include <QDebug>

#ifdef Q_OS_WIN

#define _WIN32_WINNT 0x0500

#include <windows.h>

#endif

#define ERROR_SETVALUE_NOT_SUPPORTED 1

#if defined(Q_OS_SYMBIAN)// || defined (Q_OS_LINUX)

    #define QTRY_COMPARE(a,e)                       \

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

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

            QTest::qWait(1);                        \

        }                                           \

        QCOMPARE(a, e)

    #define QTRY_VERIFY(a)                          \

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

            if (a) break;                           \

            QTest::qWait(1);                        \

        }                                           \

        QVERIFY(a)

#else

    #define QTRY_COMPARE(a,e)                       \

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

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

            QTest::qWait(100);                      \

        }                                           \

        QCOMPARE(a, e)

    #define QTRY_VERIFY(a)                       \

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

            if (a) break;                  \

            QTest::qWait(100);                      \

        }                                           \

        QVERIFY(a)

#endif

QTM_USE_NAMESPACE

class ChangeListener : public QObject

{

    Q_OBJECT

Q_SIGNALS:

    void baseChanged();

    void interestChanged(const QString&, bool);

};

Q_DECLARE_METATYPE(QValueSpaceSubscriber*)

Q_DECLARE_METATYPE(QAbstractValueSpaceLayer*)

Q_DECLARE_METATYPE(QVariant)

Q_DECLARE_METATYPE(QValueSpace::LayerOptions)

Q_DECLARE_METATYPE(QUuid)

void tst_QValueSpaceSubscriber::initTestCase()

{

    qRegisterMetaType<QVariant>("QVariant");

    qRegisterMetaType<QValueSpace::LayerOptions>("QValueSpace::LayerOptions");

#ifdef Q_OS_WIN

    HKEY key;

    long result = RegOpenKeyEx(HKEY_CURRENT_USER, L"Software\\Nokia",

                               0, KEY_ALL_ACCESS, &key);

    if (result == ERROR_SUCCESS) {

        result = RegDeleteKey(key, L"QtMobility\\volatileContext");

        result = RegDeleteKey(key, L"QtMobility\\nonVolatileContext");

        result = RegDeleteKey(key, L"QtMobility");

        RegCloseKey(key);

    }

#endif

#if defined(Q_OS_UNIX) && defined(QT_START_VALUESPACE)

    QFile::remove("/tmp/qt-0/valuespace_shmlayer");

#endif

#if defined(QT_START_VALUESPACE)

    QValueSpace::initValueSpaceServer();

#endif

    QList<QAbstractValueSpaceLayer *> layers = QValueSpaceManager::instance()->getLayers();

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

        QValueSpacePublisher *root = new QValueSpacePublisher(layers.at(i)->id(), "/");

        root->setValue("/home/user/bool", true);

        root->setValue("/home/user/int", 3);

        root->setValue("/home/user/QString", QString("testString"));

        QStringList stringList;

        stringList << QString("String 1") << QString("String 2");

        root->setValue("/home/user/QStringList", stringList);

        root->setValue("/home/user/qint64", qint64(64));

        root->setValue("/home/user/QByteArray", QByteArray("testByteArray"));

        root->setValue("/home/user/double", 4.56);

        root->setValue("/home/user/float", (float)4.56f);

        root->setValue("/home/user/QChar", QChar('c'));

        //so far not a lot of data types are supported

        //root->setValue("/home/user/QRect", QRect(0,0,5,6));

        root->setValue("/home/usercount", 1);

        root->setValue("/layer/name", layers.at(i)->name());

        root->setValue("/layer/id", layers.at(i)->id().toString());

        root->setValue("/layer/options", uint(layers.at(i)->layerOptions()));

        root->sync();

        roots.insert(layers.at(i), root);

        QValueSpacePublisher *busy = new QValueSpacePublisher(layers.at(i)->id(), "/usr");

        busy->setValue("alex/busy", true);

        busy->setValue("lorn/busy", false);

        busy->sync();

        busys.insert(layers.at(i), busy);

    }

}

void tst_QValueSpaceSubscriber::cleanupTestCase()

{

    foreach (QAbstractValueSpaceLayer *layer, roots.keys()) {

        QValueSpacePublisher *root = roots.take(layer);

        if (layer->layerOptions() & QValueSpace::PermanentLayer) {

            root->resetValue("/home/user/bool");

            root->resetValue("/home/user/int");

            root->resetValue("/home/user/QString");

            root->resetValue("/home/user/QStringList");

            root->resetValue("/home/user/qint64");

            root->resetValue("/home/user/QByteArray");

            root->resetValue("/home/user/double");

            root->resetValue("/home/user/float");

            root->resetValue("/home/user/QChar");

            root->resetValue("/home/user");

            root->resetValue("/home/usercount");

            root->resetValue("/home");

            root->resetValue("/layer/name");

            root->resetValue("/layer/id");

            root->resetValue("/layer/options");

            root->resetValue("/layer");

        }

        delete root;

    }

    foreach (QAbstractValueSpaceLayer *layer, busys.keys()) {

        QValueSpacePublisher *busy = busys.take(layer);

        if (layer->layerOptions() & QValueSpace::PermanentLayer) {

            busy->resetValue("alex/busy");

            busy->resetValue("alex");

            busy->resetValue("lorn/busy");

            busy->resetValue("lorn");

            busy->resetValue(QString());

        }

        delete busy;

    }

}

void tst_QValueSpaceSubscriber::dataVersatility_data()

{

    QTest::addColumn<QAbstractValueSpaceLayer *>("layer");

    QTest::addColumn< QVariant >("data");

    QTest::addColumn< QString >("typeString");

    QTest::addColumn< int >("typeIdent");

    QList<QAbstractValueSpaceLayer *> layers = QValueSpaceManager::instance()->getLayers();

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

        QAbstractValueSpaceLayer *layer = layers.at(i);

        //these types have custom loading/saving operator

        QTest::newRow("Int") << layer

            << QVariant((int)567) << "Int" << (int)QVariant::Int;

        QTest::newRow("Bool") << layer

            << QVariant((bool)true) << "Bool" << (int)QVariant::Bool;

        QTest::newRow("UInt") << layer

            << QVariant((unsigned int)4) << "UInt" << (int)QVariant::UInt;

        QTest::newRow("LongLong") << layer

            << QVariant((long long)5) << "LongLong" << (int)QVariant::LongLong;

        QTest::newRow("ULongLong") << layer

            << QVariant((unsigned long long)6) << "ULongLong" << (int)QVariant::ULongLong;

        QTest::newRow("Double") << layer

            << QVariant((double)4.5) << "Double" << (int)QVariant::Double;

        QTest::newRow("QChar") << layer

            << QVariant(QChar('@')) << "Char" << (int)QVariant::Char;

        QTest::newRow("QString") << layer

            << QVariant(QString("asd")) << "QString" << (int)QVariant::String;

        QTest::newRow("QByteArray") << layer

            << QVariant(QByteArray("bytearray")) << "QByteArray" << (int)QVariant::ByteArray;

        QTest::newRow("QStringList") << layer

            << QVariant(QStringList() << QString("String 1") << QString("String 2"))

            << "QStringList" << (int)QVariant::StringList;

        //other types not specifically covered by valuespace -> uses QVariant based serialization

        QTest::newRow("QRect") << layer

            << QVariant(QRect(4,5,6,7)) << "QRect" << (int)QVariant::Rect;

        QTest::newRow("QDateTime") << layer

            << QVariant(QDateTime::currentDateTime()) << "QDateTime" << (int)QVariant::DateTime;

    }

}

void tst_QValueSpaceSubscriber::dataVersatility()

{

    QFETCH(QAbstractValueSpaceLayer *, layer);

    QFETCH(QVariant, data);

    QFETCH(QString, typeString);

    QFETCH(int, typeIdent);

    QCOMPARE(data.type(), (QVariant::Type)typeIdent);

    QValueSpacePublisher publisher(layer->id(), "/usr/data");

    publisher.setValue(typeString, data);

    publisher.sync();

    QValueSpaceSubscriber subscriber(layer->id(), "/usr/data");

    QVariant v = subscriber.value(typeString);

    QCOMPARE(v.type(), (QVariant::Type)typeIdent);

    QCOMPARE(v, data);

    if (layer->layerOptions() & QValueSpace::PermanentLayer)

        publisher.resetValue(typeString);

}

void tst_QValueSpaceSubscriber::testConstructor_data()

{

    QTest::addColumn< QVariant >("testItem");

    QTest::addColumn< QVariant >("value");

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

    QTest::addColumn< QString >("path");

    QTest::addColumn< QString >("relItemPath");

    QTest::addColumn< int >("expectedValue");

    QStringList allPaths;

    allPaths << "bool" << "int" << "QString" << "QStringList" << "qint64" << "QByteArray"

             << "double" << "float" << "QChar";

    QStringList rootPaths;

    rootPaths << "home" << "usr" << "layer";

    QStringList homePaths;

    homePaths << "user" << "usercount";

    QVariant data;

    QValueSpaceSubscriber *subscriber;

    // Subscribers with / path.

    subscriber = new QValueSpaceSubscriber(QString(), this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(QString(), this)")

        << data

        << QVariant()

        << rootPaths

        << QString("/")

        << QString("home/user/int")

        << 3;

    subscriber = new QValueSpaceSubscriber(QString("/"), this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(QString(\"/\"), this)")

        << data

        << QVariant()

        << rootPaths

        << QString("/")

        << QString("home/user/int")

        << 3;

    subscriber = new QValueSpaceSubscriber("", this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(\"\", this)")

        << data

        << QVariant()

        << rootPaths

        << QString("/")

        << QString("home/user/int")

        << 3;

    subscriber = new QValueSpaceSubscriber("/", this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(\"/\", this)")

        << data

        << QVariant()

        << rootPaths

        << QString("/")

        << QString("home/user/int")

        << 3;

    subscriber = new QValueSpaceSubscriber(this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(this)")

        << data

        << QVariant()

        << rootPaths

        << QString("/")

        << QString("home/user/int")

        << 3;

    // Subscribers with /home path.

    subscriber = new QValueSpaceSubscriber(QString("/home"), this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(QString(\"/home\"), this)")

        << data

        << QVariant()

        << homePaths

        << QString("/home")

        << QString("user/int")

        << 3;

    // Subscribers with /home/user path.

    subscriber = new QValueSpaceSubscriber(QString("/home/user"), this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(QString(\"/home/user\"), this)")

        << data

        << QVariant()

        << allPaths

        << QString("/home/user")

        << QString("int")

        << 3;

    // Direct value subscriber with /home/user/int path.

    subscriber = new QValueSpaceSubscriber("/home/user/int", this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(\"/home/user/int\", this)")

        << data

        << QVariant(3)

        << QStringList()

        << QString("/home/user/int")

        << QString()

        << 3;

    // Subscriber with invalid path.

    subscriber = new QValueSpaceSubscriber(QString("/home/invalidPath"), this);

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber(QString(\"/home/invalidPath\"), this)")

        << data

        << QVariant()

        << QStringList()

        << QString("/home/invalidPath")

        << QString("user/int")

        << 100; //should fails -> returns default

    // setPath to /

    subscriber = new QValueSpaceSubscriber(this);

    subscriber->setPath("/");

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber::setPath(\"/\"")

        << data

        << QVariant()

        << rootPaths

        << QString("/")

        << QString("home/user/int")

        << 3;

    // setPath to /home

    subscriber = new QValueSpaceSubscriber(this);

    subscriber->setPath("/home");

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber::setPath(\"/home\")")

        << data

        << QVariant()

        << homePaths

        << QString("/home")

        << QString("user/int")

        << 3;

    // setPath to /home/user

    subscriber = new QValueSpaceSubscriber(this);

    subscriber->setPath("/home/user");

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber::setPath(\"/home/user\")")

        << data

        << QVariant()

        << allPaths

        << QString("/home/user")

        << QString("int")

        << 3;

    // setPath to &QValueSpaceSubscriber

    subscriber = new QValueSpaceSubscriber(this);

    {

        QValueSpaceSubscriber user("/home/user");

        subscriber->setPath(&user);

    }

    qVariantSetValue(data, subscriber);

    QTest::newRow("QValueSpaceSubscriber::setPath(&QValueSpaceSubscriber(\"/home/user\")")

        << data

        << QVariant()

        << allPaths

        << QString("/home/user")

        << QString("int")

        << 3;

}

void tst_QValueSpaceSubscriber::testConstructor()

{

    QFETCH(QVariant, testItem);

    QFETCH(QVariant, value);

    QFETCH(QStringList, subPaths);

    QFETCH(QString, path);

    QFETCH(QString, relItemPath);

    QFETCH(int, expectedValue);

    QValueSpaceSubscriber *subscriber = qvariant_cast<QValueSpaceSubscriber*>(testItem);

    QCOMPARE(subscriber->parent(), (QObject*)this);

    QCOMPARE(subscriber->value(), value);

    QVERIFY(subscriber->subPaths().toSet().contains(subPaths.toSet()));

    QCOMPARE(subscriber->path(), path);

    QCOMPARE(subscriber->value(relItemPath, 100).toInt(), expectedValue);

}

#define ADD(opt, invalid) do {\

    QTest::newRow(QString::number(opt).append(" const QString &").toLocal8Bit().constData()) \

        << (QValueSpace::UnspecifiedLayer | opt) << invalid; \

} while (false)

void tst_QValueSpaceSubscriber::testFilterConstructor_data()

{

    QTest::addColumn<QValueSpace::LayerOptions>("options");

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

    QList<QAbstractValueSpaceLayer *> layers = QValueSpaceManager::instance()->getLayers();

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

        QAbstractValueSpaceLayer *layer = layers.at(i);

        ADD(layer->layerOptions(), true);

    }

    ADD(QValueSpace::UnspecifiedLayer, true);

    ADD(QValueSpace::PermanentLayer, true);

    ADD(QValueSpace::TransientLayer, true);

    ADD(QValueSpace::PermanentLayer | QValueSpace::TransientLayer, false);

    ADD(QValueSpace::WritableLayer, true);

    ADD(QValueSpace::ReadOnlyLayer, true);

    ADD(QValueSpace::WritableLayer | QValueSpace::ReadOnlyLayer, false);

}

void tst_QValueSpaceSubscriber::testFilterConstructor()

{

    QFETCH(QValueSpace::LayerOptions, options);

    QFETCH(bool, connected);

    QValueSpaceSubscriber *subscriber;

    subscriber = new QValueSpaceSubscriber(options, QString("/layer"));

    if (!connected)

        QVERIFY(!subscriber->isConnected());

    if (subscriber->isConnected()) {

        QValueSpace::LayerOptions actualOptions =

            QValueSpace::LayerOptions(subscriber->value("options", 0).toUInt());

        QVERIFY(options == QValueSpace::UnspecifiedLayer || actualOptions & options);

    }

}

void tst_QValueSpaceSubscriber::testPathChanges()

{

    QValueSpaceSubscriber subscriber;

    QStringList rootPaths;

    rootPaths << "layer" << "usr" << "home";

    QStringList homePaths;

    homePaths << "user" << "usercount";

    QStringList homeUserPaths;

    homeUserPaths << "bool" << "int" << "QString" << "QStringList" << "qint64" << "QByteArray"

                  << "double" << "float" << "QChar";

    QCOMPARE(subscriber.path(), QLatin1String("/"));