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

**

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

#include "qtcontacts.h"

#include "qcontactchangeset.h"

#include "qcontactmanagerdataholder.h"

QTM_USE_NAMESPACE

// Eventually these will make it into qtestcase.h

// but we might need to tweak the timeout values here.

#ifndef QTRY_COMPARE

#define QTRY_COMPARE(__expr, __expected) \

    do { \

        const int __step = 50; \

        const int __timeout = 5000; \

        if ((__expr) != (__expected)) { \

            QTest::qWait(0); \

        } \

        for (int __i = 0; __i < __timeout && ((__expr) != (__expected)); __i+=__step) { \

            QTest::qWait(__step); \

        } \

        QCOMPARE(__expr, __expected); \

    } while(0)

#endif

#ifndef QTRY_VERIFY

#define QTRY_VERIFY(__expr) \

        do { \

        const int __step = 50; \

        const int __timeout = 5000; \

        if (!(__expr)) { \

            QTest::qWait(0); \

        } \

        for (int __i = 0; __i < __timeout && !(__expr); __i+=__step) { \

            QTest::qWait(__step); \

        } \

        QVERIFY(__expr); \

    } while(0)

#endif

#define QTRY_WAIT(code, __expr) \

        do { \

        const int __step = 50; \

        const int __timeout = 5000; \

        if (!(__expr)) { \

            QTest::qWait(0); \

        } \

        for (int __i = 0; __i < __timeout && !(__expr); __i+=__step) { \

            do { code } while(0); \

            QTest::qWait(__step); \

        } \

    } while(0)

#define QCONTACTMANAGER_REMOVE_VERSIONS_FROM_URI(params)  params.remove(QString::fromAscii(QTCONTACTS_VERSION_NAME)); \

                                                          params.remove(QString::fromAscii(QTCONTACTS_IMPLEMENTATION_VERSION_NAME))

//TESTED_CLASS=

//TESTED_FILES=

// to get QFETCH to work with the template expression...

typedef QMap<QString,QString> tst_QContactManager_QStringMap;

Q_DECLARE_METATYPE(tst_QContactManager_QStringMap)

Q_DECLARE_METATYPE(QList<QContactLocalId>)

/* A class that no backend can support */

class UnsupportedMetatype {

    int foo;

};

Q_DECLARE_METATYPE(UnsupportedMetatype)

Q_DECLARE_METATYPE(QContact)

Q_DECLARE_METATYPE(QContactManager::Error)

class tst_QContactManager : public QObject

{

Q_OBJECT

public:

    tst_QContactManager();

    virtual ~tst_QContactManager();

private:

    void dumpContactDifferences(const QContact& a, const QContact& b);

    void dumpContact(const QContact &c);

    void dumpContacts(QContactManager *cm);

    bool isSuperset(const QContact& ca, const QContact& cb);

    QList<QContactDetail> removeAllDefaultDetails(const QList<QContactDetail>& details);

    void addManagers(); // add standard managers to the data

    QContact createContact(QContactDetailDefinition nameDef, QString firstName, QString lastName, QString phoneNumber);

    void saveContactName(QContact *contact, QContactDetailDefinition nameDef, QContactName *contactName, const QString &name) const;

    QScopedPointer<QContactManagerDataHolder> managerDataHolder;

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void doDump();

    void doDump_data() {addManagers();}

    void doDumpSchema();

    void doDumpSchema_data() {addManagers();}

    /* Special test with special data */

    void uriParsing();

    void nameSynthesis();

    void compatibleContact();

    /* Tests that are run on all managers */

    void metadata();

    void nullIdOperations();

    void add();

    void update();

    void remove();

    void batch();

    void signalEmission();

    void detailDefinitions();

    void displayName();

    void actionPreferences();

    void selfContactId();

    void detailOrders();

    void relationships();

    void contactType();

    /* Tests that take no data */

    void contactValidation();

    void errorStayingPut();

    void ctors();

    void invalidManager();

    void memoryManager();

    void changeSet();

    void fetchHint();

    /* Special test with special data */

    void uriParsing_data();

    void nameSynthesis_data();

    void compatibleContact_data();

    /* Tests that are run on all managers */

    void metadata_data() {addManagers();}

    void nullIdOperations_data() {addManagers();}

    void add_data() {addManagers();}

    void update_data() {addManagers();}

    void remove_data() {addManagers();}

    void batch_data() {addManagers();}

    void signalEmission_data() {addManagers();}

    void detailDefinitions_data() {addManagers();}

    void displayName_data() {addManagers();}

    void actionPreferences_data() {addManagers();}

    void selfContactId_data() {addManagers();}

    void detailOrders_data() {addManagers();}

    void relationships_data() {addManagers();}

    void contactType_data() {addManagers();}

};

tst_QContactManager::tst_QContactManager()

{

}

tst_QContactManager::~tst_QContactManager()

{

}

void tst_QContactManager::initTestCase()

{

    managerDataHolder.reset(new QContactManagerDataHolder());

    /* Make sure these other test plugins are NOT loaded by default */

    // These are now removed from the list of managers in addManagers()

    //QVERIFY(!QContactManager::availableManagers().contains("testdummy"));

    //QVERIFY(!QContactManager::availableManagers().contains("teststaticdummy"));

    //QVERIFY(!QContactManager::availableManagers().contains("maliciousplugin"));

}

void tst_QContactManager::cleanupTestCase()

{

    managerDataHolder.reset(0);

}

void tst_QContactManager::dumpContactDifferences(const QContact& ca, const QContact& cb)

{

    // Try to narrow down the differences

    QContact a(ca);

    QContact b(cb);

    QContactName n1 = a.detail(QContactName::DefinitionName);

    QContactName n2 = b.detail(QContactName::DefinitionName);

    // Check the name components in more detail

    QCOMPARE(n1.firstName(), n2.firstName());

    QCOMPARE(n1.middleName(), n2.middleName());

    QCOMPARE(n1.lastName(), n2.lastName());

    QCOMPARE(n1.prefix(), n2.prefix());

    QCOMPARE(n1.suffix(), n2.suffix());

    QCOMPARE(n1.customLabel(), n2.customLabel());

    // Check the display label

    QCOMPARE(a.displayLabel(), b.displayLabel());

    // Now look at the rest

    QList<QContactDetail> aDetails = a.details();

    QList<QContactDetail> bDetails = b.details();

    // They can be in any order, so loop

    // First remove any matches

    foreach(QContactDetail d, aDetails) {

        foreach(QContactDetail d2, bDetails) {

            if(d == d2) {

                a.removeDetail(&d);

                b.removeDetail(&d2);

                break;

            }

        }

    }

    // Now dump the extra details that were unmatched in A (note that DisplayLabel and Type are always present).

    aDetails = a.details();

    bDetails = b.details();

    foreach(QContactDetail d, aDetails) {

        if (d.definitionName() != QContactDisplayLabel::DefinitionName && d.definitionName() != QContactType::DefinitionName)

            qDebug() << "A contact had extra detail:" << d.definitionName() << d.variantValues();

    }

    // and same for B

    foreach(QContactDetail d, bDetails) {

        if (d.definitionName() != QContactDisplayLabel::DefinitionName && d.definitionName() != QContactType::DefinitionName)

            qDebug() << "B contact had extra detail:" << d.definitionName() << d.variantValues();

    }

    // now test specifically the display label and the type

    if (a.displayLabel() != b.displayLabel()) {

        qDebug() << "A contact display label =" << a.displayLabel();

        qDebug() << "B contact display label =" << b.displayLabel();

    }

    if (a.type() != b.type()) {

        qDebug() << "A contact type =" << a.type();

        qDebug() << "B contact type =" << b.type();

    }

}

bool tst_QContactManager::isSuperset(const QContact& ca, const QContact& cb)

{

    // returns true if contact ca is a superset of contact cb

    // we use this test instead of equality because dynamic information

    // such as presence/location, and synthesised information such as

    // display label and (possibly) type, may differ between a contact

    // in memory and the contact in the managed store.

    QContact a(ca);

    QContact b(cb);

    QList<QContactDetail> aDetails = a.details();

    QList<QContactDetail> bDetails = b.details();

    // They can be in any order, so loop

    // First remove any matches

    foreach(QContactDetail d, aDetails) {

        foreach(QContactDetail d2, bDetails) {

            if(d == d2) {

                a.removeDetail(&d);

                b.removeDetail(&d2);

                break;

            }

        }

    }

    // Second remove any superset matches (eg, backend adds a field)

    aDetails = a.details();

    bDetails = b.details();

    foreach (QContactDetail d, aDetails) {

        foreach (QContactDetail d2, bDetails) {

            if (d.definitionName() == d2.definitionName()) {

                bool canRemove = true;

                QMap<QString, QVariant> d2map = d2.variantValues();

                foreach (QString key, d2map.keys()) {

                    if (d.value(key) != d2.value(key)) {

                        // d can have _more_ keys than d2,

                        // but not _less_; and it cannot

                        // change the value.

                        canRemove = false;

                    }

                }

                if (canRemove) {

                    // if we get to here, we can remove the details.

                    a.removeDetail(&d);

                    b.removeDetail(&d2);

                    break;

                }

            }

        }

    }

    // check for contact type updates

    if (!a.type().isEmpty())

        if (!b.type().isEmpty())

            if (a.type() != b.type())

                return false; // nonempty type is different.

    // Now check to see if b has any details remaining; if so, a is not a superset.

    // Note that the DisplayLabel and Type can never be removed.

    if (b.details().size() > 2

            || (b.details().size() == 2 && (b.details().value(0).definitionName() != QContactDisplayLabel::DefinitionName

                                            || b.details().value(1).definitionName() != QContactType::DefinitionName)))

        return false;

    return true;

}

void tst_QContactManager::dumpContact(const QContact& contact)

{

    QContactManager m;

    qDebug() << "Contact: " << contact.id().localId() << "(" << m.synthesizedContactDisplayLabel(contact) << ")";

    QList<QContactDetail> details = contact.details();

    foreach(QContactDetail d, details) {

        qDebug() << "  " << d.definitionName() << ":";

        qDebug() << "    Vals:" << d.variantValues();

    }

}

void tst_QContactManager::dumpContacts(QContactManager *cm)

{

    QList<QContactLocalId> ids = cm->contactIds();

    qDebug() << "There are" << ids.count() << "contacts in" << cm->managerUri();

    foreach(QContactLocalId id, ids) {

        QContact c = cm->contact(id);

        dumpContact(c);

    }

}

void tst_QContactManager::uriParsing_data()

{

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

    QTest::addColumn<bool>("good"); // is this a good uri or not

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

    QTest::addColumn<QMap<QString, QString> >("parameters");

    QMap<QString, QString> inparameters;

    inparameters.insert("foo", "bar");

    inparameters.insert("bazflag", QString());

    inparameters.insert("bar", "glob");

    QMap<QString, QString> inparameters2;

    inparameters2.insert("this has spaces", QString());

    inparameters2.insert("and& an", " &");

    inparameters2.insert("and an ", "=quals");

    QTest::newRow("built") << QContactManager::buildUri("manager", inparameters) << true << "manager" << inparameters;

    QTest::newRow("built with escaped parameters") << QContactManager::buildUri("manager", inparameters2) << true << "manager" << inparameters2;

    QTest::newRow("no scheme") << "this should not split" << false << QString() << tst_QContactManager_QStringMap();

    QTest::newRow("wrong scheme") << "invalidscheme:foo bar" << false << QString() << tst_QContactManager_QStringMap();

    QTest::newRow("right scheme, no colon") << "qtcontacts" << false << QString() << tst_QContactManager_QStringMap();

    QTest::newRow("no manager, colon, no params") << "qtcontacts::" << false  << "manager" << tst_QContactManager_QStringMap();

    QTest::newRow("yes manager, no colon, no params") << "qtcontacts:manager" << true << "manager" << tst_QContactManager_QStringMap();

    QTest::newRow("yes manager, yes colon, no params") << "qtcontacts:manager:" << true << "manager"<< tst_QContactManager_QStringMap();

    QTest::newRow("yes params") << "qtcontacts:manager:foo=bar&bazflag=&bar=glob" << true << "manager" << inparameters;

    QTest::newRow("yes params but misformed") << "qtcontacts:manager:foo=bar&=gloo&bar=glob" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 2") << "qtcontacts:manager:=&=gloo&bar=glob" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 3") << "qtcontacts:manager:==" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 4") << "qtcontacts:manager:&&" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 5") << "qtcontacts:manager:&goo=bar" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 6") << "qtcontacts:manager:goo&bar" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 7") << "qtcontacts:manager:goo&bar&gob" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 8") << "qtcontacts:manager:==&&==&goo=bar" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 9") << "qtcontacts:manager:foo=bar=baz" << false << "manager" << inparameters;

    QTest::newRow("yes params but misformed 10") << "qtcontacts:manager:foo=bar=baz=glob" << false << "manager" << inparameters;

    QTest::newRow("no manager but yes params") << "qtcontacts::foo=bar&bazflag=&bar=glob" << false << QString() << inparameters;

    QTest::newRow("no manager or params") << "qtcontacts::" << false << QString() << inparameters;

    QTest::newRow("no manager or params or colon") << "qtcontacts:" << false << QString() << inparameters;

}

void tst_QContactManager::addManagers()

{

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

    QStringList managers = QContactManager::availableManagers();

    /* Known one that will not pass */

    managers.removeAll("invalid");

    managers.removeAll("testdummy");

    managers.removeAll("teststaticdummy");

    managers.removeAll("maliciousplugin");

    foreach(QString mgr, managers) {

        QMap<QString, QString> params;

        QTest::newRow(QString("mgr='%1'").arg(mgr).toLatin1().constData()) << QContactManager::buildUri(mgr, params);

        if (mgr == "memory") {

            params.insert("id", "tst_QContactManager");

            QTest::newRow(QString("mgr='%1', params").arg(mgr).toLatin1().constData()) << QContactManager::buildUri(mgr, params);

        }

    }

}

/*

 * Helper method for creating a QContact instance with name and phone number

 * details. Name is generated according to the detail definition assuming that

 * either first and last name or custom label is supported.

 */

QContact tst_QContactManager::createContact(

    QContactDetailDefinition nameDef,

    QString firstName,

    QString lastName,

    QString phoneNumber)

{

    QContact contact;

    if(!firstName.isEmpty() || !lastName.isEmpty()) {

        QContactName n;

        if(nameDef.fields().contains(QContactName::FieldFirstName)

            && nameDef.fields().contains(QContactName::FieldFirstName)) {

            n.setFirstName(firstName);

            n.setLastName(lastName);

        } else if(nameDef.fields().contains(QContactName::FieldCustomLabel)) {

            n.setCustomLabel(firstName + " " + lastName);

        } else {

            // assume that either first and last name or custom label is supported

            QTest::qWarn("Neither custom label nor first name/last name supported!");

            return QContact();

        }

        contact.saveDetail(&n);

    }

    if (!phoneNumber.isEmpty()) {

        QContactPhoneNumber ph;

        ph.setNumber(phoneNumber);

        contact.saveDetail(&ph);

    }

    return contact;

}

void tst_QContactManager::saveContactName(QContact *contact, QContactDetailDefinition nameDef, QContactName *contactName, const QString &name) const

{

    // check which name fields are supported in the following order:

    // 1. custom label, 2. first name, 3. last name

    if(nameDef.fields().contains(QContactName::FieldCustomLabel)) {

        contactName->setCustomLabel(name);

    } else if(nameDef.fields().contains(QContactName::FieldFirstName)) {

        contactName->setFirstName(name);

    } else if(nameDef.fields().contains(QContactName::FieldLastName)) {

        contactName->setLastName(name);

    } else {

        // Assume that at least one of the above name fields is supported by the backend

        QVERIFY(false);

    }

    contact->saveDetail(contactName);

}

void tst_QContactManager::metadata()

{

    // ensure that the backend is publishing its metadata (name / parameters / uri) correctly

    QFETCH(QString, uri);

    QScopedPointer<QContactManager> cm(new QContactManager("memory"));

    QVERIFY(QContactManager::buildUri(cm->managerName(), cm->managerParameters()) == cm->managerUri());

}

void tst_QContactManager::nullIdOperations()

{

    QFETCH(QString, uri);

    QScopedPointer<QContactManager> cm(new QContactManager("memory"));

    QVERIFY(!cm->removeContact(QContactLocalId()));

    QVERIFY(cm->error() == QContactManager::DoesNotExistError);

    QContact c = cm->contact(QContactLocalId());

    QVERIFY(c.id() == QContactId());

    QVERIFY(c.isEmpty());

    QVERIFY(cm->error() == QContactManager::DoesNotExistError);

}

void tst_QContactManager::uriParsing()

{

    QFETCH(QString, uri);

    QFETCH(bool, good);

    QFETCH(QString, manager);

    QFETCH(tst_QContactManager_QStringMap, parameters);

    QString outmanager;

    QMap<QString, QString> outparameters;

    if (good) {

        /* Good split */

        /* Test splitting */

        QVERIFY(QContactManager::parseUri(uri, 0, 0)); // no out parms

        // 1 out param

        QVERIFY(QContactManager::parseUri(uri, &outmanager, 0));