/*

* 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:  Main test class for hspluginmodel library.

*

*/

#include <QScopedPointer>

#include <qservicemanager.h>

#include "t_caclient.h"

#include "caservice.h"

#include "canotifier.h"

#include "canotifierfilter.h"

#include "caquery.h"

#include "t_caclientNotifier.h"

const int entryIdFake(-1);

const int waitTime500ms(500);

const int waitTime1sec(1000);

QTM_USE_NAMESPACE

QStringList pluginPaths;

QString xmlName("caapphandlerplugin.xml");

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

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

//

void TestCaClient::initTestCase()

{

#ifdef Q_OS_SYMBIAN

    startThread();

#endif //Q_OS_SYMBIAN

    mService = CaService::instance();

}

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

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

//

void TestCaClient::cleanupTestCase()

{

#ifdef Q_OS_SYMBIAN

    stopThread();

#endif //Q_OS_SYMBIAN

    QSharedPointer<CaService> serviceNull(NULL);

    mService = serviceNull;

    QTest::qWait(5000);

}

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

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

int threadFunction(void *params)

{

#ifdef Q_OS_SYMBIAN

    while (ETrue) {

        User::ResetInactivityTime();//it should help for Viewserver11 panic

        User::After(5000000);

    }

#endif //Q_OS_SYMBIAN

    return 0;

}

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

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

//

void TestCaClient::startThread()

{

#ifdef Q_OS_SYMBIAN

    User::LeaveIfError(iThread.Create(

                           _L("thread_kill_viewsrv11"),

                           threadFunction,

                           16384,

                           4000,

                           4000,

                           NULL));

    iThread.Resume();

#endif //Q_OS_SYMBIAN

}

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

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

//

void TestCaClient::stopThread()

{

#ifdef Q_OS_SYMBIAN

    iThread.Close();

#endif //Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestAssignmentOperatorNotifier()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        CaNotifierFilter filter;

        filter.setEntryRole(ItemEntryRole);

        filter.setTypeNames(QStringList() << "typeName1" << "typeName2");

        filter.setParentId(22);

        filter.setIds(QList<int>() << 11 << 22);

        CaNotifierFilter filterAssign;

        filterAssign = filter;

        QCOMPARE(filterAssign.getEntryRole(), filter.getEntryRole());

        QCOMPARE(filterAssign.getParentId(), filter.getParentId());

        for (int i(0); i < filter.getIds().count(); i++) {

            QCOMPARE(filterAssign.getIds().at(i),

            filter.getIds().at(i));

        }

        for (int i(0); i < filter.getTypeNames().count(); i++) {

            QCOMPARE(filterAssign.getTypeNames().at(i),

            filter.getTypeNames().at(i));

        }

        filter.setEntryRole(GroupEntryRole);

        filter.getTypeNames().clear();

        filter.setTypeNames(QStringList() << "typeName3" << "typeName4");

        filter.setParentId(55);

        filter.getIds().clear();

        filter.setIds(QList<int>() << 33 << 44);

        QVERIFY(filterAssign.getEntryRole() != filter.getEntryRole());

        QVERIFY(filterAssign.getParentId() != filter.getParentId());

        for (int i(0); i < filter.getIds().count(); i++) {

            QVERIFY(filterAssign.getIds().at(i)

            != filter.getIds().at(i));

        }

        for (int i(0); i < filter.getTypeNames().count(); i++) {

            QVERIFY(filterAssign.getTypeNames().at(i)

            != filter.getTypeNames().at(i));

        }

        CaNotifierFilter filterCopyConstructor(filter);

        QCOMPARE(filterCopyConstructor.getEntryRole(), filter.getEntryRole());

        QCOMPARE(filterCopyConstructor.getParentId(), filter.getParentId());

        for (int i(0); i < filter.getIds().count(); i++) {

            QCOMPARE(filterCopyConstructor.getIds().at(i),

            filter.getIds().at(i));

        }

        for (int i(0); i < filter.getTypeNames().count(); i++) {

            QCOMPARE(filterCopyConstructor.getTypeNames().at(i),

            filter.getTypeNames().at(i));

        }

        CaQuery query;

        query.setEntryRoles(GroupEntryRole);

        query.setEntryTypeNames(QStringList() << "Query1" << "Query2");

        query.setParentId(77);

        CaNotifierFilter filterQuery(query);

        QCOMPARE(filterQuery.getEntryRole(), query.entryRoles());

        QCOMPARE(filterQuery.getParentId(), query.parentId());

        QCOMPARE(filterQuery.getIds().count(), 0);

        for (int i(0); i < query.entryTypeNames().count(); i++) {

            QCOMPARE(filterQuery.getTypeNames().at(i),

            query.entryTypeNames().at(i));

        }

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

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

//

void TestCaClient::TestAddItemChangeTypeNotifier()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        CaNotifierFilter *filter = new CaNotifierFilter();

        filter->setEntryRole(ItemEntryRole);

        QStringList strList;

        strList.append("TypeName");

        filter->setTypeNames(strList);

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);

        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> entry = mService->createEntry(item);

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entry->id());

        // cleanup

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

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

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        delete filter;

        mService->removeEntry(entry->id());

        QTest::qWait(waitTime500ms);

        QTest::qWait(waitTime500ms);

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestAddGroupChangeTypeNotifier()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        CaNotifierFilter *filter = new CaNotifierFilter();

        filter->setEntryRole(GroupEntryRole);

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

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);

        CaNotifier *notifier = clientNotifier->getNotifier();

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

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

        QTest::qWait(waitTime500ms);

        CaEntry group(GroupEntryRole);

        group.setText("Text");

        group.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entry = mService->createEntry(group);

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entry->id());

        // cleanup

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

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

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        mService->removeEntry(entry->id());

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestRemoveEntryChangeTypeNotifier()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        CaNotifierFilter *filter = new CaNotifierFilter();

        filter->setEntryRole(ItemEntryRole);

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

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);

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

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

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

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entry->id());

        int entryId = clientNotifier->mEntryId;

        clientNotifier->mEntryId = 0;

        bool removed = mService->removeEntry(*entry);

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entryId);

        QCOMPARE(removed, TRUE);

        // cleanup

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

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

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

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

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        mService->removeEntry(entry->id());

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestRemoveEntryIdChangeTypeNotifier()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

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

        QTest::qWait(waitTime1sec);

        CaNotifierFilter *filter = new CaNotifierFilter();

        filter->setEntryRole(ItemEntryRole);

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

        filter->setIds(QList<int>() << entry->id());

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);

        CaNotifier *notifier = clientNotifier->getNotifier();

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

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

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

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

        QTest::qWait(waitTime500ms);

        int entryId = entry->id();

        clientNotifier->mEntryId = 0;

        bool removed = mService->removeEntry(entryId);

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entryId);

        QCOMPARE(removed, TRUE);

        // cleanup

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

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

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

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

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        delete filter;

        mService->removeEntry(entry->id());

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestRemoveEntryChangeTypeNotifierFake()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);

        CaNotifier *notifier = clientNotifier->getNotifier();

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

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

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

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

        QTest::qWait(waitTime500ms);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

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

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entry->id());

        clientNotifier->mEntryId = 0;

        CaEntry *entryFake = new CaEntry();

        entryFake->setText("Text");

        entryFake->setEntryTypeName("TypeName");

        bool removed = mService->removeEntry(*entryFake);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QCOMPARE(clientNotifier->mEntryId, 0);

        QCOMPARE(removed, FALSE);

        // cleanup

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

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

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

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

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        mService->removeEntry(entry->id());

        delete entryFake;

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestRemoveEntryIdChangeTypeNotifierFake()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);

        CaNotifier *notifier = clientNotifier->getNotifier();

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

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

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

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

        QTest::qWait(waitTime500ms);

        CaEntry item;

        item.setText("Text");

        item.setEntryTypeName("TypeName");

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

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QVERIFY(clientNotifier->mEntryId > 0);

        QCOMPARE(clientNotifier->mEntryId, entry->id());

        clientNotifier->mEntryId = 0;

        bool removed = mService->removeEntry(entryIdFake);

        QTest::qWait(waitTime1sec);

        QCOMPARE(clientNotifier->mChangeType, AddChangeType);

        QCOMPARE(clientNotifier->mEntryId, 0);

        QCOMPARE(removed, FALSE);

        // cleanup

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

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

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

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

        QTest::qWait(waitTime500ms);

        delete clientNotifier;

        mService->removeEntry(entry->id());

    }

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARKEND;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

}

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

//

void TestCaClient::TestRemoveEntriesChangeTypeNotifier()

{

#ifdef Q_OS_SYMBIAN

#ifdef UT_MEMORY_CHECK

// __UHEAP_MARK;

#endif//UT_MEMORY_CHECK

#endif//Q_OS_SYMBIAN

    {

        CaEntry item1;

        item1.setText("Text");

        item1.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);

        QTest::qWait(waitTime1sec);

        CaEntry item2;

        item2.setText("Text");

        item2.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);

        QTest::qWait(waitTime1sec);

        CaEntry item3;

        item3.setText("Text");

        item3.setEntryTypeName("TypeName");

        QSharedPointer<CaEntry> entry3 = mService->createEntry(item3);

        QTest::qWait(waitTime1sec);

        CaEntry item4;

        item4.setText("Text");

        item4.setEntryTypeName("TypeName");