/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Extra tests notifications.

*

*/

#include "t_caclient.h"

#include "caservice.h"

#include "canotifier.h"

#include "canotifierfilter.h"

#include "t_caclientnotifier.h"

const int entryIdFake(-1);

const int waitTimeMin(100);

const int waitTime500ms(500);

const int waitTime1sec(1000);

const int noOfClients(3);

const int noOfManyClients(20);

class Thread: public QThread

{

public:

    enum OpType {None, AddItem, RemoveEntry, RemoveEntryId, TooMuchClients};

    void run();

    Thread(): mOpType(None), mRemoved(false), mEntry(), mId(0), mClientNotifier(NULL), mNotifier(NULL) { }

    ~Thread();

    OpType mOpType;

    bool mRemoved;

    QSharedPointer<CaEntry> mEntry;

    int mId;

    TestCaClientNotifier *mClientNotifier;

    CaNotifier *mNotifier;

};

Thread::~Thread()

{

    QSharedPointer<CaService> service = CaService::instance();

    service->removeEntry(mId);

    disconnect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),

               mClientNotifier, SLOT(entryChanged(int,ChangeType)));

    QTest::qWait(waitTime500ms);

    delete mClientNotifier;

}

void Thread::run()

{

    QTest::qWait(waitTimeMin);

    QSharedPointer<CaService> service = CaService::instance();

    CaNotifierFilter *filter = new CaNotifierFilter();

    filter->setEntryRole(ItemEntryRole);

    filter->setTypeNames(QStringList() << "TypeName");

    mClientNotifier = new TestCaClientNotifier(*service, filter);

    mNotifier = mClientNotifier->getNotifier();

    CaEntry item;

    item.setText("Text");

    item.setEntryTypeName("TypeName");

    switch (mOpType) {

    case AddItem: {

        connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),

                mClientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime1sec);

        QSharedPointer<CaEntry> entry = service->createEntry(item);

        mId = entry->id();

    }

    break;

    case RemoveEntry: {

        connect(mNotifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),

                mClientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));

        QTest::qWait(waitTime1sec);

        mRemoved = service->removeEntry(*mEntry);

    }

    break;

    case RemoveEntryId: {

        connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),

                mClientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime1sec);

        mRemoved = service->removeEntry(mId);

    }

    break;

    case TooMuchClients: {

        connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),

                mClientNotifier, SLOT(entryChanged(int,ChangeType)));

    }

    break;

    default:

        qWarning("Thread::run: unknown operation (mOpType)");

        break;

    }

    exec();

}

/*

class ThreadRemoveEntry: public QThread

{

public:

    void run();

    ~ThreadRemoveEntry();

    bool mRemoved;

    CaEntry *mEntry;

    int mId;

    TestCaClientNotifier *mClientNotifier;

    CaNotifier *mNotifier;

};

ThreadRemoveEntry::~ThreadRemoveEntry()

{

    disconnect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),

        mClientNotifier, SLOT(entryChanged(int,ChangeType)) );

    QTest::qWait(waitTime500ms);

    delete mClientNotifier;

}

void ThreadRemoveEntry::run()

{

    QSharedPointer<CaService> service = CaService::instance();

    TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);

    CaNotifier *notifier = clientNotifier->getNotifier();

    connect( notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType )),

            clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType )) );

    CaEntry item;

    item.setText("Text");

    item.setEntryTypeName("TypeName");

    mRemoved = service->removeEntry(*mEntry);

    exec();

}

*/

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestAddItemChangeTypeNotifierNClients()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        QSharedPointer<CaService> service = CaService::instance();

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);

        CaNotifier *notifier = clientNotifier->getNotifier();

        connect(notifier, SIGNAL(entryChanged(int,ChangeType)),

                clientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime1sec);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entries[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            item.setText("Text");

            item.setEntryTypeName("TypeName");

            entries[i] = service->createEntry(item);

            QTest::qWait(waitTime1sec);

            QCOMPARE(clientNotifier->mChangeType, AddChangeType);

            QCOMPARE(clientNotifier->mEntryId, entries[i]->id());

            QCOMPARE(clientNotifier->mCount, i+1);

        }

        for (int i=0; i<noOfClients; i++) {

            for (int j=i+1; j<noOfClients; j++) {

                QVERIFY(entries[i]->id() != entries[j]->id());

            }

        }

        // cleanup

        disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),

                   clientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        for (int i=0; i<noOfClients; i++) {

            service->removeEntry(entries[i]->id());

        }

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestAddItemChangeTypeNotifierNClientsFast()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        QSharedPointer<CaService> service = CaService::instance();

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);

        CaNotifier *notifier = clientNotifier->getNotifier();

        connect(notifier, SIGNAL(entryChanged(int,ChangeType)),

                clientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime1sec);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entries[noOfClients];

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        for (int i=0; i<noOfClients; i++) {

            entries[i] = service->createEntry(item);

        }

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mCount, 3);

        for (int i=0; i<noOfClients; i++) {

            QVERIFY(clientNotifier->mEntryIds->contains(entries[i]->id()));

            for (int j=i+1; j<noOfClients; j++) {

                QVERIFY(entries[i]->id() != entries[j]->id());

            }

        }

        // cleanup

        disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),

                   clientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        for (int i=0; i<noOfClients; i++) {

            service->removeEntry(entries[i]->id());

        }

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestAddItemChangeTypeNotifierNClientsThreads()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        Thread threads[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            threads[i].mOpType = Thread::AddItem;

            threads[i].start();

        }

        QTest::qWait(6*noOfClients*waitTime1sec);

        for (int i=0; i<noOfClients; i++) {

            QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);

            for (int j=0; j<noOfClients; j++) {

                for (int k=j+1; k<noOfClients; k++) {

                    QVERIFY(threads[i].mClientNotifier->mEntryIds->at(j)

                            != threads[i].mClientNotifier->mEntryIds->at(k));

                }

            }

        }

        for (int i=0; i<noOfClients; i++) {

            for (int j=0; j<noOfClients; j++) {

                QVERIFY(threads[j].mClientNotifier->mEntryIds->contains(threads[i].mId));

            }

        }

        for (int i=0; i<noOfClients; i++) {

            threads[i].exit(0);

        }

        QTest::qWait(waitTime500ms);

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestRemoveEntryChangeTypeNotifierNClients()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        QSharedPointer<CaService> service = CaService::instance();

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);

        CaNotifier *notifier = clientNotifier->getNotifier();

        connect(notifier, SIGNAL(entryChanged(int,ChangeType)),

                clientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime500ms);

        connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),

                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));

        QTest::qWait(waitTime1sec);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entries[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            entries[i] = service->createEntry(item);

            QTest::qWait(waitTime1sec);

            QCOMPARE(clientNotifier->mChangeType, AddChangeType);

            QCOMPARE(clientNotifier->mEntryId, entries[i]->id());

            QCOMPARE(clientNotifier->mCount, 2*(i+1));

        }

        for (int i=0; i<noOfClients; i++) {

            bool removed = service->removeEntry(*entries[i]);

            QVERIFY(removed);

            QTest::qWait(waitTime1sec);

            QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);

            QCOMPARE(clientNotifier->mEntryId, entries[i]->id());

        }

        // cleanup

        disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),

                   clientNotifier, SLOT(entryChanged(int,ChangeType)));

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestRemoveEntryChangeTypeNotifierNClientsThreads()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        QSharedPointer<CaService> service = CaService::instance();

        QTest::qWait(waitTime1sec);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entries[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            entries[i] = service->createEntry(item);

        }

        QTest::qWait(waitTime1sec);

        Thread threads[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            threads[i].mOpType = Thread::RemoveEntry;

            threads[i].mEntry = entries[i];

            threads[i].start();

        }

        QTest::qWait(6*noOfClients*waitTime1sec);

        for (int i=0; i<noOfClients; i++) {

            QVERIFY(threads[i].mRemoved);

            QCOMPARE(threads[i].mClientNotifier->mChangeType, RemoveChangeType);

            QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);

            QVERIFY(threads[i].mClientNotifier->mEntryIds->contains(entries[i]->id()));

        }

        for (int i=0; i<noOfClients; i++) {

            threads[i].exit(0);

        }

        QTest::qWait(waitTime500ms);

        // cleanup

        for (int i=0; i<noOfClients; i++) {

            bool removed = service->removeEntry(*entries[i]);

            QTest::qWait(waitTime1sec);

        }

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestRemoveEntryIdChangeTypeNotifierNClientsThreads()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        QSharedPointer<CaService> service = CaService::instance();

        QTest::qWait(waitTime1sec);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        int ids[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            ids[i] = service->createEntry(item)->id();

        }

        QTest::qWait(waitTime1sec);

        Thread threads[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            threads[i].mOpType = Thread::RemoveEntryId;

            threads[i].mId = ids[i];

            threads[i].start();

        }

        QTest::qWait(6*noOfClients*waitTime1sec);

        for (int i=0; i<noOfClients; i++) {

            QVERIFY(threads[i].mRemoved);

            QCOMPARE(threads[i].mClientNotifier->mChangeType, RemoveChangeType);

            QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);

            QVERIFY(threads[i].mClientNotifier->mEntryIds->contains(ids[i]));

        }

        for (int i=0; i<noOfClients; i++) {

            threads[i].exit(0);

        }

        QTest::qWait(waitTime500ms);

        // cleanup

        for (int i=0; i<noOfClients; i++) {

            bool removed = service->removeEntry(ids[i]);

            QTest::qWait(waitTime1sec);

        }

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void TestCaClient::TestAddItemChangeTypeNotifierManyClientsThreads()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        QSharedPointer<CaService> service = CaService::instance();

        Thread threads[noOfManyClients];

        for (int i=0; i<noOfManyClients; i++) {

            threads[i].mOpType = Thread::TooMuchClients;

            threads[i].start();

        }

        QTest::qWait(10*waitTime1sec);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

        int ids[noOfClients];

        for (int i=0; i<noOfClients; i++) {

            ids[i] = service->createEntry(item)->id();

        }

        QTest::qWait(6*noOfManyClients*waitTime1sec);

        for (int i=0; i<noOfManyClients; i++) {

            QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);

            for (int j=0; j<noOfClients; j++) {

                for (int k=j+1; k<noOfClients; k++) {

                    QVERIFY(threads[i].mClientNotifier->mEntryIds->at(j)

                            != threads[i].mClientNotifier->mEntryIds->at(k));

                }

            }

        }

        for (int i=0; i<noOfClients; i++) {

            for (int j=0; j<noOfManyClients; j++) {

                QVERIFY(threads[j].mClientNotifier->mEntryIds->contains(ids[i]));

            }

        }

        for (int i=0; i<noOfManyClients; i++) {

            threads[i].exit(0);

        }

        QTest::qWait(waitTime500ms);

        // cleanup

        for (int i=0; i<noOfClients; i++) {

            bool removed = service->removeEntry(ids[i]);

            QVERIFY(removed);

            QTest::qWait(waitTime1sec);

        }

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

    __UHEAP_MARKEND;