/*
* 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;
#endif//UT_MEMORY_CHECK
#endif//Q_OS_SYMBIAN
}