/*

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

#include <gsmerror.h>

#include <mock_cpsetrefreshhandler.h>

#include "ut_psetnetworkwrapper.h"

#include "testutilities.h"

#define private public

#include "psetnetworkwrapper.h"

#include "psetnetworkwrapper_p.h"

class NetworkInfoObserver : public MPsetNetworkInfoObserver

{

    void HandleNetworkInfoReceivedL( 

        const CNetworkInfoArray* aInfoArray, 

        const TInt aResult)

    {

        Q_UNUSED(aInfoArray);

        Q_UNUSED(aResult);

    }

    void HandleCurrentNetworkInfoL( 

        const MPsetNetworkSelect::TCurrentNetworkInfo& aCurrentInfo, 

        const TInt aResult)

    {

        Q_UNUSED(aCurrentInfo);

        Q_UNUSED(aResult);

    }

    void HandleNetworkChangedL( 

        const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,

        const MPsetNetworkSelect::TCurrentNetworkStatus aStatus, 

        const TInt aResult)

    {

        Q_UNUSED(aCurrentInfo);

        Q_UNUSED(aStatus);

        Q_UNUSED(aResult);

    }

    void HandleNetworkChangedL( 

        const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,

        const RMobilePhone::TMobilePhoneRegistrationStatus& aStatus, 

        const TInt aResult)

    {

        Q_UNUSED(aCurrentInfo);

        Q_UNUSED(aStatus);

        Q_UNUSED(aResult);

    }

    void HandleSearchingNetworksL( 

        TServiceRequest aRequest)

    {

        Q_UNUSED(aRequest);

    }

    void HandleRequestingSelectedNetworkL( 

        TBool aOngoing)

    {

        Q_UNUSED(aOngoing);

    }

    void HandleCallActivatedL()

    {

    }

    void HandleNetworkErrorL( 

        const MPsetNetworkInfoObserver::TServiceRequest aRequest,

        const TInt aError)

    {

        Q_UNUSED(aRequest);

        Q_UNUSED(aError);

    }

};

void SimulateLeaveL()

{

    User::Leave(KErrGeneral);

}

/*!

  UT_PSetNetworkWrapper::UT_PSetNetworkWrapper

 */

UT_PSetNetworkWrapper::UT_PSetNetworkWrapper() 

    : 

    m_wrapper(NULL), 

    m_psetContainerMock(NULL), 

    m_psetNetworkMock(NULL),

    m_psetNetworkModeMock(NULL)

{

}

/*!

  UT_PSetNetworkWrapper::~UT_PSetNetworkWrapper

 */

UT_PSetNetworkWrapper::~UT_PSetNetworkWrapper()

{

    delete m_wrapper;

    delete m_psetContainerMock;

    m_psetNetworkMock = NULL;

    m_psetNetworkModeMock = NULL;

}

/*!

  UT_PSetNetworkWrapper::init

 */

void UT_PSetNetworkWrapper::init()

{

    initialize();

    m_psetContainerMock = new CPsetContainer();

    m_refreshHandler = CPSetRefreshHandlerMock::NewL();

    SmcDefaultValue<CPSetRefreshHandler *>::SetL(m_refreshHandler);

    RMobilePhone dummyHandle;

    NetworkInfoObserver dummyObserver;

    QT_TRAP_THROWING(m_psetNetworkMock = 

        CPsetNetwork::NewL(dummyHandle, dummyObserver));

    QT_TRAP_THROWING(m_psetNetworkModeMock = 

        CPsetNetwork::NewL(dummyHandle, dummyObserver));

    expect("CPsetContainer::CreateNetworkObjectL").returns(m_psetNetworkMock);

    expect("CPsetContainer::CreateNetworkModeObjectL").

        returns(m_psetNetworkModeMock);

    // wrapper takes ownership of networkmocks during successfull

    // construction

    QScopedPointer<CPsetNetwork> networkMockPtr(m_psetNetworkMock);

    QScopedPointer<CPsetNetwork> networkModeMockPtr(m_psetNetworkModeMock);

    m_wrapper = new PSetNetworkWrapper(*m_psetContainerMock, NULL);

    networkMockPtr.take();

    networkModeMockPtr.take();

}

/*!

  UT_PSetNetworkWrapper::cleanup

 */

void UT_PSetNetworkWrapper::cleanup()

{

    reset();

    delete m_wrapper;

    m_wrapper = NULL;

    delete m_psetContainerMock;

    m_psetContainerMock = NULL;

    m_psetNetworkMock = NULL;

    m_psetNetworkModeMock = NULL;

}

/*!

  UT_PSetNetworkWrapper::t_construction

 */

void UT_PSetNetworkWrapper::t_construction()

{

    if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") != 0) {

        expect("CPsetContainer::CreateNetworkObjectL").

            willOnce(invokeWithoutArguments(SimulateLeaveL));

        PSetNetworkWrapper *wrapper = NULL;

        EXPECT_EXCEPTION(

            wrapper = new PSetNetworkWrapper(*m_psetContainerMock, NULL);

            delete wrapper;

            wrapper = NULL;

        )

        QVERIFY(verify());

        expect("CPsetContainer::CreateNetworkModeObjectL").

            willOnce(invokeWithoutArguments(SimulateLeaveL));

        EXPECT_EXCEPTION(

            wrapper = new PSetNetworkWrapper(*m_psetContainerMock, NULL);

            delete wrapper;

            wrapper = NULL;

        )

        QVERIFY(verify());

    }

}

/*!

  UT_PSetNetworkWrapper::t_getAvailableNetworks

 */

void UT_PSetNetworkWrapper::t_getAvailableNetworks()

{

    expect("CPsetNetwork::GetAvailableNetworksL")

        .willOnce(invokeWithoutArguments(SimulateLeaveL));

    EXPECT_EXCEPTION(

        m_wrapper->getAvailableNetworks();

    )

    QVERIFY(verify());

}

/*!

  UT_PSetNetworkWrapper::t_getNetworkSelectionMode

 */

void UT_PSetNetworkWrapper::t_getNetworkSelectionMode()

{

    expect("CPsetNetwork::GetNetworkSelectMode")/*.

        with(MPsetNetworkSelect::ENetSelectModeManual)*/.

        returns(KErrNone);

    expect("CPsetNetwork::GetNetworkSelectMode")/*.

        with(MPsetNetworkSelect::ENetSelectModeAutomatic)*/.

        returns(KErrGeneral);

    PSetNetworkWrapper::NetworkSelectionMode selectionModeManual =

        PSetNetworkWrapper::SelectionModeManual;

    PSetNetworkWrapper::NetworkSelectionMode selectionModeAutomatic =

        PSetNetworkWrapper::SelectionModeAutomatic;

    m_wrapper->getNetworkSelectionMode(selectionModeManual);

    m_wrapper->getNetworkSelectionMode(selectionModeAutomatic);

    QVERIFY(true == verify());

}

/*!

  UT_PSetNetworkWrapper::t_selectNetwork

 */

void UT_PSetNetworkWrapper::t_selectNetwork()

{

    expect("CPsetNetwork::SelectNetworkL")

        .willOnce(invokeWithoutArguments(SimulateLeaveL));

    PSetNetworkWrapper::NetworkInfo info;

    EXPECT_EXCEPTION(

        m_wrapper->selectNetwork(info);

    )

    QVERIFY(true == verify());

}

/*!

  UT_PSetNetworkWrapper::t_cancelRequest

 */

void UT_PSetNetworkWrapper::t_cancelRequest()

{

    expect("CPsetNetwork::CancelProcess");

    m_wrapper->cancelRequest();

    QVERIFY(true == verify());

}

/*!

  UT_PSetNetworkWrapper::t_getNetworkAccessMode

 */

void UT_PSetNetworkWrapper::t_getNetworkAccessMode()

{

    expect("CPsetNetwork::GetCurrentNetworkModeSelectionL")

        .willOnce(invokeWithoutArguments(SimulateLeaveL));

    EXPECT_EXCEPTION(

        m_wrapper->getNetworkAccessMode();

    )

    QVERIFY(true == verify());

}

/*!

  UT_PSetNetworkWrapper::t_setNetworkAccessMode

 */

void UT_PSetNetworkWrapper::t_setNetworkAccessMode()

{

    expect("CPsetNetwork::SetNetworkModeSelectionL").

        with(RMmCustomAPI::KCapsNetworkModeDual);

    expect("CPsetNetwork::SetNetworkModeSelectionL").

        with(RMmCustomAPI::KCapsNetworkModeUmts);

    expect("CPsetNetwork::SetNetworkModeSelectionL")

        .with(RMmCustomAPI::KCapsNetworkModeGsm)

        .willOnce(invokeWithoutArguments(SimulateLeaveL));

    m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeDual);

    m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeUmts);

    EXPECT_EXCEPTION(

        m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeGsm);

    )

    const int invalidMode = -1;

    m_wrapper->setNetworkAccessMode(

        reinterpret_cast<const PSetNetworkWrapper::NetworkAccessMode&>

            (invalidMode));

    QVERIFY(true == verify());

}

/*!

  UT_PSetNetworkWrapper::t_handleNetworkInfoReceived

 */

void UT_PSetNetworkWrapper::t_handleNetworkInfoReceived()

{

    CNetworkInfoArray* infos = NULL;

    TRAPD(result, m_wrapper->m_privateImpl->

        HandleNetworkInfoReceivedL(infos, KErrNone));

    QVERIFY(KErrArgument == result);

    const TInt KGranularity = 3;

    infos = new CNetworkInfoArray(KGranularity);

    QScopedPointer<CNetworkInfoArray> infoArrayGuard(infos);

    MPsetNetworkSelect::TNetworkInfo info1;

    infos->AppendL(info1);

    TRAP(result, m_wrapper->m_privateImpl->

        HandleNetworkInfoReceivedL(infos, KErrNone));

    QVERIFY(KErrNone == result);

    MPsetNetworkSelect::TNetworkInfo info2;

    infos->AppendL(info2);

    TRAP(result, m_wrapper->m_privateImpl->

        HandleNetworkInfoReceivedL(infos, KErrNone));

    QVERIFY(KErrNone == result);

    MPsetNetworkSelect::TNetworkInfo info3;

    infos->AppendL(info3);

    TRAP(result, m_wrapper->m_privateImpl->

        HandleNetworkInfoReceivedL(infos, KErrNone));

    QVERIFY(KErrNone == result);

}

/*!

  UT_PSetNetworkWrapper::t_handleCurrentNetworkInfo

 */

void UT_PSetNetworkWrapper::t_handleCurrentNetworkInfo()

{

    MPsetNetworkSelect::TCurrentNetworkInfo networkInfo;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleCurrentNetworkInfoL(networkInfo, KErrNone));

}

/*!

  UT_PSetNetworkWrapper::t_handleNetworkChangedWithNetworkStatus

 */

void UT_PSetNetworkWrapper::t_handleNetworkChangedWithNetworkStatus()

{

    MPsetNetworkSelect::TNetworkInfo networkInfo;

    MPsetNetworkSelect::TCurrentNetworkStatus networkStatus =

        MPsetNetworkSelect::ENotRegisteredNotSearching;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleNetworkChangedL(networkInfo, networkStatus, KErrNone));

}

/*!

  UT_PSetNetworkWrapper::t_handleNetworkChangedWithPhoneRegistrationStatus

 */

void UT_PSetNetworkWrapper::t_handleNetworkChangedWithPhoneRegistrationStatus()

{

    MPsetNetworkSelect::TNetworkInfo networkInfo;

    RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleNetworkChangedL(networkInfo, registrationStatus, KErrNone));

}

/*!

  UT_PSetNetworkWrapper::t_handleSearchingNetworks

 */

void UT_PSetNetworkWrapper::t_handleSearchingNetworks()

{

    MPsetNetworkInfoObserver::TServiceRequest request =

        MPsetNetworkInfoObserver::EServiceRequestNone;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleSearchingNetworksL(request));

}

/*!

  UT_PSetNetworkWrapper::t_handleRequestingSelectedNetwork

 */

void UT_PSetNetworkWrapper::t_handleRequestingSelectedNetwork()

{

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleRequestingSelectedNetworkL(EFalse));

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleRequestingSelectedNetworkL(ETrue));

}

/*!

  UT_PSetNetworkWrapper::t_handleCallActivated

 */

void UT_PSetNetworkWrapper::t_handleCallActivated()

{

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleCallActivatedL());

}

/*!

  UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver

 */

Q_DECLARE_METATYPE(PSetNetworkWrapper::RequestType)

Q_DECLARE_METATYPE(PSetNetworkWrapper::ErrorCode)

void UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver()

{

    qRegisterMetaType<PSetNetworkWrapper::RequestType>

        ("PSetNetworkWrapper::RequestType");

    qRegisterMetaType<PSetNetworkWrapper::ErrorCode>

        ("PSetNetworkWrapper::ErrorCode");

    QSignalSpy spy(m_wrapper, SIGNAL(networkReqestFailed(

        PSetNetworkWrapper::ErrorCode, PSetNetworkWrapper::RequestType)));

    MPsetNetworkInfoObserver::TServiceRequest request =

        MPsetNetworkInfoObserver::EServiceRequestNone;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL(

        request, KErrGsmNetCauseCallActive));

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL(

        request, KErrGsm0707NoNetworkService));

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL(

        request, KErrGsmOfflineOpNotAllowed));

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL(

        request, KErrGeneral));

    QCOMPARE(spy.count(), 4);

    QVERIFY(PSetNetworkWrapper::ErrCauseCallActive == 

        qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(0).at(0)));

    QVERIFY(PSetNetworkWrapper::ErrNoNetworkService == 

        qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(1).at(0)));

    QVERIFY(PSetNetworkWrapper::ErrOfflineOpNotAllowed == 

        qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(2).at(0)));

    QVERIFY(PSetNetworkWrapper::ErrNoNetworkAccess == 

        qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(3).at(0)));

}

/*!

  UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents

 */

void UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents()

{

    QSignalSpy spy(m_wrapper, SIGNAL(networkAccessModeGot(int)));

    MPsetNetworkModeObserver::TServiceRequest serviceRequest =

        MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode;

    RMmCustomAPI::TNetworkModeCaps modeCaps = 

        RMmCustomAPI::KCapsNetworkModeDual;

    QT_TRAP_THROWING( 

        m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

        serviceRequest, modeCaps));

    modeCaps =RMmCustomAPI::KCapsNetworkModeUmts;

    QT_TRAP_THROWING( 

        m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

        serviceRequest, modeCaps));

    modeCaps = RMmCustomAPI::KCapsNetworkModeGsm;

    QT_TRAP_THROWING( 

        m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

        serviceRequest, modeCaps));

    QCOMPARE(spy.count(), 3);

    const QList<QVariant> &arguments0 = spy.at(0);

    QVERIFY(PSetNetworkWrapper::AccessModeDual == arguments0.at(0).toInt());

    const QList<QVariant> &arguments1 = spy.at(1);

    QVERIFY(PSetNetworkWrapper::AccessModeUmts == arguments1.at(0).toInt());

    const QList<QVariant> &arguments2 = spy.at(2);

    QVERIFY(PSetNetworkWrapper::AccessModeGsm == arguments2.at(0).toInt());

    // TODO: test skeleton for switch cases not yet implemented 

    serviceRequest = MPsetNetworkModeObserver::EServiceRequestNone;

    QT_TRAP_THROWING( 

        m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

        serviceRequest, modeCaps));

    serviceRequest = 

        MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode;

    QT_TRAP_THROWING( 

        m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

        serviceRequest, modeCaps));

}

/*!

  UT_PSetNetworkWrapper::t_handleNetworkErrorFromModeObserver

 */

void UT_PSetNetworkWrapper::t_handleNetworkErrorFromModeObserver()

{

    MPsetNetworkModeObserver::TServiceRequest request =

        MPsetNetworkModeObserver::EServiceRequestNone;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->

        HandleNetworkErrorL(request, KErrNone));

}

/*!

  UT_PSetNetworkWrapper::t_exceptionSafety

 */

void UT_PSetNetworkWrapper::t_exceptionSafety()

{

    cleanup();

    OomTestExecuter::runAllTests(*this, "t_exceptionSafety");

}

/*!

  UT_PSetNetworkWrapper::t_isManualNetworkSelectionSupported

 */

void UT_PSetNetworkWrapper::t_isManualNetworkSelectionSupported()

{

    expect("CPsetCustomerServiceProfile::IsNetworkSelectionSupported").returns(KErrNone);

    m_wrapper->isManualNetworkSelectionSupported();

    QVERIFY(verify());

    expect("CPsetCustomerServiceProfile::IsNetworkSelectionSupported").returns(KErrGeneral);

    m_wrapper->isManualNetworkSelectionSupported();

    QVERIFY(verify());

}

/*!

  UT_PSetNetworkWrapper::t_AllowRefresh

 */

void UT_PSetNetworkWrapper::t_AllowRefresh()

{

    TSatRefreshType type;

    TSatElementaryFiles file;

    m_refreshHandler->trigerAllowRefresh(type, file);

}

/*!

  UT_PSetNetworkWrapper::t_Refresh

 */