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

**

** Copyright (C) 2009 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 <QCoreApplication>

#include "qtcontacts.h"

#include "qcontactmanagerdataholder.h" //QContactManagerDataHolder

QTM_USE_NAMESPACE

class tst_QContactAsync : public QObject

{

    Q_OBJECT

public:

    tst_QContactAsync();

    virtual ~tst_QContactAsync();

public slots:

    void init();

    void cleanup();

private:

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

private slots:

    void testDestructor();

    void testDestructor_data() { addManagers(); }

    void contactFetch();

    void contactFetch_data() { addManagers(); }

    void contactIdFetch();

    void contactIdFetch_data() { addManagers(); }

    void contactRemove();

    void contactRemove_data() { addManagers(); }

    void contactSave();

    void contactSave_data() { addManagers(); }

    void definitionFetch();

    void definitionFetch_data() { addManagers(); }

    void definitionRemove();

    void definitionRemove_data() { addManagers(); }

    void definitionSave();

    void definitionSave_data() { addManagers(); }

    void relationshipFetch();

    void relationshipFetch_data() { addManagers(); }

    void relationshipRemove();

    void relationshipRemove_data() { addManagers(); }

    void relationshipSave();

    void relationshipSave_data() { addManagers(); }

    void maliciousManager(); // uses it's own custom data (manager)

    void threadDelivery();

    void progressReceived(QContactFetchRequest* request, bool appendOnly);

    void threadDelivery_data() { addManagers(); }

private:

    bool containsIgnoringTimestamps(const QList<QContact>& list, const QContact& c);

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

    bool prepareModel(const QString &uri, QContactManager *&cm);

    bool prepareModel(const QString &uri, QContactManager *&cm, QList<QContact> &contacts, QList<QContactRelationship> &relationships);

    Qt::HANDLE m_mainThreadId;

    Qt::HANDLE m_progressSlotThreadId;

    QContactManagerDataHolder managerDataHolder;

};

typedef QList<QContactLocalId> QContactLocalIdList;

Q_DECLARE_METATYPE(QContactLocalIdList);

tst_QContactAsync::tst_QContactAsync()

{

    // ensure we can load all of the plugins we need to.

    QString path = QApplication::applicationDirPath() + "/dummyplugin/plugins";

    QApplication::addLibraryPath(path);

    qRegisterMetaType<QContactLocalIdList>("QList<QContactLocalId>");

}

tst_QContactAsync::~tst_QContactAsync()

{

    QString path = QApplication::applicationDirPath() + "/dummyplugin/plugins";

    QApplication::removeLibraryPath(path);

}

void tst_QContactAsync::init()

{

}

void tst_QContactAsync::cleanup()

{

}

bool tst_QContactAsync::containsIgnoringTimestamps(const QList<QContact>& list, const QContact& c)

{

    QList<QContact> cl = list;

    QContact a(c);

    for (int i = 0; i < cl.size(); i++) {

        QContact b(cl.at(i));

        if (compareIgnoringTimestamps(a, b))

            return true;

    }

    return false;

}

bool tst_QContactAsync::compareIgnoringTimestamps(const QContact& ca, const QContact& cb)

{

    // Compares two contacts, ignoring any timestamp details

    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, and any timestamps

    foreach (QContactDetail d, aDetails) {

        foreach (QContactDetail d2, bDetails) {

            if (d == d2) {

                a.removeDetail(&d);

                b.removeDetail(&d2);

                break;

            }

            if (d.definitionName() == QContactTimestamp::DefinitionName) {

                a.removeDetail(&d);

            }

            if (d2.definitionName() == QContactTimestamp::DefinitionName) {

                b.removeDetail(&d2);

            }

        }

    }

    if (a == b)

        return true;

    return false;

}

void tst_QContactAsync::testDestructor()

{

    QFETCH(QString, uri);

    QContactManager* cm(0);

    QVERIFY(prepareModel(uri, cm));

    QContactFetchRequest* req = new QContactFetchRequest;

    req->setManager(cm);

    QContactManager* cm2(0);

    QVERIFY(prepareModel(uri, cm2));

    QContactFetchRequest* req2 = new QContactFetchRequest;

    req2->setManager(cm2);

    // first, delete manager then request

    delete cm;

    delete req;

    // second, delete request then manager

    delete req2;

    delete cm2;

}

void tst_QContactAsync::contactFetch()

{

    QFETCH(QString, uri);

    QContactManager* cm(0);

    QVERIFY(prepareModel(uri, cm));

    QContactFetchRequest cfr;

    QVERIFY(cfr.type() == QContactAbstractRequest::ContactFetchRequest);

    // initial state - not started, no manager.

    QVERIFY(!cfr.isActive());

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());

    QVERIFY(!cfr.cancel());

    QVERIFY(!cfr.waitForFinished());

    QVERIFY(!cfr.waitForProgress());

    // "all contacts" retrieval

    QContactFilter fil;

    cfr.setManager(cm);

    QCOMPARE(cfr.manager(), cm);

    QVERIFY(!cfr.isActive());

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.cancel());

    QVERIFY(!cfr.waitForFinished());

    QVERIFY(!cfr.waitForProgress());

    qRegisterMetaType<QContactFetchRequest*>("QContactFetchRequest*");

    QSignalSpy spy(&cfr, SIGNAL(progress(QContactFetchRequest*, bool)));

    cfr.setFilter(fil);

    QCOMPARE(cfr.filter(), fil);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    int expectedCount = 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

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

    QList<QContact> contacts = cfr.contacts();

    QCOMPARE(contactIds.size(), contacts.size());

    for (int i = 0; i < contactIds.size(); i++) {

        QContact curr = cm->contact(contactIds.at(i));

        QVERIFY(contacts.at(i) == curr);

    }

    // asynchronous detail filtering

    QContactDetailFilter dfil;

    dfil.setDetailDefinitionName(QContactUrl::DefinitionName, QContactUrl::FieldUrl);

    cfr.setFilter(dfil);

    QVERIFY(cfr.filter() == dfil);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    contactIds = cm->contacts(dfil);

    contacts = cfr.contacts();

    QCOMPARE(contactIds.size(), contacts.size());

    for (int i = 0; i < contactIds.size(); i++) {

        QContact curr = cm->contact(contactIds.at(i));

        QVERIFY(contacts.at(i) == curr);

    }

    // sort order

    QContactSortOrder sortOrder;

    sortOrder.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);

    QList<QContactSortOrder> sorting;

    sorting.append(sortOrder);

    cfr.setFilter(fil);

    cfr.setSorting(sorting);

    QCOMPARE(cfr.sorting(), sorting);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    contactIds = cm->contacts(sorting);

    contacts = cfr.contacts();

    QCOMPARE(contactIds.size(), contacts.size());

    for (int i = 0; i < contactIds.size(); i++) {

        QContact curr = cm->contact(contactIds.at(i));

        QVERIFY(contacts.at(i) == curr);

    }

    // restrictions

    sorting.clear();

    cfr.setFilter(fil);

    cfr.setSorting(sorting);

    cfr.setDefinitionRestrictions(QStringList(QContactName::DefinitionName));

    QCOMPARE(cfr.definitionRestrictions(), QStringList(QContactName::DefinitionName));

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    contactIds = cm->contacts(sorting);

    contacts = cfr.contacts();

    QCOMPARE(contactIds.size(), contacts.size());

    for (int i = 0; i < contactIds.size(); i++) {

        // create a contact from the restricted data only (id + display label)

        QContact currFull = cm->contact(contactIds.at(i));

        QContact currRestricted;

        currRestricted.setId(currFull.id());

        QList<QContactName> names = currFull.details<QContactName>();

        foreach (const QContactName& name, names) {

            QContactName fullName = name;

            if (!fullName.isEmpty()) {

                currRestricted.saveDetail(&fullName);

            }

        }

        // now find the contact in the retrieved list which our restricted contact mimics

        QContact retrievedRestricted;

        bool found = false;

        foreach (const QContact& retrieved, contacts) {

            if (retrieved.id() == currRestricted.id()) {

                retrievedRestricted = retrieved;

                found = true;

            }

        }

        QVERIFY(found); // must exist or fail.

        // ensure that the contact is the same (except synth fields)

        QList<QContactDetail> fdets = retrievedRestricted.details();

        QList<QContactDetail> rdets = currRestricted.details();

        foreach (const QContactDetail& det, fdets) {

            // ignore backend synthesised details

            // again, this requires a "default contact details" function to work properly.

            if (det.definitionName() == QContactDisplayLabel::DefinitionName

                || det.definitionName() == QContactTimestamp::DefinitionName) {

                continue;

            }

            // everything else must exist in both.

            if(!rdets.contains(det)) {

                qWarning("A detail exists in retrieved contact which doesn't exist in restricted contact!  This could be due to backend synthesization, or represent a bug!  (Definition name: %s)", det.definitionName().toAscii().constData());

            }

        }

    }

    // cancelling

    sorting.clear();

    cfr.setFilter(fil);

    cfr.setSorting(sorting);

    cfr.setDefinitionRestrictions(QStringList());

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(cfr.cancel());

    QVERIFY(cfr.status() == QContactAbstractRequest::Cancelling);

    QVERIFY(cfr.isActive());    // still cancelling

    QVERIFY(!cfr.isFinished()); // not finished cancelling

    QVERIFY(!cfr.start());      // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 3;

    QCOMPARE(spy.count(), expectedCount); // active + cancelling + cancelled progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Cancelled);

    // restart, and wait for progress after cancel.

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(cfr.cancel());

    QVERIFY(cfr.status() == QContactAbstractRequest::Cancelling);

    QVERIFY(cfr.isActive());    // still cancelling

    QVERIFY(!cfr.isFinished()); // not finished cancelling

    QVERIFY(!cfr.start());      // already started.

    QVERIFY(cfr.waitForProgress());

    expectedCount += 3;

    QCOMPARE(spy.count(), expectedCount); // active + cancelling + cancelled progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Cancelled);

    delete cm;

}

void tst_QContactAsync::contactIdFetch()

{

    QFETCH(QString, uri);

    QContactManager* cm(0);

    QVERIFY(prepareModel(uri, cm));

    QContactLocalIdFetchRequest cfr;

    QVERIFY(cfr.type() == QContactAbstractRequest::ContactLocalIdFetchRequest);

    // initial state - not started, no manager.

    QVERIFY(!cfr.isActive());

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());

    QVERIFY(!cfr.cancel());

    QVERIFY(!cfr.waitForFinished());

    QVERIFY(!cfr.waitForProgress());

    // "all contacts" retrieval

    QContactFilter fil;

    cfr.setManager(cm);

    QCOMPARE(cfr.manager(), cm);

    QVERIFY(!cfr.isActive());

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.cancel());

    QVERIFY(!cfr.waitForFinished());

    QVERIFY(!cfr.waitForProgress());

    qRegisterMetaType<QContactLocalIdFetchRequest*>("QContactLocalIdFetchRequest*");

    QSignalSpy spy(&cfr, SIGNAL(progress(QContactLocalIdFetchRequest*, bool)));

    cfr.setFilter(fil);

    QCOMPARE(cfr.filter(), fil);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    int expectedCount = 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

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

    QList<QContactLocalId> result = cfr.ids();

    QCOMPARE(contactIds, result);

    // asynchronous detail filtering

    QContactDetailFilter dfil;

    dfil.setDetailDefinitionName(QContactUrl::DefinitionName, QContactUrl::FieldUrl);

    cfr.setFilter(dfil);

    QVERIFY(cfr.filter() == dfil);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    contactIds = cm->contacts(dfil);

    result = cfr.ids();

    QCOMPARE(contactIds, result);

    // sort order

    QContactSortOrder sortOrder;

    sortOrder.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);

    QList<QContactSortOrder> sorting;

    sorting.append(sortOrder);

    cfr.setFilter(fil);

    cfr.setSorting(sorting);

    QCOMPARE(cfr.sorting(), sorting);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.start());  // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 2;

    QCOMPARE(spy.count(), expectedCount); // active + finished progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    contactIds = cm->contacts(sorting);

    result = cfr.ids();

    QCOMPARE(contactIds, result);

    // cancelling

    sorting.clear();

    cfr.setFilter(fil);

    cfr.setSorting(sorting);

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());

    QVERIFY(cfr.cancel());

    QVERIFY(cfr.status() == QContactAbstractRequest::Cancelling);

    QVERIFY(cfr.isActive());    // still cancelling

    QVERIFY(!cfr.isFinished()); // not finished cancelling

    QVERIFY(!cfr.start());      // already started.

    QVERIFY(cfr.waitForFinished());

    expectedCount += 3;

    QCOMPARE(spy.count(), expectedCount); // active + cancelling + cancelled progress signals.

    QVERIFY(cfr.isFinished());

    QVERIFY(!cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Cancelled);

    // restart, and wait for progress after cancel.

    QVERIFY(!cfr.cancel()); // not started

    QVERIFY(cfr.start());

    QVERIFY(cfr.isActive());

    QVERIFY(cfr.status() == QContactAbstractRequest::Active);

    QVERIFY(!cfr.isFinished());