diff -r 594d59766373 -r 7d48bed6ce0c cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetnetworkwrapper/ut_psetnetworkwrapper.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetnetworkwrapper/ut_psetnetworkwrapper.cpp	Tue Aug 31 15:45:17 2010 +0300
@@ -0,0 +1,546 @@
+/*
+* 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
+ */
+void UT_PSetNetworkWrapper::t_Refresh()
+{
+    TSatElementaryFiles file;
+    expect("CPsetCustomerServiceProfile::IsNetworkSelectionSupported").returns(KErrNone);
+    m_refreshHandler->trigerRefresh(EFileChangeNotification, KCsp1Ef);
+    QVERIFY(verify());
+    
+    expect("CPsetCustomerServiceProfile::IsNetworkSelectionSupported").returns(KErrGeneral);
+    m_refreshHandler->trigerRefresh(EFileChangeNotification, KCsp1Ef);
+    QVERIFY(verify());
+ 
+    expect("CPsetCustomerServiceProfile::IsNetworkSelectionSupported").times(0);
+    m_refreshHandler->trigerRefresh(EFileChangeNotification, KCsp2Ef);
+    QVERIFY(verify());
+}
+
+QTEST_MAIN_S60(UT_PSetNetworkWrapper)