/*

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

*

*/

#include <QtTest/QtTest>

#include "t_tsservicesprovider.h"

#include "tsservicesproviderconfig.h"

#include "tsservice.h"

#include "tsservicesprovider.h"

#include "tsserviceobserver.h"

class QtModel: public QObject

{

    QList<QVariantHash> taskList() const

    {

        return QList<QVariantHash>();

    }

    QList<QVariantHash> taskList(int limit) const

    {

        Q_UNUSED(limit);

        return QList<QVariantHash>();

    }

    bool openTask(const QVariant &/*id*/){return true;};

    bool closeTask(const QVariant &/*id*/){return true;};

};

void T_TsServiceProvider::testProvider()

{

    CTsServiceProvider *provider(0);

    CTsServiceProviderConfig* config(0);

    //test provider with different amount of data

    int errNo;

    const int maxDataCount(4);

    for(TInt dataCount(0); dataCount < maxDataCount; ++dataCount) {

        config = CTsServiceProviderConfig::NewLC(dataCount);

        provider = CTsServiceProvider::NewL(*config);

        CleanupStack::PopAndDestroy(config);

        QVERIFY(dataCount == provider->count());

        for(TInt dataProviderIter(0); dataProviderIter < provider->count(); ++dataProviderIter) {

            MTsModel& model((*provider)[dataProviderIter]);

            //we dont verify data. just try to retrieve it. model can leave but shouldn't panic

            for (TInt dataIter(0); dataIter < model.count(); ++dataIter) {

                TRAP_IGNORE(model.itemL(dataIter).keyL());

                TRAP_IGNORE(model.itemL(dataIter).displayNameL());

                TRAP_IGNORE(model.itemL(dataIter).iconHandleL());

                TRAP_IGNORE(model.itemL(dataIter).isActiveL());

                TRAP_IGNORE(model.itemL(dataIter).isClosableL());

                TRAP_IGNORE(model.itemL(dataIter).timestampL());

                TRAP_IGNORE(model.itemL(dataIter).launchL());

                TRAP_IGNORE(model.itemL(dataIter).closeL());

            }

            TRAP(errNo, model.itemL(model.count()).keyL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).displayNameL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).iconHandleL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).isActiveL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).isClosableL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).timestampL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).launchL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count()).closeL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).keyL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).displayNameL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).iconHandleL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).isActiveL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).isClosableL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).timestampL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).launchL());

            QVERIFY(KErrNone != errNo);

            TRAP(errNo, model.itemL(model.count() + 1).closeL());

            QVERIFY(KErrNone != errNo);

        }

        delete provider;

    }

}

void T_TsServiceProvider::testService()

{

    int errNo, maxNotifications(20);

    CTsService* service;

    mNotyfications = 0;

    TRAP(errNo, service = CTsService::NewLC(0));

    QVERIFY(KErrNone != errNo);

    TRAP(errNo, 

    service = CTsService::NewLC(new QtModel());

    service->setObserver(0);

    service->DataChanged();

    if(0 != mNotyfications){

        User::Leave(KErrCorrupt);

    }

    service->setObserver(this);

    for(int iter(0); iter < maxNotifications; ++iter) {

        service->DataChanged();

        if(iter + 1 != mNotyfications){

            User::Leave(KErrCorrupt);

        }

    }

    CleanupStack::PopAndDestroy(service);

    );//TRAP

    QVERIFY(KErrNone == errNo);

}

void T_TsServiceProvider::testServiceObserver()

{

    TsServiceObserver observer(*this);

    QObject::connect(this,

                     SIGNAL(someSignal()),

                     &observer,

                     SLOT(dataChanged()));

    QTimer::singleShot(5000, &mLoop, SLOT(quit()));

    mNotyfications = 0;

    emit someSignal();

    if(0 == mNotyfications && !mLoop.isRunning()) {

        mLoop.exec();

    }

    QVERIFY(1 == mNotyfications);

}

void T_TsServiceProvider::dataChanged(MTsModel &/*model*/)

{

    ++mNotyfications;

}

void T_TsServiceProvider::dataChanged(const TTsModelItem &/*item*/)

{

}

void T_TsServiceProvider::DataChanged()

{

    ++mNotyfications;

    if(mLoop.isRunning()) {

        mLoop.quit();

    }

}

QTEST_MAIN(T_TsServiceProvider)