1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include <PsetContainer.h>

    19 #include <MPsetNetworkInfoObs.h>

    20 #include "ut_psetnetworkwrapper.h"

    21 #include "testutilities.h"

    22 #define private public

    23 #include "psetnetworkwrapper.h"

    24 #include "psetnetworkwrapper_p.h"

    25 

    26 class NetworkInfoObserver : public MPsetNetworkInfoObserver

    27 {

    28 

    29     void HandleNetworkInfoReceivedL( 

    30         const CNetworkInfoArray* aInfoArray, 

    31         const TInt aResult)

    32     {

    33         Q_UNUSED(aInfoArray);

    34         Q_UNUSED(aResult);

    35     }

    36 

    37     void HandleCurrentNetworkInfoL( 

    38         const MPsetNetworkSelect::TCurrentNetworkInfo& aCurrentInfo, 

    39         const TInt aResult)

    40     {

    41         Q_UNUSED(aCurrentInfo);

    42         Q_UNUSED(aResult);

    43     }

    44 

    45     void HandleNetworkChangedL( 

    46         const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,

    47         const MPsetNetworkSelect::TCurrentNetworkStatus aStatus, 

    48         const TInt aResult)

    49     {

    50         Q_UNUSED(aCurrentInfo);

    51         Q_UNUSED(aStatus);

    52         Q_UNUSED(aResult);

    53     }

    54 

    55     void HandleNetworkChangedL( 

    56         const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,

    57         const RMobilePhone::TMobilePhoneRegistrationStatus& aStatus, 

    58         const TInt aResult)

    59     {

    60         Q_UNUSED(aCurrentInfo);

    61         Q_UNUSED(aStatus);

    62         Q_UNUSED(aResult);

    63     }

    64 

    65     void HandleSearchingNetworksL( 

    66         TServiceRequest aRequest)

    67     {

    68         Q_UNUSED(aRequest);

    69     }

    70 

    71     void HandleRequestingSelectedNetworkL( 

    72         TBool aOngoing)

    73     {

    74         Q_UNUSED(aOngoing);

    75     }

    76 

    77     void HandleCallActivatedL()

    78     {

    79         

    80     }

    81 

    82     void HandleNetworkErrorL( 

    83         const MPsetNetworkInfoObserver::TServiceRequest aRequest,

    84         const TInt aError)

    85     {

    86         Q_UNUSED(aRequest);

    87         Q_UNUSED(aError);

    88     }

    89 };

    90 

    91 /*!

    92   UT_PSetNetworkWrapper::UT_PSetNetworkWrapper

    93  */

    94 UT_PSetNetworkWrapper::UT_PSetNetworkWrapper() 

    95     : 

    96     m_wrapper(NULL), 

    97     m_psetContainerMock(NULL), 

    98     m_psetNetworkMock(NULL),

    99     m_psetNetworkModeMock(NULL)

   100 {

   101 }

   102 

   103 /*!

   104   UT_PSetNetworkWrapper::~UT_PSetNetworkWrapper

   105  */

   106 UT_PSetNetworkWrapper::~UT_PSetNetworkWrapper()

   107 {

   108     delete m_wrapper;

   109     delete m_psetContainerMock;

   110     m_psetNetworkMock = NULL;

   111     m_psetNetworkModeMock = NULL;

   112 }

   113 

   114 /*!

   115   UT_PSetNetworkWrapper::init

   116  */

   117 void UT_PSetNetworkWrapper::init()

   118 {

   119     initialize();

   120     

   121     m_psetContainerMock = new CPsetContainer();

   122     

   123     RMobilePhone dummyHandle;

   124     NetworkInfoObserver dummyObserver;

   125     QT_TRAP_THROWING(m_psetNetworkMock = 

   126         CPsetNetwork::NewL(dummyHandle, dummyObserver));

   127     QT_TRAP_THROWING(m_psetNetworkModeMock = 

   128         CPsetNetwork::NewL(dummyHandle, dummyObserver));

   129     

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

   131     expect("CPsetContainer::CreateNetworkModeObjectL").

   132         returns(m_psetNetworkModeMock);

   133     

   134     // wrapper takes ownership of networkmocks during successfull

   135     // construction

   136     QScopedPointer<CPsetNetwork> networkMockPtr(m_psetNetworkMock);

   137     QScopedPointer<CPsetNetwork> networkModeMockPtr(m_psetNetworkModeMock);

   138     m_wrapper = new PSetNetworkWrapper(*m_psetContainerMock, NULL);

   139     networkMockPtr.take();

   140     networkModeMockPtr.take();

   141 }

   142 

   143 /*!

   144   UT_PSetNetworkWrapper::cleanup

   145  */

   146 void UT_PSetNetworkWrapper::cleanup()

   147 {

   148     reset();

   149     

   150     delete m_wrapper;

   151     m_wrapper = NULL;

   152     delete m_psetContainerMock;

   153     m_psetContainerMock = NULL;

   154     m_psetNetworkMock = NULL;

   155     m_psetNetworkModeMock = NULL;

   156 }

   157 

   158 /*!

   159   UT_PSetNetworkWrapper::t_getAvailableNetworks

   160  */

   161 void UT_PSetNetworkWrapper::t_getAvailableNetworks()

   162 {

   163     expect("CPsetNetwork::GetAvailableNetworksL");

   164     

   165     m_wrapper->getAvailableNetworks();

   166     

   167     QVERIFY(true == verify());

   168 }

   169 

   170 

   171 /*!

   172   UT_PSetNetworkWrapper::t_getNetworkSelectionMode

   173  */

   174 void UT_PSetNetworkWrapper::t_getNetworkSelectionMode()

   175 {

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

   177         with(MPsetNetworkSelect::ENetSelectModeManual)*/.

   178         returns(KErrNone);

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

   180         with(MPsetNetworkSelect::ENetSelectModeAutomatic)*/.

   181         returns(KErrGeneral);

   182     

   183     PSetNetworkWrapper::NetworkSelectionMode selectionModeManual =

   184         PSetNetworkWrapper::SelectionModeManual;

   185     PSetNetworkWrapper::NetworkSelectionMode selectionModeAutomatic =

   186         PSetNetworkWrapper::SelectionModeAutomatic;

   187     m_wrapper->getNetworkSelectionMode(selectionModeManual);

   188     m_wrapper->getNetworkSelectionMode(selectionModeAutomatic);

   189     

   190     

   191     QVERIFY(true == verify());

   192 }

   193 

   194 /*!

   195   UT_PSetNetworkWrapper::t_selectNetwork

   196  */

   197 void UT_PSetNetworkWrapper::t_selectNetwork()

   198 {

   199     expect("CPsetNetwork::SelectNetworkL");

   200 

   201     PSetNetworkWrapper::NetworkInfo info;

   202     m_wrapper->selectNetwork(info);

   203     

   204     QVERIFY(true == verify());

   205 }

   206 

   207 /*!

   208   UT_PSetNetworkWrapper::t_cancelRequest

   209  */

   210 void UT_PSetNetworkWrapper::t_cancelRequest()

   211 {

   212     expect("CPsetNetwork::CancelProcess");

   213     

   214     m_wrapper->cancelRequest();

   215     

   216     QVERIFY(true == verify());

   217 }

   218 

   219 /*!

   220   UT_PSetNetworkWrapper::t_getNetworkAccessMode

   221  */

   222 void UT_PSetNetworkWrapper::t_getNetworkAccessMode()

   223 {

   224     expect("CPsetNetwork::GetCurrentNetworkModeSelectionL");

   225     

   226     m_wrapper->getNetworkAccessMode();

   227     

   228     QVERIFY(true == verify());

   229 }

   230 

   231 /*!

   232   UT_PSetNetworkWrapper::t_setNetworkAccessMode

   233  */

   234 void UT_PSetNetworkWrapper::t_setNetworkAccessMode()

   235 {

   236     expect("CPsetNetwork::SetNetworkModeSelectionL").

   237         with(RMmCustomAPI::KCapsNetworkModeDual);

   238     expect("CPsetNetwork::SetNetworkModeSelectionL").

   239         with(RMmCustomAPI::KCapsNetworkModeUmts);

   240     expect("CPsetNetwork::SetNetworkModeSelectionL").

   241         with(RMmCustomAPI::KCapsNetworkModeGsm);

   242     

   243     m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeDual);

   244     m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeUmts);

   245     m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeGsm);

   246     

   247     const int invalidMode = -1;

   248     m_wrapper->setNetworkAccessMode(

   249         reinterpret_cast<const PSetNetworkWrapper::NetworkAccessMode&>

   250             (invalidMode));

   251     

   252     QVERIFY(true == verify());

   253 }

   254 

   255 /*!

   256   UT_PSetNetworkWrapper::t_handleNetworkInfoReceived

   257  */

   258 void UT_PSetNetworkWrapper::t_handleNetworkInfoReceived()

   259 {

   260     CNetworkInfoArray* infos = NULL;

   261     

   262     TRAPD(result, m_wrapper->m_privateImpl->

   263         HandleNetworkInfoReceivedL(infos, KErrNone));

   264     QVERIFY(KErrArgument == result);

   265     

   266     infos = reinterpret_cast<CNetworkInfoArray*>(this);

   267     TRAP(result, m_wrapper->m_privateImpl->

   268         HandleNetworkInfoReceivedL(infos, KErrNone));

   269     QVERIFY(KErrNone == result);

   270 }

   271 

   272 

   273 /*!

   274   UT_PSetNetworkWrapper::t_handleCurrentNetworkInfo

   275  */

   276 void UT_PSetNetworkWrapper::t_handleCurrentNetworkInfo()

   277 {

   278     MPsetNetworkSelect::TCurrentNetworkInfo networkInfo;

   279     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   280         HandleCurrentNetworkInfoL(networkInfo, KErrNone));

   281 }

   282 

   283 /*!

   284   UT_PSetNetworkWrapper::t_handleNetworkChangedWithNetworkStatus

   285  */

   286 void UT_PSetNetworkWrapper::t_handleNetworkChangedWithNetworkStatus()

   287 {

   288     MPsetNetworkSelect::TNetworkInfo networkInfo;

   289     MPsetNetworkSelect::TCurrentNetworkStatus networkStatus =

   290         MPsetNetworkSelect::ENotRegisteredNotSearching;

   291     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   292         HandleNetworkChangedL(networkInfo, networkStatus, KErrNone));

   293 }

   294 

   295 /*!

   296   UT_PSetNetworkWrapper::t_handleNetworkChangedWithPhoneRegistrationStatus

   297  */

   298 void UT_PSetNetworkWrapper::t_handleNetworkChangedWithPhoneRegistrationStatus()

   299 {

   300     MPsetNetworkSelect::TNetworkInfo networkInfo;

   301     RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus;

   302     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   303         HandleNetworkChangedL(networkInfo, registrationStatus, KErrNone));

   304 }

   305 

   306 

   307 /*!

   308   UT_PSetNetworkWrapper::t_handleSearchingNetworks

   309  */

   310 void UT_PSetNetworkWrapper::t_handleSearchingNetworks()

   311 {

   312     MPsetNetworkInfoObserver::TServiceRequest request =

   313         MPsetNetworkInfoObserver::EServiceRequestNone;

   314     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   315         HandleSearchingNetworksL(request));

   316 }

   317 

   318 /*!

   319   UT_PSetNetworkWrapper::t_handleRequestingSelectedNetwork

   320  */

   321 void UT_PSetNetworkWrapper::t_handleRequestingSelectedNetwork()

   322 {

   323     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   324         HandleRequestingSelectedNetworkL(EFalse));

   325     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   326         HandleRequestingSelectedNetworkL(ETrue));

   327 }

   328 

   329 /*!

   330   UT_PSetNetworkWrapper::t_handleCallActivated

   331  */

   332 void UT_PSetNetworkWrapper::t_handleCallActivated()

   333 {

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

   335 }

   336 

   337 /*!

   338   UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver

   339  */

   340 void UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver()

   341 {

   342     MPsetNetworkInfoObserver::TServiceRequest request =

   343         MPsetNetworkInfoObserver::EServiceRequestNone;

   344     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   345         HandleNetworkErrorL(request, KErrNone));

   346 }

   347 

   348 

   349 /*!

   350   UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents

   351  */

   352 Q_DECLARE_METATYPE(PSetNetworkWrapper::NetworkAccessMode)

   353 void UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents()

   354 {

   355     qRegisterMetaType<PSetNetworkWrapper::NetworkAccessMode>

   356         ("PSetNetworkWrapper::NetworkAccessMode");

   357     QSignalSpy spy(m_wrapper, 

   358         SIGNAL(networkAccessModeGot(PSetNetworkWrapper::NetworkAccessMode)));

   359     

   360     MPsetNetworkModeObserver::TServiceRequest serviceRequest =

   361         MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode;

   362     RMmCustomAPI::TNetworkModeCaps modeCaps = 

   363         RMmCustomAPI::KCapsNetworkModeDual;

   364     QT_TRAP_THROWING( 

   365         m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

   366         serviceRequest, modeCaps));

   367     modeCaps =RMmCustomAPI::KCapsNetworkModeUmts;

   368     QT_TRAP_THROWING( 

   369         m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

   370         serviceRequest, modeCaps));

   371     modeCaps = RMmCustomAPI::KCapsNetworkModeGsm;

   372     QT_TRAP_THROWING( 

   373         m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

   374         serviceRequest, modeCaps));

   375     

   376     QCOMPARE(spy.count(), 3);

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

   378     QVERIFY(PSetNetworkWrapper::AccessModeDual 

   379         == arguments0.at(0).value<PSetNetworkWrapper::NetworkAccessMode>());

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

   381     QVERIFY(PSetNetworkWrapper::AccessModeUmts 

   382         == arguments1.at(0).value<PSetNetworkWrapper::NetworkAccessMode>());

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

   384     QVERIFY(PSetNetworkWrapper::AccessModeGsm 

   385         == arguments2.at(0).value<PSetNetworkWrapper::NetworkAccessMode>());

   386     

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

   388     serviceRequest = MPsetNetworkModeObserver::EServiceRequestNone;

   389     QT_TRAP_THROWING( 

   390         m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

   391         serviceRequest, modeCaps));

   392     serviceRequest = 

   393         MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode;

   394     QT_TRAP_THROWING( 

   395         m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL(

   396         serviceRequest, modeCaps));

   397 }

   398 

   399 /*!

   400   UT_PSetNetworkWrapper::t_handleNetworkErrorFromModeObserver

   401  */

   402 void UT_PSetNetworkWrapper::t_handleNetworkErrorFromModeObserver()

   403 {

   404     MPsetNetworkModeObserver::TServiceRequest request =

   405         MPsetNetworkModeObserver::EServiceRequestNone;

   406     QT_TRAP_THROWING(m_wrapper->m_privateImpl->

   407         HandleNetworkErrorL(request, KErrNone));

   408 }

   409 

   410 /*!

   411   UT_PSetNetworkWrapper::t_exceptionSafety

   412  */

   413 void UT_PSetNetworkWrapper::t_exceptionSafety()

   414 {

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

   416 }

   417 

   418 QTEST_MAIN_S60(UT_PSetNetworkWrapper)