/*!

* 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:  Unit tests for PhoneUIQtViewAdapter.

*

*/

#include <QtTest/QtTest>

#include <QtGui>

#include <QList>

#include <QKeyEvent>

#include <hbapplication.h>

#include <QSignalSpy>

#include <hbmainwindow.h>

#include <phoneappcommands.hrh>

#include <hbmenu.h>

//#include <hbglobal_p.h>

#include "phoneuiqtviewadapter.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamaudiooutput.h"

#include "phoneuiqtviewif.h"

#include "tphonecmdparamcallstatedata.h"

#include "tphonecmdparamcallheaderdata.h"

#include "tphonecmdparamemergencycallheaderdata.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparamringtone.h"

#include "tphonecmdparamkeycapture.h"

#include "pevirtualengine.h"

#include "bubblemanagerif.h"

#include "phoneresourceids.h"

#include "phonebubblewrapper.h"

#include "phoneuiqtbuttonscontroller.h"

#include "tphonecmdparamglobalnote.h"

#include "tphonecmdparamstring.h"

#include "phoneindicatorcontroller.h"

extern int m_phoneButtonFlags;

extern bool m_EPhoneViewMuteRingToneOnAnswer_called;

extern bool m_EPhoneViewStopRingTone_called;

extern bool m_EPhoneViewMuteRingTone_called;

extern bool m_EPhoneViewPlayRingTone_called;

extern bool m_showGlobalNoteCalled;

extern bool m_removeCallHeaderCalled;

extern bool m_addToConferenceBubbleCalled;

extern bool m_showQueryCalled;

extern bool m_removeDtmfNoteCalled;

extern bool m_removeNoteCalled;

extern bool m_removeQueryCalled;

extern bool m_showNoteCalled;

extern bool m_removeGlobalWaitNoteCalled;

extern bool m_ordinalPositionCalled;

extern bool m_sendToBackgroundCalled;

#define PHONE_QT_VIEW_ADAPTER_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; \

    }

// Own assert initialization  

/*void qt_assert(const char *assertion, const char *file, int line)

{

    qDebug () << "View test assert FAIL";

}*/

class TestPhoneUIQtViewAdapter : public QObject, public PhoneUIQtViewIF, public BubbleManagerIF

{

    Q_OBJECT

public:

    TestPhoneUIQtViewAdapter();

    virtual ~TestPhoneUIQtViewAdapter();

    // From PhoneUIQtViewIF

    BubbleManagerIF& bubbleManager ();

    void addBubbleCommand (int bubbleId, const PhoneAction& action);

    void clearBubbleCommands (int bubbleId);

    void addParticipantListAction(

            int commandId,  

            const QString &text, 

            const HbIcon &icon);

    void clearParticipantListActions();

    void hideToolbar () { };

    void showToolbar () { m_showToolbarCalled = true; };

    void setToolbarActions (const QList<PhoneAction*>& actions) {m_toolbarActionCount = actions.count(); };

    int volumeSliderValue () { m_volumeSliderValueCalled = true; return 5; };

    void removeVolumeSlider () { m_removeVolumeSliderCalled = true; };

    void setVolumeSliderValue (

            int value, 

            int , 

            int , 

            int  ) { m_setVolumeSliderValueCalled = true; m_volumeSliderValue = value; };

    void setExpandAction(int bubbleId, int commandId) {m_expandAction[bubbleId]=commandId;};

    void removeExpandAction(int ) {};

    void showDialpad() {m_showDialpadCalled = true;};  

    void hideDialpad() {m_hideDialpadCalled = true;};  

    bool isDialpadVisible() 

        {m_dialpadVisibilityCalled = true;

    return m_isDialpadVisible; }

    QString dialpadText() {return m_dialpadText;};

    void clearAndHideDialpad() { m_clearAndHideDialpadCalled = true;};

    void bringToForeground() {};

    void setMenuActions(const QList<PhoneAction*>& ) { m_setMenuActionsCalled = true;};

    void shutdownPhoneApp() {};

    void setBackButtonVisible(bool ) {};

    HbMenu &menuReference(){return m_menu;};

    void captureKey(Qt::Key key, bool capture) {

        m_capturedKey = key;

        m_captured = capture;};

    // From BubbleManagerIF

    void startChanges () { m_startChangesCalled=true; };

    void endChanges () { m_endChangesCalled=true; };

    int createCallHeader () { return 0; };

    void removeCallHeader (int ) {};

    void setState (int , PhoneCallState ) {};

    void setLabel ( 

        int , 

        const QString& , 

        Qt::TextElideMode ) {};

    void setCli (int , 

                 const QString& , 

                 Qt::TextElideMode ) {};

    void updateCLI ( 

        int , 

        const QString& , 

        Qt::TextElideMode ) {};

    void setSecondaryCli ( 

        int , 

        const QString& , 

        Qt::TextElideMode ) {};

    void setCallTime (int , const QString& ) {};

    void updateCallTime (int bubbleId, const QString& callTime) { m_updateCallTimeCalled=true; m_int=bubbleId; m_string=callTime; };

    void setCallObjectImage (int , const QString &) {};

    void setCallObjectFromTheme (int ) {};

    void setCallObjectText (int , const QString &) {};

    void setCallFlags (int , int ) {};

    void setCallFlag (int , PhoneCallFlags , bool ) {};

    void setNumberType (int , PhoneNumberType ) {};

    void updateCallHeaderText( 

        int , 

        const QString &, 

        const QString &, 

        Qt::TextElideMode ) {};

    void setPhoneMuted (bool muted) { m_setPhoneMutedCalled = muted; };

    int createConference (int , int ) { return 1; };

    void removeConference () {};

    void addRowToConference (int ) {};

    void removeRowFromConference (int ) {};

    int conferenceRowCount () const { return 2; };

    void setSelectionInConference (int ) {};

    void setSelectionIdInConference (int ) {};

    int selectionInConference () const { return 0; };

    int selectionIdInConference () const { return 0; };

    void moveHighlightOneUpInConference () {};

    void moveHighlightOneDownInConference () {};

    void setExpandedConferenceCallHeader (bool ) { m_ExpandConferenceCalled = true; };

    bool isConferenceExpanded () const { return false; };

    int shownHeaderCount () const { return 1; };

    void setParticipantListCli (int , ParticipantListCli ) {};

    void addAction (int , HbAction *) {};

    void clearActions (int ) {};

    QGraphicsWidget* graphicsWidgetForAction (HbAction *) const { return 0;};

    void addParticipantListAction (HbAction *) {};

    int expandedBubble() const { return 1; };

    void setExpandAction(int , HbAction* ) {};

    void setBubbleSelectionDisabled(bool ) {};

    void setRestrictedMode(bool ) {};

signals:

    void dialpadAboutToClose();

    void keyPressReleased(QKeyEvent *event);

    void windowActivated();

    void windowDeactivated();

public slots:

    void initTestCase ();

    void cleanupTestCase ();

    void init ();

    void cleanup ();

private slots:

    void testEPhoneViewSetTopApplicationCommand ();

    void testEPhoneViewSetIdleTopApplicationCommand ();

    void testEPhoneViewUpdateCallHeaderCallDurationCommand ();

    void testEPhoneViewCreateCallHeaderCommand ();

    void testEPhoneViewCreateEmergencyCallHeader ();

    void testEPhoneViewUpdateBubble ();

    void testEPhoneViewUpdateCallHeaderRemoteInfoData ();

    void testEPhoneViewUpdateCallHeaderRemoteInfoDataAndLabel();

    void testCallIdByState ();

    void testSetToolbarButtons ();

    void testHoldFlag ();

    void testEPhoneViewHideNaviPaneAudioVolume ();

    void testEPhoneViewSetNaviPaneAudioVolume ();

    void testEPhoneViewGetAudioVolumeLevel ();

    void testEPhoneViewActivateMuteUIChanges ();

    void testEPhoneViewGetCountOfActiveCallss ();

    void testExecuteCommandLwithCmdId ();

    void testExecuteCommandLwithCmdIdAndCallId ();

    void testExecuteCommandLwithCmdIdAndCmdParam ();

    void testSetTouchButtons ();

    void testCreateConferenceBubble ();

    void testHandleCommandL ();

    void testGetSelectedConferenceMember ();

    void testSetAudioPath ();

    void testMuteRingToneOnAnswer ();

    void testStopRingTone ();

    void testMuteRingTone ();

    void testPlayRingTone ();

    void testShowGlobalNote ();

    void testSetExpandActions();

    void testShowDialpad ();

    void testDialpadVisibility ();

    void removeAllCallHeaders ();

    void testRemoveDialpad();

    void testGetDialpadStringLength();

    void testGetDialpadString();

    void testAddToConference();

    void testSetConferenceExpanded();

    void testSetMenuActions();

    void testNoteController();

    void testHsToForegroundAfterCall();

    void testCipheringInfoChange();

    void testSetHidden();

    void testBeginEndUiUpdate();

    void testIndicatorController();

    void testOpenLogs();

    void testSetFlags();

    void testCaptureEndKey();

private:

    PhoneUIQtViewAdapter *m_adapter; // class under test

    bool m_showToolbarCalled;

    bool m_updateCallTimeCalled;

    int m_int;

    QString m_string;

    HbAction *m_action;

    int  m_toolbarActionCount;

    bool m_startChangesCalled;

    bool m_endChangesCalled;

    bool m_volumeSliderValueCalled;

    bool m_removeVolumeSliderCalled;

    bool m_setVolumeSliderValueCalled;

    int m_volumeSliderValue;

    bool m_setPhoneMutedCalled;

    QMap<int, QList<int> *> m_actionMap;

    QMap<int,int> m_expandAction;

    bool m_showDialpadCalled;

    bool m_hideDialpadCalled;

    bool m_dialpadVisibilityCalled;

    bool m_clearAndHideDialpadCalled;

    bool m_ExpandConferenceCalled;

    bool m_setMenuActionsCalled;

    bool m_isDialpadVisible;

    QString m_dialpadText;

    HbMenu m_menu;

    bool m_captured;

    Qt::Key m_capturedKey;

    QList<int> mParticipantListActions;

};

TestPhoneUIQtViewAdapter::TestPhoneUIQtViewAdapter () :

    m_isDialpadVisible(false),

    m_dialpadText("1234567")

{

}

TestPhoneUIQtViewAdapter::~TestPhoneUIQtViewAdapter ()

{

}

void TestPhoneUIQtViewAdapter::initTestCase ()

{

    m_adapter = new PhoneUIQtViewAdapter (*this);

}

void TestPhoneUIQtViewAdapter::cleanupTestCase ()

{

    delete m_adapter;

}

void TestPhoneUIQtViewAdapter::init ()

{

    m_startChangesCalled = false;

    m_endChangesCalled = false;

    m_setCipheringCalled = false;

}

void TestPhoneUIQtViewAdapter::cleanup ()

{

}

BubbleManagerIF& TestPhoneUIQtViewAdapter::bubbleManager ()

{

    return *this;

}

void TestPhoneUIQtViewAdapter::addBubbleCommand (

        int bubbleId, const PhoneAction& action)

{

    if (m_actionMap.keys().contains(bubbleId)) {

        m_actionMap.value(bubbleId)->append(action.command());

    } else {

        QList<int> *list = new QList<int>();

        list->append(action.command());

        m_actionMap.insert( bubbleId, list);

    }

}

void TestPhoneUIQtViewAdapter::clearBubbleCommands (int bubbleId)

{

    if (m_actionMap.keys().contains(bubbleId)) {

        QList<int> *list = m_actionMap.value(bubbleId);

        list->clear();

        delete list;

        m_actionMap.remove(bubbleId);

    }

}

void TestPhoneUIQtViewAdapter::addParticipantListAction(

    int commandId,

    const QString& , 

    const HbIcon& )

{

    mParticipantListActions.append(commandId);

}

void TestPhoneUIQtViewAdapter::clearParticipantListActions()

{

    mParticipantListActions.clear();

}

void TestPhoneUIQtViewAdapter::testEPhoneViewSetTopApplicationCommand ()

{

    TPhoneCmdParamInteger intParam;

    intParam.SetInteger (12345);

    m_adapter->ExecuteCommandL (EPhoneViewSetTopApplication, &intParam);

}

void TestPhoneUIQtViewAdapter::testEPhoneViewSetIdleTopApplicationCommand ()

{

    m_adapter->ExecuteCommandL (EPhoneViewSetIdleTopApplication);

}

void TestPhoneUIQtViewAdapter::testEPhoneViewUpdateCallHeaderCallDurationCommand ()

{

    TPhoneCmdParamInteger time;

    time.SetInteger(73);

    m_adapter->ExecuteCommandL (EPhoneViewUpdateCallHeaderCallDuration, 1, &time);	

    QCOMPARE (m_updateCallTimeCalled, true);

    QCOMPARE (m_int, 2);

    QVERIFY (m_string == "0:01:13");

}

void TestPhoneUIQtViewAdapter::testEPhoneViewCreateCallHeaderCommand ()

{

    TPhoneCmdParamCallHeaderData callHeader;

    callHeader.SetDiverted (ETrue);

    callHeader.SetCallState (3);

    callHeader.SetLabelText (_L("Foo"));

    callHeader.SetCLIText (_L("Bar"), TPhoneCmdParamCallHeaderData::ERight);

    callHeader.SetCNAPText (_L("CNAP"), TPhoneCmdParamCallHeaderData::ERight);

    callHeader.SetCallType (3);

    callHeader.SetCipheringIndicatorAllowed(true);

    callHeader.SetCiphering(false);

    m_adapter->ExecuteCommandL (EPhoneViewCreateCallHeader, 2, &callHeader);

    QVERIFY (m_startChangesCalled == true);

    QVERIFY (m_createCallHeaderCalled == true);

    QCOMPARE (m_createCallHeaderInt, 2);

    QVERIFY (m_setStateCalled == true); 

    QCOMPARE (m_setStateCallId, 2);

    QCOMPARE (m_setStateBubbleId, 1);

    QCOMPARE (m_setStateCallState, 3); 

    QVERIFY (m_setLabelCalled == true);

    QString labelText = QString::fromUtf16 (m_setLabelText->Ptr (), m_setLabelText->Length ());

    QCOMPARE (m_setLabelBubbleId, 1);

    QCOMPARE (labelText, QString("Foo"));

    QVERIFY (m_setCliCalled == true);

    QString cliText = QString::fromUtf16 (m_setCliText->Ptr (), m_setCliText->Length ());

    QCOMPARE (m_setCliBubbleId, 1);

    QCOMPARE (cliText, QString("Bar"));

    QVERIFY (m_setSecondaryCliCalled == true);

    QString cnapText = QString::fromUtf16 (m_setSecondaryCliText->Ptr (), m_setSecondaryCliText->Length ());

    QCOMPARE (m_setSecondaryCliBubbleId, 1);

    QCOMPARE (cnapText, QString("CNAP"));

    QVERIFY (m_setCallTypeCalled == true);

    QCOMPARE (m_setCallTypeBubbleId, 1);

    QCOMPARE (m_setCallTypeType, 3);

    QVERIFY (m_setDivertCalled == true);

    QVERIFY (m_bubblewrapperbool == true);

    QCOMPARE (m_bubblewrapperint, 1);

    QVERIFY (m_setCipheringCalled == true);

    QVERIFY (m_endChangesCalled == true);

    QVERIFY (m_setActiveCallCalled == true);

}

void TestPhoneUIQtViewAdapter::testEPhoneViewCreateEmergencyCallHeader ()

{

    TPhoneCmdParamEmergencyCallHeaderData callHeader;

    callHeader.SetLabelText (_L("Attempting"));

    callHeader.SetHeaderText (_L("emergency") );

    m_adapter->ExecuteCommandL (EPhoneViewCreateEmergencyCallHeader, 2, &callHeader);

    callHeader.SetCipheringIndicatorAllowed(true);

    callHeader.SetCiphering(false);    

    QVERIFY (m_startChangesCalled == true);

    QVERIFY (m_createCallHeaderCalled == true);

    QCOMPARE (m_createCallHeaderInt, 2);

    QVERIFY (m_setLabelCalled == true);

    QString labelText = QString::fromUtf16 (m_setLabelText->Ptr (), m_setLabelText->Length ());

    QCOMPARE (m_setLabelBubbleId, 1);

    QCOMPARE (labelText, QString("Attempting"));

    QVERIFY (m_setCliCalled == true);

    QString cliText = QString::fromUtf16 (m_setCliText->Ptr (), m_setCliText->Length ());

    QCOMPARE (m_setCliBubbleId, 1);

    QCOMPARE (cliText, QString("emergency"));

    QVERIFY (m_setCipheringCalled == true);

    QVERIFY (m_endChangesCalled == true);

    QVERIFY (m_setActiveCallCalled == true);

}

void TestPhoneUIQtViewAdapter::testEPhoneViewUpdateBubble ()

{

    // Bubble id will return -1

    m_bubble_id = -1;

    TPhoneCmdParamCallHeaderData callHeader;

    callHeader.SetCallState (2);

    callHeader.SetLabelText (_L("Foo2"));

    callHeader.SetDiverted (EFalse);

    m_adapter->ExecuteCommandL (EPhoneViewUpdateBubble, 3, &callHeader);

    QVERIFY (m_startChangesCalled == false);

    //Test with available bubble id

    m_bubble_id = -2;

    m_adapter->ExecuteCommandL (EPhoneViewUpdateBubble, 3, &callHeader);

    QVERIFY (m_startChangesCalled == true);

    QVERIFY (m_bubbleIdCalled == true);

    QCOMPARE (m_bubbleIdCallId, 3);

    QVERIFY (m_setStateCalled == true); 

    QCOMPARE (m_setStateCallId, 3);

    QCOMPARE (m_setStateBubbleId, 2);

    QCOMPARE (m_setStateCallState, 2); 

    QVERIFY (m_setLabelCalled == true);

    QString labelText = QString::fromUtf16 (m_setLabelText->Ptr (), m_setLabelText->Length ());

    QCOMPARE (m_setLabelBubbleId, 2);

    QCOMPARE (labelText, QString("Foo2"));

    QVERIFY (m_setDivertCalled == true);

    QVERIFY (m_bubblewrapperbool == false);

    QCOMPARE (m_bubblewrapperint, 2);

    QVERIFY (m_endChangesCalled == true);	

}

void TestPhoneUIQtViewAdapter::testEPhoneViewUpdateCallHeaderRemoteInfoData ()

{

    // Bubble id will return -1

    m_bubble_id = -1;

    TPhoneCmdParamCallHeaderData callHeader;

    callHeader.SetCLIText (_L("Bar3"), TPhoneCmdParamCallHeaderData::ERight);

    callHeader.SetCNAPText (_L("CNAP3"), TPhoneCmdParamCallHeaderData::ERight);

    callHeader.SetDiverted (ETrue);

    m_adapter->ExecuteCommandL (EPhoneViewUpdateCallHeaderRemoteInfoData, 4, &callHeader);

    QVERIFY (m_startChangesCalled == false);

    //Test with available bubble id

    m_bubble_id = -2;

    m_adapter->ExecuteCommandL (EPhoneViewUpdateCallHeaderRemoteInfoData, 4, &callHeader);

    QVERIFY (m_startChangesCalled == true);