--- /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)