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 Fri Mar 19 09:40:14 2010 +0200
@@ -0,0 +1,418 @@
+/*
+* 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 "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);
+ }
+};
+
+/*!
+ 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();
+
+ 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_getAvailableNetworks
+ */
+void UT_PSetNetworkWrapper::t_getAvailableNetworks()
+{
+ expect("CPsetNetwork::GetAvailableNetworksL");
+
+ m_wrapper->getAvailableNetworks();
+
+ QVERIFY(true == 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");
+
+ PSetNetworkWrapper::NetworkInfo info;
+ 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");
+
+ 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);
+
+ m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeDual);
+ m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeUmts);
+ 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);
+
+ infos = reinterpret_cast<CNetworkInfoArray*>(this);
+ 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
+ */
+void UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver()
+{
+ MPsetNetworkInfoObserver::TServiceRequest request =
+ MPsetNetworkInfoObserver::EServiceRequestNone;
+ QT_TRAP_THROWING(m_wrapper->m_privateImpl->
+ HandleNetworkErrorL(request, KErrNone));
+}
+
+
+/*!
+ UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents
+ */
+Q_DECLARE_METATYPE(PSetNetworkWrapper::NetworkAccessMode)
+void UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents()
+{
+ qRegisterMetaType<PSetNetworkWrapper::NetworkAccessMode>
+ ("PSetNetworkWrapper::NetworkAccessMode");
+ QSignalSpy spy(m_wrapper,
+ SIGNAL(networkAccessModeGot(PSetNetworkWrapper::NetworkAccessMode)));
+
+ 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).value<PSetNetworkWrapper::NetworkAccessMode>());
+ const QList<QVariant> &arguments1 = spy.at(1);
+ QVERIFY(PSetNetworkWrapper::AccessModeUmts
+ == arguments1.at(0).value<PSetNetworkWrapper::NetworkAccessMode>());
+ const QList<QVariant> &arguments2 = spy.at(2);
+ QVERIFY(PSetNetworkWrapper::AccessModeGsm
+ == arguments2.at(0).value<PSetNetworkWrapper::NetworkAccessMode>());
+
+ // 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()
+{
+ OomTestExecuter::runAllTests(*this, "t_exceptionSafety");
+}
+
+QTEST_MAIN_S60(UT_PSetNetworkWrapper)