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

**

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

    void cleanupTestCase();

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 threadDelivery_data() { addManagers(); }

protected slots:

    void resultsAvailableReceived();

private:

    bool compareContactLists(QList<QContact> lista, QList<QContact> listb);

    bool compareContacts(QContact ca, QContact cb);

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

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

{

}

void tst_QContactAsync::initTestCase()

{

    managerDataHolder.reset(new QContactManagerDataHolder());

}

void tst_QContactAsync::cleanupTestCase()

{

    managerDataHolder.reset(0);

}

bool tst_QContactAsync::compareContactLists(QList<QContact> lista, QList<QContact> listb)

{

    // NOTE: This compare is contact order insensitive.  

    // Remove matching contacts

    foreach (QContact a, lista) {

        foreach (QContact b, listb) {

            if (compareContacts(a, b)) {

                lista.removeOne(a);

                listb.removeOne(b);

                break;

            }

        }

    }    

    return (lista.count() == 0 && listb.count() == 0);

}

bool tst_QContactAsync::compareContacts(QContact ca, QContact cb)

{

    // NOTE: This compare is contact detail order insensitive.

    if (ca.localId() != cb.localId())

        return false;

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

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

    // Remove matching details

    foreach (QContactDetail ad, aDetails) {

        foreach (QContactDetail bd, bDetails) {

            if (ad == bd) {

                ca.removeDetail(&ad);

                cb.removeDetail(&bd);

                break;

            }

            // Special handling for timestamp

            if (ad.definitionName() == QContactTimestamp::DefinitionName &&

                bd.definitionName() == QContactTimestamp::DefinitionName) {

                QContactTimestamp at = static_cast<QContactTimestamp>(ad);

                QContactTimestamp bt = static_cast<QContactTimestamp>(bd);

                if (at.created().toString() == bt.created().toString() &&

                    at.lastModified().toString() == bt.lastModified().toString()) {

                    ca.removeDetail(&ad);

                    cb.removeDetail(&bd);

                    break;

                }

            }            

        }

    }

    return (ca == cb);

}

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

    QContactFetchHint fetchHint;

    fetchHint.setDetailDefinitionsHint(QStringList(QContactName::DefinitionName));

    cfr.setFetchHint(fetchHint);

    QCOMPARE(cfr.fetchHint().detailDefinitionsHint(), 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) {