/*!

* Copyright (c) 2009-2010 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:  Unit tests for PhoneIndicatorController.

*

*/

#include <QtTest/QtTest>

#include <QtGui>

#include <HbGlobal>

#include <HbMenu>

#include <mockservice.h>

#include <QByteArray>

#include <QKeyEvent>

#include <QSignalSpy>

#include <HbApplication>

#include <xqcallinfo.h>

#include <callinformation.h>

#include <MediatorDomainUIDs.h>

#include <telinformationpskeys.h>

#include <coreapplicationuisdomainpskeys.h>

#include <ccallinfoiter.h>

#include <keyguardaccessapi.h>

#include <LogsDomainCRKeys.h>

#include <ctsydomaincrkeys.h>

#include "phonevisibilityhandler.h"

#include "phoneuiqtviewif_stub.h"

#include <logsmodel.h>

#include "phoneindicatorcontroller.h"

#include "phoneindicators.h"

#include "hbindicatorstubhelper.h"

extern bool m_logsModelCreated;

extern bool m_serviceCreated;

extern bool m_aiwRequestCreated;

extern bool m_aiwRequestSended;

extern int m_modelMaxSize;

extern bool m_bringToForegroundCalled;

#define PHONE_QT_INDICATOR_CONTROLLER_TEST_MAIN(TestObject) \

int main(int argc, char *argv[]) \

{ \

    HbApplication app(argc, argv); \

    TestObject tc; \

    QResource::registerResource("../hbcore.rcc"); \

    int ret = QTest::qExec(&tc, argc, argv); \

    /* Core dump if HbIconLoader instance is not destroyed before the application instance. */ \

    /* HbIconLoader uses QCoreApplication::aboutToQuit() signal to destroy itself. */ \

    /* app.exec() where the signal is normally emitted is not called here. */ \

    /* So, invoking the signal explicitly. */ \

    QMetaObject::invokeMethod(&app, "aboutToQuit", Qt::DirectConnection); \

    return ret; \

}

class UT_PhoneIndicatorController : public QObject, public MockService

{

    Q_OBJECT

public:

    UT_PhoneIndicatorController();

    virtual ~UT_PhoneIndicatorController();

signals:

    void valueChanged(const XQSettingsKey &key ,const QVariant &value);

    void userActivated(QString,QVariantMap data);

    void rowsInserted(const QModelIndex &, int, int );

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void testIndicatorController();

    void t_setActiveCallData();

    void t_clearActiveCallData();

    void t_enableActiveCallIndicator();

    void t_updateMissedCallIndicator();

    void t_updateDivertIndicator();

    void t_setMissedallIndicatorData();

    void t_handleInteraction(); 

    void t_handleInteraction1(); 

    void t_handleInteraction2(); 

private:

    PhoneUIQtViewIFStub *mPhoneUIQtViewIFStub;

    PhoneVisibilityHandler *m_handler;

    PhoneIndicatorController *m_phoneIndicatorController; // class under test

    HbMenu m_menu;  

};

UT_PhoneIndicatorController::UT_PhoneIndicatorController():

        m_phoneIndicatorController(NULL)

{

}

UT_PhoneIndicatorController::~UT_PhoneIndicatorController()

{

    delete m_phoneIndicatorController;

}

void UT_PhoneIndicatorController::initTestCase()

{

    mPhoneUIQtViewIFStub = new PhoneUIQtViewIFStub();

    m_handler = new PhoneVisibilityHandler(*mPhoneUIQtViewIFStub, this);

    m_phoneIndicatorController = new PhoneIndicatorController(*m_handler, this);

}

void UT_PhoneIndicatorController::cleanupTestCase()

{

    delete m_phoneIndicatorController;

    delete m_handler;

    delete mPhoneUIQtViewIFStub;

}

void UT_PhoneIndicatorController::init()

{

}

void UT_PhoneIndicatorController::cleanup()

{

    reset();

}

void UT_PhoneIndicatorController::testIndicatorController()

{

    QVERIFY(m_phoneIndicatorController);

}

void UT_PhoneIndicatorController::t_setActiveCallData()

{

    QVERIFY(m_phoneIndicatorController->m_cli.isEmpty());

    m_phoneIndicatorController->setActiveCallData();

    QVERIFY(!m_phoneIndicatorController->m_cli.isEmpty());

}

void UT_PhoneIndicatorController::t_clearActiveCallData()

{

    m_phoneIndicatorController->clearActiveCallData();

    QVERIFY(m_phoneIndicatorController->m_cli.isEmpty());

}

void UT_PhoneIndicatorController::t_enableActiveCallIndicator()

{   

    m_phoneIndicatorController->enableActiveCallIndicator();

    QVERIFY(!HbIndicatorStubHelper::indicatorActive());

    m_phoneIndicatorController->setActiveCallData();

    m_phoneIndicatorController->enableActiveCallIndicator();

    QVERIFY(HbIndicatorStubHelper::indicatorActive());

    m_phoneIndicatorController->disableActiveCallIndicator();

    QVERIFY(!HbIndicatorStubHelper::indicatorActive());    

}

void UT_PhoneIndicatorController::t_updateMissedCallIndicator()

{

    QObject::connect( this, SIGNAL( valueChanged(const XQSettingsKey & ,const QVariant &)),

            m_phoneIndicatorController, SLOT(updateMissedCallIndicator(XQSettingsKey, 

                    QVariant)));

    const XQSettingsKey key(XQSettingsKey::TargetCentralRepository, 

            KCRUidLogs.iUid, 

            KLogsNewMissedCalls );

    emit valueChanged(key, QVariant(1));

    QVERIFY(m_logsModelCreated); 

    QVERIFY(m_modelMaxSize = 2);

}

void UT_PhoneIndicatorController::t_updateDivertIndicator()

{

    QObject::connect( this, SIGNAL( valueChanged(const XQSettingsKey & ,const QVariant &)),

                m_phoneIndicatorController, SLOT(updateDivertIndicator(XQSettingsKey, 

                        QVariant)));

    const XQSettingsKey key(XQSettingsKey::TargetCentralRepository, 

            KCRUidCtsyCallForwardingIndicator.iUid, 

            KCtsyUnconditionalCFStatus);

    int x(KCFVoiceForwarded);

    emit valueChanged( key, QVariant(x).toByteArray());

    QVERIFY(HbIndicatorStubHelper::indicatorActive());

    emit valueChanged( key, QVariant(0).toByteArray());

    QVERIFY(!HbIndicatorStubHelper::indicatorActive());

}

void UT_PhoneIndicatorController::t_setMissedallIndicatorData()

{

    // TODO:

    QObject::connect( this, SIGNAL(rowsInserted(const QModelIndex &, int, int )),

                this, SLOT(setMissedallIndicatorData()));  

    QModelIndex index; 

    emit(rowsInserted(index,0,0));

}

void UT_PhoneIndicatorController::t_handleInteraction()

{

    QObject::connect(this,SIGNAL(userActivated(QString,QVariantMap)),

            m_phoneIndicatorController,SLOT(handleInteraction(QString,QVariantMap)));

    QVariantMap data;

    data.insert(QLatin1String("interaction"), OpenMissedCallView);

    emit userActivated(QString(),data);

    QVERIFY(m_serviceCreated);

    QVERIFY(m_aiwRequestCreated);

    QVERIFY(m_aiwRequestSended);

}

void UT_PhoneIndicatorController::t_handleInteraction1()

{

    QObject::connect(this,SIGNAL(userActivated(QString,QVariantMap)),

                    m_phoneIndicatorController,SLOT(handleInteraction(QString,QVariantMap)));

    QVariantMap data;

    data.insert(QLatin1String("interaction"), OpenCallUi);

    emit userActivated(QString(),data);

    QVERIFY(m_bringToForegroundCalled);

}

void UT_PhoneIndicatorController::t_handleInteraction2()

{

    QObject::connect(this,SIGNAL(userActivated(QString,QVariantMap)),

                m_phoneIndicatorController,SLOT(handleInteraction(QString,QVariantMap)));

    QVariantMap data;

    data.insert(QLatin1String("interaction"), OpenDiverSettingsView);

    emit userActivated(QString(),data);

    QVERIFY(m_serviceCreated);

    QVERIFY(m_aiwRequestCreated);

    QVERIFY(m_aiwRequestSended);

}

PHONE_QT_INDICATOR_CONTROLLER_TEST_MAIN(UT_PhoneIndicatorController)

#include "unit_tests.moc"