/*

* 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 <PsetContainer.h>

#include <PsetCallDiverting.h>

#include <MPsetDivertObs.h>

#include "ut_psetcalldivertingwrapper.h"

#include "mock_cphcltemergencycall.h"

#include "testutilities.h"

#define private public

#include "psetcalldivertingwrapper.h"

#include "psetcalldivertingwrapper_p.h"

class DivertObserver : public MPsetDivertObserver

{

    void HandleDivertingChangedL( 

        const TCallDivertSetting& aSetting, TBool aPlural) 

    {

        Q_UNUSED(aSetting);

        Q_UNUSED(aPlural);

    }

    void HandleDivertingStatusL(CMobilePhoneCFList& aSetting, TBool aPlural) 

    {

        Q_UNUSED(aSetting);

        Q_UNUSED(aPlural);

    }

    void HandleDivertingErrorL(TInt aReason) 

    {

        Q_UNUSED(aReason);

    }

    void HandleCFRequestingL(TBool aOngoing, 

        TBool aInterrupted) 

    {

        Q_UNUSED(aOngoing);

        Q_UNUSED(aInterrupted);

    }

    void SetEngineContact(MPsetCallDiverting* aDivertEngine) 

    {

        Q_UNUSED(aDivertEngine);

    }

};

/*!

  UT_PSetCallDivertingWrapper::UT_PSetWrapperCallDiverting

 */

UT_PSetCallDivertingWrapper::UT_PSetCallDivertingWrapper() 

    : mWrapper(NULL), mSetContainerMock(NULL) 

{

}

/*!

  UT_PSetCallDivertingWrapper::~UT_PSetWrapperCallDiverting

 */

UT_PSetCallDivertingWrapper::~UT_PSetCallDivertingWrapper()

{

    delete mWrapper;

    delete mSetContainerMock;

    mPsetCallDivertingMock = NULL;

}

/*!

  UT_PSetCallDivertingWrapper::init

 */

void UT_PSetCallDivertingWrapper::init()

{

    initialize();

    CPhCltEmergencyCallMock::iSimulateEmergencyNumberMatch = false;

    mSetContainerMock = new CPsetContainer();

    RMobilePhone dummyHandle;

    DivertObserver dummyObsever;

    QT_TRAP_THROWING(mPsetCallDivertingMock 

        = CPsetCallDiverting::NewL(dummyObsever, dummyHandle));

    expect("CPsetContainer::CreateCFObjectL").returns(mPsetCallDivertingMock);

    // Wrapper takes ownership of callDivertingMock during construction. 

    // Mock must be deleted here if exception happens during construction.

    QScopedPointer<CPsetCallDiverting> divertingMockPtr(mPsetCallDivertingMock);

    mWrapper = new PSetCallDivertingWrapper(*mSetContainerMock, NULL);

    divertingMockPtr.take();

}

/*!

  UT_PSetCallDivertingWrapper::cleanup

 */

void UT_PSetCallDivertingWrapper::cleanup()

{

    reset();

    delete mWrapper;

    mWrapper = NULL;

    delete mSetContainerMock;

    mSetContainerMock = NULL;

    mPsetCallDivertingMock = NULL;

}

/*!

  UT_PSetCallDivertingWrapper::t_setCallDivertingWithValidParameters

 */

void UT_PSetCallDivertingWrapper::t_setCallDivertingWithValidParameters()

{

    PSCallDivertingCommand divertingCmd;

    divertingCmd.iCondition = DivertConditionUnconditional;

    divertingCmd.iSetting = RegisterDiverting;

    divertingCmd.iStatus = DivertingStatusUnknown;

    divertingCmd.iServiceGroup = ServiceGroupVoice;

    divertingCmd.iNumber = "1234567890";

    divertingCmd.iNoReplyTimer = 0;

    TCallDivertSetting expectedParam;

    expectedParam.iCondition = EDivertConditionUnconditional;

    expectedParam.iSetting = ERegisterDiverting;

    expectedParam.iStatus = EDivertingStatusUnknown;

    expectedParam.iServiceGroup = EServiceGroupVoice;

    expectedParam.iNumber 

        = TPtrC16(reinterpret_cast<const TUint16*>(divertingCmd.iNumber.utf16()));

    expectedParam.iNoReplyTimer 

        = static_cast<TInt>(divertingCmd.iNoReplyTimer);

    TBool isVmbx = EFalse;

    expect("CPsetCallDiverting::SetDivertingL").

        with(expectedParam, ETelephony, isVmbx);

    mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_setCallDivertingWithInvalidNumber

 */

void UT_PSetCallDivertingWrapper::t_setCallDivertingWithInvalidNumber()

{

    PSCallDivertingCommand divertingCmd;

    divertingCmd.iCondition = DivertConditionUnconditional;

    divertingCmd.iSetting = RegisterDiverting;

    divertingCmd.iStatus = DivertingStatusUnknown;

    divertingCmd.iServiceGroup = ServiceGroupVoice;

    divertingCmd.iNoReplyTimer = 0;

    expect("CPsetCallDiverting::SetDivertingL").times(0);

    // DTMF digits "*#pw" are not allowed characters

    divertingCmd.iNumber = "*";

    int result = mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(result == KErrGsmSSUnknownAlphabet);

    divertingCmd.iNumber = "#";

    result = mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(result == KErrGsmSSUnknownAlphabet);

    divertingCmd.iNumber = "p";

    result = mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(result == KErrGsmSSUnknownAlphabet);

    divertingCmd.iNumber = "w";

    result = mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(result == KErrGsmSSUnknownAlphabet);

    // plus allowed only in the beginning of the number

    divertingCmd.iNumber = "++";

    result = mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(result == KErrGsmSSUnknownAlphabet);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_setCallDivertingWithEmergencyNumber

 */

void UT_PSetCallDivertingWrapper::t_setCallDivertingWithEmergencyNumber()

{

    PSCallDivertingCommand divertingCmd;

    divertingCmd.iCondition = DivertConditionUnconditional;

    divertingCmd.iSetting = RegisterDiverting;

    divertingCmd.iStatus = DivertingStatusUnknown;

    divertingCmd.iServiceGroup = ServiceGroupVoice;

    divertingCmd.iNumber = "112";

    divertingCmd.iNoReplyTimer = 0;

    expect("CPsetCallDiverting::SetDivertingL").times(0);

    CPhCltEmergencyCallMock::iSimulateEmergencyNumberMatch = ETrue;

    expect("CPhCltEmergencyCallMock::IsEmergencyPhoneNumber").returns(KErrNone);

    int result = mWrapper->setCallDiverting(divertingCmd, ETelephony);

    QVERIFY(result == KErrGsmSSIllegalOperation);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_setCallDivertingException

 */

void UT_PSetCallDivertingWrapper::t_setCallDivertingException()

{

    PSCallDivertingCommand divertingCmd;

    divertingCmd.iCondition = DivertConditionUnconditional;

    divertingCmd.iSetting = RegisterDiverting;

    divertingCmd.iStatus = DivertingStatusUnknown;

    divertingCmd.iServiceGroup = ServiceGroupVoice;

    divertingCmd.iNumber = "1234567890";

    divertingCmd.iNoReplyTimer = 0;

    expect("CPsetCallDiverting::SetDivertingL").

        willOnce(invokeWithoutArguments(this, &simulateLeaveOnMockMethodCallL));

    EXPECT_EXCEPTION(

        mWrapper->setCallDiverting(divertingCmd, ETelephony);

    )

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_getCallDivertingStatus

 */

void UT_PSetCallDivertingWrapper::t_getCallDivertingStatus()

{

    expect("CPsetCallDiverting::GetDivertingStatusL").

        with(EServiceGroupVoice, EDivertConditionUnconditional, ETelephony);

    mWrapper->getCallDivertingStatus(

        ServiceGroupVoice, DivertConditionUnconditional, ETelephony);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_getCallDivertingStatusException

 */

void UT_PSetCallDivertingWrapper::t_getCallDivertingStatusException()

{

    expect("CPsetCallDiverting::GetDivertingStatusL").

        with(EServiceGroupVoice, EDivertConditionUnconditional, ETelephony).

        willOnce(invokeWithoutArguments(this, &simulateLeaveOnMockMethodCallL));

    EXPECT_EXCEPTION(

        mWrapper->getCallDivertingStatus(

            ServiceGroupVoice, DivertConditionUnconditional, ETelephony);

    )

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_cancelProcess

 */

void UT_PSetCallDivertingWrapper::t_cancelProcess()

{

    expect("CPsetCallDiverting::CancelCurrentRequest");

    mWrapper->cancelProcess();

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_getDefaultNumbers

 */

void UT_PSetCallDivertingWrapper::t_getDefaultNumbers()

{

    expect("CPsetCallDiverting::GetDefaultNumbersL").times(1);

    QStringList defNumbers;

    mWrapper->getDefaultNumbers(defNumbers);

    // 2 numbers added in mock_psetcalldiverting.cpp

    QVERIFY(2 == defNumbers.count());

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_getDefaultNumbersException

 */

void UT_PSetCallDivertingWrapper::t_getDefaultNumbersException()

{

    expect("CPsetCallDiverting::GetDefaultNumbersL").

        willOnce(invokeWithoutArguments(this, &simulateLeaveOnMockMethodCallL));

    QStringList defNumbers;

    EXPECT_EXCEPTION(

        mWrapper->getDefaultNumbers(defNumbers);

    )

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_setNewDefaultNumber

 */

void UT_PSetCallDivertingWrapper::t_setNewDefaultNumber()

{

    expect("CPsetCallDiverting::SetNewDefaultNumberL").times(1);

    expect("CPsetCallDiverting::SwapDefaultNumberL").times(0);

    // number not added in mock_psetcalldiverting.cpp

    QString defNumber = "444444";

    mWrapper->setNewDefaultNumber(defNumber);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber

 */

void UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber()

{

    // Fail case

    expect("CVoiceMailbox::GetStoredEntry").returns(-2).times(1);

    QString defNumber;

    mWrapper->getVoiceMailBoxNumber(defNumber);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber2

 */

void UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber2()

{

    expect("CVoiceMailbox::GetStoredEntry").times(1);

    expect("CVoiceMailboxEntry::GetVmbxNumber").returns(-1).times(1);

    QString defNumber;

    mWrapper->getVoiceMailBoxNumber(defNumber);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_swapDefaultNumber

 */

void UT_PSetCallDivertingWrapper::t_swapDefaultNumber()

{

    expect("CPsetCallDiverting::SetNewDefaultNumberL").times(0);

    expect("CPsetCallDiverting::SwapDefaultNumberL").times(1);

    // same number added in mock_psetcalldiverting.cpp

    QString defNumber = "222222";

    mWrapper->setNewDefaultNumber(defNumber);

    QVERIFY(true == verify());

}

Q_DECLARE_METATYPE(PSCallDivertingCommand)

/*!

  UT_PSetCallDivertingWrapper::t_handleDivertingChanged

 */

void UT_PSetCallDivertingWrapper::t_handleDivertingChanged()

{

    qRegisterMetaType<PSCallDivertingCommand>("PSCallDivertingCommand");

    QSignalSpy spy(mWrapper, 

        SIGNAL(handleDivertingChanged(const PSCallDivertingCommand&, bool)));

    TCallDivertSetting setting;

    setting.iCondition = EDivertConditionUnconditional;

    setting.iSetting = EActivateDiverting;

    setting.iStatus = EDivertingStatusUnknown;

    setting.iServiceGroup = EServiceGroupAllTeleservices;

    setting.iNumber = KNullDesC();

    TBool plural = ETrue;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));

    setting.iCondition = EDivertConditionBusy;

    setting.iStatus = EDivertingStatusActive;

    setting.iServiceGroup = EServiceGroupVoice;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));

    setting.iCondition = EDivertConditionNoReply;

    setting.iStatus = EDivertingStatusInactive;

    setting.iServiceGroup = EServiceGroupData;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));

    setting.iCondition = EDivertConditionNotReachable;

    setting.iStatus = EDivertingStatusNotRegistered;

    setting.iServiceGroup = EServiceGroupFax;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));

    setting.iCondition = EDivertConditionAllCalls;

    setting.iStatus = EDivertingStatusNotProvisioned;

    setting.iServiceGroup = EServiceGroupFax;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));

    setting.iCondition = EDivertConditionAllConditionalCases;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));

    QCOMPARE(spy.count(), 6);

    PSCallDivertingCommand actualCmd = 

        qvariant_cast<PSCallDivertingCommand>(spy.at(0).at(0));

    QVERIFY(actualCmd.iCondition == DivertConditionUnconditional);

    QVERIFY(actualCmd.iSetting == ActivateDiverting);

    QVERIFY(actualCmd.iStatus == DivertingStatusUnknown);

    QVERIFY(actualCmd.iServiceGroup == ServiceGroupAllTeleservices);

    QVERIFY(actualCmd.iNumber == QString::fromUtf16(setting.iNumber.Ptr(),

        setting.iNumber.Length()));

    QVERIFY(spy.at(0).at(1).toBool() == true);

    actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(1).at(0));

    QVERIFY(actualCmd.iCondition == DivertConditionBusy);

    QVERIFY(actualCmd.iStatus == DivertingStatusActive);

    QVERIFY(actualCmd.iServiceGroup == ServiceGroupVoice);

    actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(2).at(0));

    QVERIFY(actualCmd.iCondition == DivertConditionNoReply);

    QVERIFY(actualCmd.iStatus == DivertingStatusInactive);

    QVERIFY(actualCmd.iServiceGroup == ServiceGroupData);

    actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(3).at(0));

    QVERIFY(actualCmd.iCondition == DivertConditionNotReachable);

    QVERIFY(actualCmd.iStatus == DivertingStatusNotRegistered);

    QVERIFY(actualCmd.iServiceGroup == ServiceGroupFax);

    actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(4).at(0));

    QVERIFY(actualCmd.iCondition == DivertConditionAllCalls);

    QVERIFY(actualCmd.iStatus == DivertingStatusNotProvisioned);

    QVERIFY(actualCmd.iServiceGroup == ServiceGroupFax);

    actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(5).at(0));

    QVERIFY(actualCmd.iCondition == DivertConditionAllConditionalCases);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallDivertingWrapper::t_handleDivertingStatus

 */

void UT_PSetCallDivertingWrapper::t_handleDivertingStatus()

{

    qRegisterMetaType<QList<PSCallDivertingStatus*> >("QList<PSCallDivertingStatus*>&");

    QSignalSpy spy(mWrapper, 

        SIGNAL(handleDivertingStatus(QList<PSCallDivertingStatus*>&, bool)));

    // With empty list

    CMobilePhoneCFList* cfList = NULL;

    QT_TRAP_THROWING(cfList = CMobilePhoneCFList::NewL());

    QScopedPointer<CMobilePhoneCFList> cfListDeleter(cfList);

    TBool plural = ETrue;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingStatusL(*cfList, plural));

    QCOMPARE(spy.count(), 1);

    QVERIFY(spy.at(0).at(1).toBool() == true);

    spy.clear();

    // With list entry

    RMobilePhone::TMobilePhoneCFInfoEntryV1 entry;

    entry.iStatus = RMobilePhone::ECallForwardingStatusNotProvisioned;

    entry.iCondition = RMobilePhone::ECallForwardingAllConditionalCases;

    cfList->AddEntryL(entry);

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingStatusL(*cfList, plural));

    QCOMPARE(spy.count(), 1);

    QList<PSCallDivertingStatus*> result = 

            *reinterpret_cast<const QList<PSCallDivertingStatus*> *>(spy.at(0).at(0).constData());

    QVERIFY(result.at(0)->iStatus == DivertingStatusNotProvisioned);

    QVERIFY(result.at(0)->iCondition == DivertConditionAllConditionalCases);

    QVERIFY(spy.at(0).at(1).toBool() == true);

    spy.clear();

    // With list, two entries

    delete cfList;

    QT_TRAP_THROWING(cfList = CMobilePhoneCFList::NewL());

    entry.iStatus = RMobilePhone::ECallForwardingStatusNotActive;

    entry.iCondition = RMobilePhone::ECallForwardingBusy;

    cfList->AddEntryL(entry); // Takes copy

    RMobilePhone::TMobilePhoneCFInfoEntryV1 entry2;

    entry2.iStatus = RMobilePhone::ECallForwardingStatusActive;

    entry2.iCondition = RMobilePhone::ECallForwardingUnconditional;

    cfList->AddEntryL(entry2);

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleDivertingStatusL(*cfList, plural));

    QCOMPARE(spy.count(), 1);

    result = *reinterpret_cast<const QList<PSCallDivertingStatus*> *>(spy.at(0).at(0).constData());

    QVERIFY(result.at(0)->iStatus == DivertingStatusInactive);

    QVERIFY(result.at(0)->iCondition == DivertConditionBusy);

    QVERIFY(result.at(1)->iStatus == DivertingStatusActive);

    QVERIFY(result.at(1)->iCondition == DivertConditionUnconditional);

    QVERIFY(spy.at(0).at(1).toBool() == true);

    spy.clear();

}

/*!

  UT_PSetCallDivertingWrapper::t_handleDivertingError

 */

void UT_PSetCallDivertingWrapper::t_handleDivertingError()

{

    QSignalSpy spy(mWrapper, SIGNAL(handleDivertingError(int)));

    QT_TRAP_THROWING(mWrapper->m_Priv->HandleDivertingErrorL(KErrGeneral));

    QCOMPARE(spy.count(), 1);

    QVERIFY(spy.at(0).at(0).toInt() == KErrGeneral);

}

/*!

  UT_PSetCallDivertingWrapper::t_handleCFRequesting

 */

void UT_PSetCallDivertingWrapper::t_handleCFRequesting()

{

    QSignalSpy spy(mWrapper, SIGNAL(handleCFRequesting(bool, bool)));

    TBool ongoing = ETrue;

    TBool interrupted = ETrue;

    QT_TRAP_THROWING(

        mWrapper->m_Priv->HandleCFRequestingL(ongoing, interrupted));

    QCOMPARE(spy.count(), 1);