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

**

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

#include <QTest>

#include <QDebug>

#include "qtmessaging.h"

#include "../support/support.h"

#if defined(Q_OS_SYMBIAN) || (defined(Q_OS_WIN) && defined(_WIN32_WCE))

# if defined(TESTDATA_DIR)

#  undef TESTDATA_DIR

# endif

# define TESTDATA_DIR "."

#endif

// Will try to wait for the condition while allowing event processing

#define QTRY_VERIFY(__expr) \

    do { \

        const int __step = 50; \

        const int __timeout = 90000; \

        if (!(__expr)) { \

            QTest::qWait(0); \

        } \

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

            QTest::qWait(__step); \

        } \

        QVERIFY(__expr); \

    } while(0)

//TESTED_CLASS=

//TESTED_FILES=

QTM_USE_NAMESPACE

class SignalCatcher : public QObject

{

    Q_OBJECT

public:

    SignalCatcher(QObject* parent = 0);

    void reset();

public slots:

    void messagesCounted(int count);

    void messagesFound(const QMessageIdList& messageList);

    void stateChanged(QMessageService::State s);

    void progressChanged(int,int);

public:

    QMessageIdList ids;

    int count;

    QMessageService::State state;

    int progressMin, progressMax;

};

SignalCatcher::SignalCatcher(QObject* parent)

:

QObject(parent)

{

    reset();

}

void SignalCatcher::reset()

{

    ids.clear();

    count = 0;

    progressMin = 0;

    progressMax = 0;

    state = QMessageService::InactiveState;

}

void SignalCatcher::messagesCounted(int c)

{

    count = c;

}

void SignalCatcher::messagesFound(const QMessageIdList& results)

{

    ids.append(results);

}

void SignalCatcher::stateChanged(QMessageService::State s)

{

    state = s;

}

void SignalCatcher::progressChanged(int min, int max)

{

    progressMin = min; progressMax = max;

}

class Params

{

    QMap<const char*, const char*> _map;

public:

    Params() {}

    Params& operator()(const char* name, const char* value)

    {

        _map.insert(name, value); return *this;

    }

    operator Support::Parameters() const

    {

        Support::Parameters result;

        QMap<const char*, const char*>::const_iterator it = _map.begin(), end = _map.end();

        for ( ; it != end; ++it) {

            result.insert(it.key(), it.value());

        }

        return result;

    }

};

/*

    Unit test for QMessageService class.

*/

class tst_QMessageService : public QObject

{

    Q_OBJECT

public:

    tst_QMessageService();

    virtual ~tst_QMessageService();

private slots:

    void init();

    void cleanUp();

    void initTestCase();

    void cleanupTestCase();

    void testQueryMessages();

    void testQueryMessages_data();

    void testCountMessages();

    void testCountMessages_data();

    void testSend();

    void testCompose();

    void testRetrieveHeader();

    void testRetrieveBody();

    void testRetrieve();

    void testShow();

    void testExportUpdates();

private:

    void testQueryCountData();

private:

    QMessageService* testService;

    QSet<QMessageFolderId> existingFolderIds;

    QMessageFolderIdList folderIds;

    QSet<QMessageAccountId> existingAccountIds;

    QMessageAccountIdList accountIds;

    QSet<QMessageId> existingMessageIds;

    QMessageIdList messageIds;

    QMessageFilter existingAccountsFilter;

    QList<int> messageSizes;

};

Q_DECLARE_METATYPE(QMessageAccountIdList)

Q_DECLARE_METATYPE(QMessageAccountFilter)

Q_DECLARE_METATYPE(QMessageAccountSortOrder)

Q_DECLARE_METATYPE(QMessageFolderIdList)

Q_DECLARE_METATYPE(QMessageFolderFilter)

Q_DECLARE_METATYPE(QMessageFolderSortOrder)

Q_DECLARE_METATYPE(QMessageIdList)

Q_DECLARE_METATYPE(QMessageFilter)

Q_DECLARE_METATYPE(QMessageSortOrder)

QTEST_MAIN(tst_QMessageService)

#include "tst_qmessageservice.moc"

tst_QMessageService::tst_QMessageService()

{

}

tst_QMessageService::~tst_QMessageService()

{

}

void tst_QMessageService::init()

{

    testService = new QMessageService(this);

}

void tst_QMessageService::cleanUp()

{

    if(testService) delete testService; testService = 0;

}

void tst_QMessageService::initTestCase()

{

#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)

    if (!Support::mapiAvailable())

        QSKIP("Skipping tests because a MAPI subsystem does not appear to be available", SkipAll);

#endif

    Support::clearMessageStore();

    QMessageManager* manager = new QMessageManager(this);

    existingAccountIds = manager->queryAccounts().toSet();

    existingAccountsFilter = ~QMessageFilter();

    foreach(QMessageAccountId id, existingAccountIds) {

        existingAccountsFilter |= QMessageFilter::byParentAccountId(id);

    }

    QList<Support::Parameters> accountParams;

    accountParams << Params()("name", "Work")

        ("fromAddress", "Important.Person@example.com")

        << Params()("name", "Personal")

        ("fromAddress", "superstar2000@example.net")

        << Params()("name", "Alter Ego")

        ("fromAddress", "UltraMegaLightningBabe@superhero.test");

    foreach (const Support::Parameters &params, accountParams) {

        accountIds.append(Support::addAccount(params));

        QVERIFY(accountIds.last().isValid());

    }

    existingFolderIds = manager->queryFolders().toSet();

    QList<Support::Parameters> folderParams;

    folderParams << Params()("parentAccountName", "Alter Ego")

        ("path", "My messages")

        ("name", "My messages")

        ("parentFolderPath", "")

        << Params()("parentAccountName", "Work")

        ("path", "Innbox")

        ("name", "Innbox")

        ("parentFolderPath", "")

#if !defined(Q_OS_SYMBIAN) && !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

        << Params()("parentAccountName", "Work")

        ("path", "Innbox/X-Announce")

        ("name", "X-Announce")

        ("parentFolderPath", "Innbox")

        << Params()("parentAccountName", "Work")

        ("path", "Innbox/X-Announce/X-Archived")

        ("name", "X-Archived")

        ("parentFolderPath", "Innbox/X-Announce");

#else    

    << Params()("parentAccountName", "Work")

        ("path", "X-Announce")

        ("name", "X-Announce")

        ("parentFolderPath", "")

        << Params()("parentAccountName", "Work")

        ("path", "X-Archived")

        ("name", "X-Archived")

        ("parentFolderPath", "");

#endif    

    foreach (const Support::Parameters &params, folderParams) {

        folderIds.append(Support::addFolder(params));

        QVERIFY(folderIds.last().isValid());

    }

    existingMessageIds = manager->queryMessages(~existingAccountsFilter).toSet();

    // For windows at least, we can't have HasAttachments set without a real attachment

    const char *attachmentPaths = TESTDATA_DIR "/testdata/1.txt";

    QList<Support::Parameters> messageParams;

    messageParams << Params()("parentAccountName", "Alter Ego")

        ("parentFolderPath", "My messages")

#if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)) // SMS messages must be in SMS store on Windows and on Symbian

        ("type", "email")

#else

        ("type", "sms")

#endif

        ("to", "SuperMegaLightningBabe")

        ("from", "Frozone")

        ("subject", "Ice to meet you")

        ("text", "Shall I compare thee to a summers day")

        ("date", "2000-01-01T12:00:00Z")

        ("receivedDate", "2000-01-01T12:01:00Z")

        ("priority", "")

        ("size", "160")

        ("status-read", "true")

        ("custom-flagged", "true")

        << Params()("parentAccountName", "Work")

        ("parentFolderPath", "Innbox")

        ("type", "email")

        ("to", "Important.Person@example.com")

        ("from", "Esteemed.Colleague@example.com")

        ("subject", "Meeting agenda")

        ("date", "2000-01-01T12:00:00Z")

        ("receivedDate", "2000-01-01T20:00:00Z")

        ("priority", "High")

        ("size", "10240")

        ("status-hasAttachments", "true")

        ("attachments", attachmentPaths)

        ("custom-spam", "filter:no")

        ("custom-flagged", "true")

        << Params()("parentAccountName", "Work")

        ("parentFolderPath", "Innbox")

        ("type", "email")

        ("to", "Important.Person@example.com,Minion@example.com")

        ("from", "Big.Boss@example.com")

        ("subject", "Motivational message")

        ("text", "School's out for summer")

        ("date", "2000-01-01T13:00:00Z")

        ("receivedDate", "2000-01-01T13:05:00Z")

        ("priority", "High")

        ("size", "20480")

        ("status-hasAttachments", "true")

        ("attachments", attachmentPaths)

        ("custom-spam", "filter:no")

#if !defined(Q_OS_SYMBIAN) && !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

        << Params()("parentAccountName", "Work")

        ("parentFolderPath", "Innbox/X-Announce")

        ("type", "email")

        ("to", "announce@example.com,maintenance-log@example.com")

        ("from", "sysadmin@example.com")

        ("subject", "Scheduled maintenance")

        ("date", "2000-01-01T13:00:00Z")

        ("receivedDate", "2000-01-01T13:00:01Z")

        ("priority", "")

        ("size", "1056")

        ("status-read", "true")

        ("custom-spam", "filter:maybe")

        << Params()("parentAccountName", "Work")

        ("parentFolderPath", "Innbox/X-Announce/X-Archived")

        ("type", "email")

        ("to", "announce@example.com")

        ("from", "Big.Boss@example.com")

        ("subject", "Free beer")

        ("date", "1999-04-01T10:30:00Z")

        ("receivedDate", "1999-04-01T10:31:00Z")

        ("priority", "Low")

        ("size", "4096")

        ("status-read", "true")

        ("status-hasAttachments", "true")

        ("attachments", attachmentPaths)

        ("custom-spam", "filter:yes");

#else

    << Params()("parentAccountName", "Work")

        ("parentFolderPath", "X-Announce")

        ("type", "email")

        ("to", "announce@example.com,maintenance-log@example.com")

        ("from", "sysadmin@example.com")

        ("subject", "Scheduled maintenance")

        ("date", "2000-01-01T13:00:00Z")

        ("receivedDate", "2000-01-01T13:00:01Z")

        ("priority", "")

        ("size", "1056")

        ("status-read", "true")

        ("custom-spam", "filter:maybe")

        << Params()("parentAccountName", "Work")

        ("parentFolderPath", "X-Archived")

        ("type", "email")

        ("to", "announce@example.com")

        ("from", "Big.Boss@example.com")

        ("subject", "Free beer")

        ("date", "1999-04-01T10:30:00Z")

        ("receivedDate", "1999-04-01T10:31:00Z")

        ("priority", "Low")

        ("size", "4096")

        ("status-read", "true")

        ("status-hasAttachments", "true")

        ("attachments", attachmentPaths)

        ("custom-spam", "filter:yes");

#endif

    foreach (const Support::Parameters &params, messageParams) {

        messageIds.append(Support::addMessage(params));

        QVERIFY(messageIds.last().isValid());

        // Use the resultant message sizes in testing - the configured sizes aren't honoured by MAPI

        QMessage m(messageIds.last());

        messageSizes.append(m.size());

    }

}

void tst_QMessageService::cleanupTestCase()

{

}

void tst_QMessageService::testQueryMessages()

{

    QFETCH(QMessageFilter, filter);

    QFETCH(QMessageIdList, ids);

    QFETCH(QMessageIdList, negatedIds);

    QFETCH(QString, body);

    if (filter.isSupported()) {

        QVERIFY(filter == filter);

        QCOMPARE(filter != QMessageFilter(), !filter.isEmpty());

        SignalCatcher sc(this);

        connect(testService,SIGNAL(messagesFound(const QMessageIdList&)),&sc,SLOT(messagesFound(const QMessageIdList&)));

#if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

        connect(testService,SIGNAL(stateChanged(QMessageService::State)),&sc,SLOT(stateChanged(QMessageService::State)));

        // Order is irrelevant for filtering

        if (body.isEmpty()) {

            sc.reset();

            QCOMPARE(testService->queryMessages(filter&~existingAccountsFilter),true);

#if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

            QTRY_VERIFY(sc.state == QMessageService::FinishedState);

            while(testService->state() == QMessageService::ActiveState)

            QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),ids.toSet());

            sc.reset();

            QCOMPARE(testService->queryMessages(~filter&~existingAccountsFilter),true);

#if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

            QTRY_VERIFY(sc.state == QMessageService::FinishedState);

            while(testService->state() == QMessageService::ActiveState)

            QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),negatedIds.toSet());

        } else {

            sc.reset();

            QCOMPARE(testService->queryMessages(filter&~existingAccountsFilter,body),true);

#if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

            QTRY_VERIFY(sc.state == QMessageService::FinishedState);

            while(testService->state() == QMessageService::ActiveState)

            QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),ids.toSet());

            sc.reset();

            QCOMPARE(testService->queryMessages(~filter&~existingAccountsFilter,body),true);

#if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

            QTRY_VERIFY(sc.state == QMessageService::FinishedState);

            while(testService->state() == QMessageService::ActiveState)

            QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),negatedIds.toSet());

        }

    } else {

        QSKIP("Unsupported for this configuration", SkipSingle);

    }

}

void tst_QMessageService::testQueryCountData()

{

    QTest::addColumn<QMessageFilter>("filter");

    QTest::addColumn<QMessageIdList>("ids");

    QTest::addColumn<QMessageIdList>("negatedIds");

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

#if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

    QTest::newRow("empty filter")

        << QMessageFilter() 

        << messageIds

        << QMessageIdList()

        << "";

#endif

    QTest::newRow("id equality 1")

        << QMessageFilter::byId(messageIds[0], QMessageDataComparator::Equal)