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

**

** 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 <QScopedPointer>

#include "qtcontacts.h"

#include "qcontactmanagerdataholder.h" //QContactManagerDataHolder

QTM_USE_NAMESPACE

/* Define an innocuous request (fetch ie doesn't mutate) to "fill up" any queues */

#define FILL_QUEUE_WITH_FETCH_REQUESTS() QContactFetchRequest fqcfr1, fqcfr2, fqcfr3; \

                                         QContactDetailDefinitionFetchRequest fqdfr1, fqdfr2, fqdfr3; \

                                         fqcfr1.start(); \

                                         fqcfr2.start(); \

                                         fqcfr3.start(); \

                                         fqdfr1.start(); \

                                         fqdfr2.start(); \

                                         fqdfr3.start();

//TESTED_CLASS=

//TESTED_FILES=

// Unfortunately the plumbing isn't in place to allow cancelling requests at arbitrary points

// in their processing.  So we do multiple loops until things work out.. or not

#define MAX_OPTIMISTIC_SCHEDULING_LIMIT 100

// Thread capable QThreadSignalSpy (to avoid data races with count/appendArgS)

class QThreadSignalSpy: public QObject

{

public:

    QThreadSignalSpy(QObject *obj, const char *aSignal)

    {

#ifdef Q_CC_BOR

        const int memberOffset = QObject::staticMetaObject.methodCount();

#else

        static const int memberOffset = QObject::staticMetaObject.methodCount();

#endif

        Q_ASSERT(obj);

        Q_ASSERT(aSignal);

        if (((aSignal[0] - '0') & 0x03) != QSIGNAL_CODE) {

            qWarning("QThreadSignalSpy: Not a valid signal, use the SIGNAL macro");

            return;

        }

        QByteArray ba = QMetaObject::normalizedSignature(aSignal + 1);

        const QMetaObject *mo = obj->metaObject();

        int sigIndex = mo->indexOfMethod(ba.constData());

        if (sigIndex < 0) {

            qWarning("QThreadSignalSpy: No such signal: '%s'", ba.constData());

            return;

        }

        if (!QMetaObject::connect(obj, sigIndex, this, memberOffset,

                    Qt::DirectConnection, 0)) {

            qWarning("QThreadSignalSpy: QMetaObject::connect returned false. Unable to connect.");

            return;

        }

        sig = ba;

        initArgs(mo->method(sigIndex));

    }

    inline bool isValid() const { return !sig.isEmpty(); }

    inline QByteArray signal() const { return sig; }

    int qt_metacall(QMetaObject::Call call, int methodId, void **a)

    {

        methodId = QObject::qt_metacall(call, methodId, a);

        if (methodId < 0)

            return methodId;

        if (call == QMetaObject::InvokeMetaMethod) {

            if (methodId == 0) {

                appendArgs(a);

            }

            --methodId;

        }

        return methodId;

    }

    // The QList<QVariantList> API we actually use

    int count() const

    {

        QMutexLocker m(&lock);

        return savedArgs.count();

    }

    void clear()

    {

        QMutexLocker m(&lock);

        savedArgs.clear();

    }

private:

    void initArgs(const QMetaMethod &member)

    {

        QMutexLocker m(&lock);

        QList<QByteArray> params = member.parameterTypes();

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

            int tp = QMetaType::type(params.at(i).constData());

            if (tp == QMetaType::Void)

                qWarning("Don't know how to handle '%s', use qRegisterMetaType to register it.",

                         params.at(i).constData());

            args << tp;

        }

    }

    void appendArgs(void **a)

    {

        QMutexLocker m(&lock);

        QList<QVariant> list;

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

            QMetaType::Type type = static_cast<QMetaType::Type>(args.at(i));

            list << QVariant(type, a[i + 1]);

        }

        savedArgs.append(list);

    }

    // the full, normalized signal name

    QByteArray sig;

    // holds the QMetaType types for the argument list of the signal

    QList<int> args;

    mutable QMutex lock;

    // Different API

    QList< QVariantList> savedArgs;

};

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 testQuickDestruction();

    void testQuickDestruction_data() { addManagers(); }

    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);

    QContactManager* prepareModel(const QString& uri);

    Qt::HANDLE m_mainThreadId;

    Qt::HANDLE m_progressSlotThreadId;

    QContactManagerDataHolder managerDataHolder;

};

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<QContactAbstractRequest::State>("QContactAbstractRequest::State");

}

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 = prepareModel(uri);

    QContactFetchRequest* req = new QContactFetchRequest;

    req->setManager(cm);

    QContactManager* cm2 = prepareModel(uri);

    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);

    QScopedPointer<QContactManager> cm(prepareModel(uri));

    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());

    // "all contacts" retrieval

    QContactFilter fil;

    cfr.setManager(cm.data());

    QCOMPARE(cfr.manager(), cm.data());

    QVERIFY(!cfr.isActive());

    QVERIFY(!cfr.isFinished());

    QVERIFY(!cfr.cancel());

    QVERIFY(!cfr.waitForFinished());

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

    QThreadSignalSpy spy(&cfr, SIGNAL(stateChanged(QContactAbstractRequest::State)));

    cfr.setFilter(fil);

    QCOMPARE(cfr.filter(), fil);

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

    QVERIFY(cfr.start());

    //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

    QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

    QVERIFY(cfr.waitForFinished());

    QVERIFY(cfr.isFinished());

    QVERIFY(spy.count() >= 1); // active + finished progress signals

    spy.clear();

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

    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() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

    //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

    QVERIFY(cfr.waitForFinished());

    QVERIFY(cfr.isFinished());

    QVERIFY(spy.count() >= 1); // active + finished progress signals

    spy.clear();

    contactIds = cm->contactIds(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() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

    //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

    QVERIFY(cfr.waitForFinished());

    QVERIFY(cfr.isFinished());

    QVERIFY(spy.count() >= 1); // active + finished progress signals

    spy.clear();

    contactIds = cm->contactIds(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() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

    //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

    QVERIFY(cfr.waitForFinished());

    QVERIFY(cfr.isFinished());

    QVERIFY(spy.count() >= 1); // active + finished progress signals

    spy.clear();

    contactIds = cm->contactIds(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> retrievedDetails = retrievedRestricted.details();

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

        foreach (const QContactDetail& det, expectedDetails) {

            // 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 in the expected contact should be in the retrieved one.

            QVERIFY(retrievedDetails.contains(det));

        }

    }

    // cancelling

    sorting.clear();

    cfr.setFilter(fil);

    cfr.setSorting(sorting);

    cfr.setDefinitionRestrictions(QStringList());

    int bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT; // attempt to cancel 40 times.  If it doesn't work due to threading, bail out.

    while (true) {

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

        FILL_QUEUE_WITH_FETCH_REQUESTS();

        QVERIFY(cfr.start());

        if (!cfr.cancel()) {

            // due to thread scheduling, async cancel might be attempted

            // after the request has already finished.. so loop and try again.

            spy.clear();

            cfr.waitForFinished();

            sorting.clear();

            cfr.setFilter(fil);

            cfr.setSorting(sorting);

            cfr.setDefinitionRestrictions(QStringList());

            bailoutCount -= 1;

            if (!bailoutCount) {

                qWarning("Unable to test cancelling due to thread scheduling!");

                bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

                break;

            }

            continue;

        }

        // if we get here, then we are cancelling the request.

        QVERIFY(cfr.waitForFinished());

        QVERIFY(cfr.isCanceled());

        QVERIFY(spy.count() >= 1); // active + cancelled progress signals

        spy.clear();

        break;

    }

    // restart, and wait for progress after cancel.

    while (true) {

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

        FILL_QUEUE_WITH_FETCH_REQUESTS();

        QVERIFY(cfr.start());

        if (!cfr.cancel()) {

            // due to thread scheduling, async cancel might be attempted

            // after the request has already finished.. so loop and try again.

            cfr.waitForFinished();

            sorting.clear();

            cfr.setFilter(fil);

            cfr.setSorting(sorting);

            cfr.setDefinitionRestrictions(QStringList());

            bailoutCount -= 1;