/*

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

#include <psetwrappertypes.h>

#include <nwdefs.h>

#include "ut_psetcallbarringwrapper.h"

#include "testutilities.h"

#define private public

#include <psetcallbarringwrapper.h>

#include "psetcallbarringwrapper_p.h"

const int KInvalidEnumeration = -1;

class BarringObserver : public MPsetBarringObserver

{

    void HandleBarringModeChangedL( 

        TBarringProgram aType, 

        TBarringStatus aStatus, 

        TBool aPlural )

    {

        Q_UNUSED(aType);

        Q_UNUSED(aStatus);

        Q_UNUSED(aPlural);

    }

    void HandleBarringModeStatusL( 

        TUint8 aBsc[KPSetNumberOfBsc], 

        TBarringStatus aStatus )

    {

        Q_UNUSED(aBsc);

        Q_UNUSED(aStatus);

    }

    void HandleBarringErrorL( 

        TInt aReason )

    {

        Q_UNUSED(aReason);

    }

    void HandleCBRequestingL( 

        TBool aTrue, 

        TBool aInterrupted )

    {

        Q_UNUSED(aTrue);

        Q_UNUSED(aInterrupted);

    }

    void SetEngineContact( 

        MPsetCallBarring* aBarringEngine )

    {

        Q_UNUSED(aBarringEngine);

    }

    void CbPasswordChangedL( 

        TBool aSuccess )

    {

        Q_UNUSED(aSuccess);

    }

};

void simulateLeaveL()

{

    User::Leave(KErrGeneral);

}

/*!

  UT_PSetCallBarringWrapper::UT_PSetCallBarringWrapper

 */

UT_PSetCallBarringWrapper::UT_PSetCallBarringWrapper()

    :

    m_psetContainerMock(NULL),

    m_wrapper(NULL)

{

}

/*!

  UT_PSetCallBarringWrapper::~UT_PSetCallBarringWrapper

 */

UT_PSetCallBarringWrapper::~UT_PSetCallBarringWrapper()

{

    delete m_psetContainerMock;

    delete m_wrapper;

}

/*!

  UT_PSetCallBarringWrapper::init

 */

void UT_PSetCallBarringWrapper::init()

{

    initialize();

    m_psetContainerMock = new CPsetContainer();

    BarringObserver dummyObserver;

    RMobilePhone dummyPhone;

    CPsetCallBarring *barringMock = NULL;

    TRAPD(result, barringMock = CPsetCallBarring::NewL(dummyObserver, dummyPhone));

    QScopedPointer<CPsetCallBarring> barringMockGuard(barringMock);

    EXPECT(CPsetContainer, CreateCBObjectL)

        .returns(barringMock);

    m_wrapper = new PSetCallBarringWrapper(*m_psetContainerMock, NULL);

    barringMockGuard.take();

    QVERIFY(verify());

}

/*!

  UT_PSetCallBarringWrapper::cleanup

 */

void UT_PSetCallBarringWrapper::cleanup()

{

    reset();

    delete m_psetContainerMock;

    m_psetContainerMock = NULL;

    delete m_wrapper;

    m_wrapper = NULL;

}

/*!

  UT_PSetCallBarringWrapper::t_construction

 */

void UT_PSetCallBarringWrapper::t_construction()

{

    EXPECT(CPsetContainer, CreateCBObjectL).

        willOnce(invokeWithoutArguments(this, simulateLeaveAtMockMethodCall));

    PSetCallBarringWrapper *wrapper = NULL;

    EXPECT_EXCEPTION(

        wrapper = new PSetCallBarringWrapper(*m_psetContainerMock, NULL););

}

/*!

  UT_PSetCallBarringWrapper::t_barringStatus

 */

void UT_PSetCallBarringWrapper::t_barringStatus()

{

// test status query with different service groups

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllBarrings);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupData, EBarringTypeAllBarrings);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupFax, EBarringTypeAllBarrings);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupAllTeleservices, EBarringTypeAllBarrings);

    // invalid/unknown enumeration as service group identifier

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllBarrings);

    //TODO: remove SeviceGroupUnknown enumeration?

    //m_wrapper->barringStatus(ServiceGroupUnknown);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllBarrings);

    m_wrapper->barringStatus(ServiceGroupData,

        PSetCallBarringWrapper::BarringTypeAllBarrings);

    m_wrapper->barringStatus(ServiceGroupFax,

        PSetCallBarringWrapper::BarringTypeAllBarrings);

    m_wrapper->barringStatus(ServiceGroupAllTeleservices,

        PSetCallBarringWrapper::BarringTypeAllBarrings);

    // invalid/unknown enumeration as service group identifier

    m_wrapper->barringStatus(

        static_cast<PsService>(KInvalidEnumeration),

        PSetCallBarringWrapper::BarringTypeAllBarrings);

// test status query with different barring types    

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllOutgoing);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeOutgoingInternational);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, 

            EBarringTypeOutgoingInternationalExceptToHomeCountry);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllIncoming);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeIncomingWhenRoaming);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllServices);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllOutgoingServices);

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllIncomingServices);

    // invalid/unknown enumeration as barring type

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .with(EServiceGroupVoice, EBarringTypeAllBarrings);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllOutgoing);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeOutgoingInternational);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::

            BarringTypeOutgoingInternationalExceptToHomeCountry);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllIncoming);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllServices);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllOutgoingServices);

    m_wrapper->barringStatus(ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllIncomingServices);

    // invalid/unknown enumeration as barring type

    m_wrapper->barringStatus(ServiceGroupVoice, 

        static_cast<PSetCallBarringWrapper::BarringType>(KInvalidEnumeration));

    QVERIFY(verify());

}

/*!

  UT_PSetCallBarringWrapper::t_barringStatusExceptionOccurs

 */

void UT_PSetCallBarringWrapper::t_barringStatusExceptionOccurs()

{

    EXPECT(CPsetCallBarring, GetBarringStatusL)

        .willOnce(invokeWithoutArguments(this, simulateLeaveAtMockMethodCall));

    EXPECT_EXCEPTION(

        m_wrapper->barringStatus(

            ServiceGroupVoice, 

            PSetCallBarringWrapper::BarringTypeAllBarrings);

    )

    QVERIFY(verify());

}

/*!

  UT_PSetCallBarringWrapper::t_enableBarring

 */

void UT_PSetCallBarringWrapper::t_enableBarring()

{

    _LIT(KPassword, "1234");

    TCallBarringSetting setting;

    setting.iType = EBarringTypeAllBarrings;

    setting.iSetting = EActivateBarring;

    setting.iServiceGroup = EServiceGroupVoice;

    setting.iPassword.Copy(KPassword());

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllBarrings,

        QString("1234"));

    setting.iType = EBarringTypeAllOutgoing;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllOutgoing,

        QString("1234"));

    setting.iType = EBarringTypeOutgoingInternational;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeOutgoingInternational,

        QString("1234"));

    setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,

        QString("1234"));

    setting.iType = EBarringTypeAllIncoming;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllIncoming,

        QString("1234"));

    setting.iType = EBarringTypeIncomingWhenRoaming;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,

        QString("1234"));

    setting.iType = EBarringTypeAllServices;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllServices,

        QString("1234"));

    setting.iType = EBarringTypeAllOutgoingServices;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllOutgoingServices,

        QString("1234"));

    setting.iType = EBarringTypeAllIncomingServices;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->enableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllIncomingServices,

        QString("1234"));

// error handling    

    EXPECT(CPsetCallBarring, SetBarringL)

        .willOnce(invokeWithoutArguments(simulateLeaveL));

    EXPECT_EXCEPTION(

        m_wrapper->enableBarring(

            ServiceGroupVoice, 

            PSetCallBarringWrapper::BarringTypeAllIncomingServices,

            QString("1234"));

    )

    QVERIFY(verify());

}

/*!

  UT_PSetCallBarringWrapper::t_disableBarring

 */

void UT_PSetCallBarringWrapper::t_disableBarring()

{

    _LIT(KPassword, "1234");

    TCallBarringSetting setting;

    setting.iType = EBarringTypeAllBarrings;

    setting.iSetting = ECancelBarring;

    setting.iServiceGroup = EServiceGroupVoice;

    setting.iPassword.Copy(KPassword());

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllBarrings,

        QString("1234"));

    setting.iType = EBarringTypeAllOutgoing;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllOutgoing,

        QString("1234"));

    setting.iType = EBarringTypeOutgoingInternational;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeOutgoingInternational,

        QString("1234"));

    setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,

        QString("1234"));

    setting.iType = EBarringTypeAllIncoming;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllIncoming,

        QString("1234"));

    setting.iType = EBarringTypeIncomingWhenRoaming;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,

        QString("1234"));

    setting.iType = EBarringTypeAllServices;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllServices,

        QString("1234"));

    setting.iType = EBarringTypeAllOutgoingServices;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllOutgoingServices,

        QString("1234"));

    setting.iType = EBarringTypeAllIncomingServices;

    EXPECT(CPsetCallBarring, SetBarringL)

        .with(setting, EAllTeleAndBearer);

    m_wrapper->disableBarring(

        ServiceGroupVoice, 

        PSetCallBarringWrapper::BarringTypeAllIncomingServices,

        QString("1234"));

// error handling    

    EXPECT(CPsetCallBarring, SetBarringL)

        .willOnce(invokeWithoutArguments(simulateLeaveL));

    EXPECT_EXCEPTION(

        m_wrapper->disableBarring(

            ServiceGroupVoice, 

            PSetCallBarringWrapper::BarringTypeAllIncomingServices,

            QString("1234"));

    )

    QVERIFY(verify());

}

/*!

  UT_PSetCallBarringWrapper::t_changeBarringPassword

 */

void UT_PSetCallBarringWrapper::t_changeBarringPassword()

{

    QString oldPassword = "1234";

    QString newPassword = "4321";

    QString verifiedPassword = "4321";

    RMobilePhone::TMobilePhonePasswordChangeV2 passwordChange;

    passwordChange.iOldPassword.Copy(oldPassword.utf16());

    passwordChange.iNewPassword.Copy(newPassword.utf16());

    passwordChange.iVerifiedPassword.Copy(verifiedPassword.utf16());

    EXPECT(CPsetCallBarring, ChangePasswordL)

        .with(passwordChange);

    m_wrapper->changeBarringPassword(

        oldPassword, newPassword, verifiedPassword);

// error handling    

    EXPECT(CPsetCallBarring, ChangePasswordL)

        .willOnce(invokeWithoutArguments(simulateLeaveL));

    EXPECT_EXCEPTION(

        m_wrapper->changeBarringPassword(

            oldPassword, newPassword, verifiedPassword);

    )

    QVERIFY(verify());

}

/*!

  UT_PSetCallBarringWrapper::t_HandleBarringModeChangedL

 */

void UT_PSetCallBarringWrapper::t_HandleBarringModeChangedL()

{

    TBool plural = EFalse;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeAllBarrings, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeAllOutgoing, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeOutgoingInternational, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeOutgoingInternationalExceptToHomeCountry, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeAllIncoming, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeIncomingWhenRoaming, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeAllServices, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeAllOutgoingServices, EBarringStatusActive, plural);

        m_wrapper->m_privateImpl->HandleBarringModeChangedL(

            EBarringTypeAllIncomingServices, EBarringStatusActive, plural);

    )

}

/*!

  UT_PSetCallBarringWrapper::t_HandleBarringErrorL

 */

void UT_PSetCallBarringWrapper::t_HandleBarringErrorL()

{

    // TODO: dummy test as functionality not yet implemented

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleBarringErrorL(KErrGeneral);

    )

}

/*!

  UT_PSetCallBarringWrapper::t_HandleCBRequestingL

 */

void UT_PSetCallBarringWrapper::t_HandleCBRequestingL()

{

    // TODO: dummy test as functionality not yet implemented

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCBRequestingL(EFalse, EFalse);

    )

}

/*!

  UT_PSetCallBarringWrapper::t_SetEngineContact

 */

void UT_PSetCallBarringWrapper::t_SetEngineContact()