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 <mpsetcliobserver.h>

    20 #include <psetwrappertypes.h>

    21 #include <PsetCli.h>

    22 #include <psuiconstants.h>

    23 #include "ut_psetcliwrapper.h"

    24 #include "testutilities.h"

    25 #define private public

    26 #include "psetcliwrapper.h"

    27 #include "psetcliwrapper_p.h"

    28 

    29 class CliObserver : public MPsetCliObserver

    30 {

    31     void SetEngineContact( MPsetCli* aEngine )

    32     {

    33         Q_UNUSED(aEngine);

    34     }

    35 

    36     void HandleCliRequestingL( TBool aOngoing, 

    37         TBool aInterrupted )

    38     {

    39         Q_UNUSED(aOngoing);

    40         Q_UNUSED(aInterrupted);

    41     }

    42 

    43     void CliInformationL( TPsuiCli aType )

    44     {

    45         Q_UNUSED(aType);

    46     }

    47 

    48     void HandleCliStatusL( TUint8 aBsc[KPSetNumberOfBsc], TPsuiCli aMode )

    49     {

    50         Q_UNUSED(aBsc);

    51         Q_UNUSED(aMode);

    52     }

    53       

    54     void HandleCnapStatusL( TInt aStatus )

    55     {

    56         Q_UNUSED(aStatus);

    57     }

    58 

    59     void HandleCliErrorL( TInt aError )

    60     {

    61         Q_UNUSED(aError);

    62     }

    63 };

    64 

    65 void SimulateLeaveL()

    66 {

    67     User::Leave(KErrGeneral);

    68 }

    69 

    70 

    71 /*!

    72   UT_PSetCliWrapper::UT_PSetCliWrapper

    73  */

    74 UT_PSetCliWrapper::UT_PSetCliWrapper()

    75     :

    76     m_numOfLeaveSimulations(0),

    77     m_psetContainerMock(NULL),

    78     m_wrapper(NULL),

    79     m_cliMock(NULL)

    80 {

    81 }

    82 

    83 /*!

    84   UT_PSetCliWrapper::~UT_PSetCliWrapper

    85  */

    86 UT_PSetCliWrapper::~UT_PSetCliWrapper()

    87 {

    88     delete m_psetContainerMock;

    89     delete m_wrapper;

    90     m_cliMock = NULL;

    91 }

    92 

    93 /*!

    94   UT_PSetCliWrapper::init

    95  */

    96 void UT_PSetCliWrapper::init()

    97 {

    98     initialize();

    99     

   100     m_numOfLeaveSimulations = 0;

   101     m_psetContainerMock = new CPsetContainer();

   102     

   103     RMobilePhone dummyHandle;

   104     CliObserver dummyObserver;

   105     QT_TRAP_THROWING(m_cliMock = 

   106         CPsetCli::NewL(dummyHandle, dummyObserver));

   107     expect("CPsetContainer::CreateCliObjectL").returns(m_cliMock);

   108     // wrapper takes ownership of callDivertingMock during successfull

   109     // construction.

   110     QScopedPointer<CPsetCli> cliMockPtr(m_cliMock);

   111     m_wrapper = new PSetCliWrapper(*m_psetContainerMock, NULL);

   112     cliMockPtr.take();

   113 }

   114 

   115 /*!

   116   UT_PSetCliWrapper::cleanup

   117  */

   118 void UT_PSetCliWrapper::cleanup()

   119 {

   120     reset();

   121     

   122     delete m_psetContainerMock;

   123     m_psetContainerMock = NULL;

   124     delete m_wrapper;

   125     m_wrapper = NULL;

   126     m_cliMock = NULL;

   127 }

   128 

   129 /*!

   130   UT_PSetCliWrapper::t_construction

   131  */

   132 void UT_PSetCliWrapper::t_construction()

   133 {

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

   135         expect("CPsetContainer::CreateCliObjectL").

   136             willOnce(invokeWithoutArguments(SimulateLeaveL));

   137         

   138         PSetCliWrapper *wrapper = NULL;

   139         EXPECT_EXCEPTION(

   140             wrapper = new PSetCliWrapper(*m_psetContainerMock, NULL);

   141         )

   142         delete wrapper;

   143         

   144         QVERIFY(verify());

   145     }

   146 }

   147 

   148 /*!

   149   UT_PSetCliWrapper::t_getColpMode

   150  */

   151 void UT_PSetCliWrapper::t_getColpMode()

   152 {

   153     expect("CPsetCli::GetColpModeL").

   154         willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

   155     

   156     EXPECT_EXCEPTION(

   157         m_wrapper->getColpMode();

   158     )

   159     

   160     QVERIFY(1 == m_numOfLeaveSimulations);

   161     QVERIFY(true == verify());

   162 }

   163 

   164 /*!

   165   UT_PSetCliWrapper::t_getClipMode

   166  */

   167 void UT_PSetCliWrapper::t_getClipMode()

   168 {

   169     expect("CPsetCli::GetClipModeL").

   170         willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

   171     

   172     EXPECT_EXCEPTION(

   173         m_wrapper->getClipMode();

   174     )

   175     

   176     QVERIFY(1 == m_numOfLeaveSimulations);

   177     QVERIFY(true == verify());

   178 }

   179 

   180 /*!

   181   UT_PSetCliWrapper::t_getClirMode

   182  */

   183 void UT_PSetCliWrapper::t_getClirMode()

   184 {

   185     expect("CPsetCli::GetClirModeL").

   186         willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

   187     

   188     EXPECT_EXCEPTION(

   189         m_wrapper->getClirMode();

   190     )

   191     

   192     QVERIFY(1 == m_numOfLeaveSimulations);

   193     QVERIFY(true == verify());

   194 }

   195 

   196 /*!

   197   UT_PSetCliWrapper::t_getColrMode

   198  */

   199 void UT_PSetCliWrapper::t_getColrMode()

   200 {

   201     expect("CPsetCli::GetColrModeL").

   202         willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

   203     

   204     EXPECT_EXCEPTION(

   205         m_wrapper->getColrMode();

   206     )

   207     

   208     QVERIFY(1 == m_numOfLeaveSimulations);

   209     QVERIFY(true == verify());

   210 }

   211 

   212 /*!

   213   UT_PSetCliWrapper::t_getCnap

   214  */

   215 void UT_PSetCliWrapper::t_getCnap()

   216 {

   217     expect("CPsetCli::GetCnapL").

   218         willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

   219     

   220     EXPECT_EXCEPTION(

   221         m_wrapper->getCnap();

   222     )

   223     

   224     QVERIFY(1 == m_numOfLeaveSimulations);

   225     QVERIFY(true == verify());

   226 }

   227 

   228 /*!

   229   UT_PSetCliWrapper::t_cancelAll

   230  */

   231 void UT_PSetCliWrapper::t_cancelAll()

   232 {

   233     expect("CPsetCli::CancelAll");

   234     

   235     m_wrapper->cancelAll();

   236     

   237     QVERIFY(true == verify());

   238 }

   239 

   240 

   241 /*!

   242   UT_PSetCliWrapper::t_handleCliRequesting

   243  */

   244 void UT_PSetCliWrapper::t_handleCliRequesting()

   245 {

   246     QSignalSpy spy(m_wrapper, SIGNAL(handleCliRequesting(bool, bool)));

   247     

   248     TBool isOngoing = ETrue;

   249     TBool isInterrupted = ETrue;

   250     QT_TRAP_THROWING(

   251         m_wrapper->m_privateImpl->HandleCliRequestingL(isOngoing, isInterrupted));

   252     

   253     const int expectednumOfSignalEmissions = 1;

   254     const int expectedNumOfSignalArguments = 2;

   255     QCOMPARE(spy.count(), expectednumOfSignalEmissions);

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

   257     QVERIFY(expectedNumOfSignalArguments == arguments.count());

   258     QVERIFY(ETrue == arguments.at(0).toBool());

   259     QVERIFY(ETrue == arguments.at(1).toBool());

   260 }

   261 

   262 /*!

   263   UT_PSetCliWrapper::t_cliInformation

   264  */

   265 Q_DECLARE_METATYPE(PsCallLineIdentity)

   266 void UT_PSetCliWrapper::t_cliInformation()

   267 {

   268     qRegisterMetaType<PsCallLineIdentity>("PsCallLineIdentity");

   269     QSignalSpy spy(m_wrapper, SIGNAL(cliInformation(PsCallLineIdentity)));

   270     

   271     QT_TRAP_THROWING(m_wrapper->m_privateImpl->CliInformationL(EPsuiClirOn));

   272     

   273     const int expectednumOfSignalEmissions = 1;

   274     const int expectedNumOfSignalArguments = 1;

   275     QCOMPARE(spy.count(), expectednumOfSignalEmissions);

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

   277     QVERIFY(expectedNumOfSignalArguments == arguments.count());

   278     QVERIFY(ClirOn == arguments.at(0).value<PsCallLineIdentity>());

   279 }

   280 

   281 /*!

   282   UT_PSetCliWrapper::t_handleCliStatus

   283  */

   284 Q_DECLARE_METATYPE(unsigned char *)

   285 void UT_PSetCliWrapper::t_handleCliStatus()

   286 {

   287     qRegisterMetaType<unsigned char *>("unsigned char *");

   288     QSignalSpy spy(m_wrapper, 

   289         SIGNAL(handleCliStatus(unsigned char *, int, PsCallLineIdentity)));

   290     

   291     TUint8 bscList[KPSetNumberOfBsc] = { EAllTele };

   292     QT_TRAP_THROWING(

   293         m_wrapper->m_privateImpl->HandleCliStatusL(bscList, EPsuiClirOn));

   294     

   295     const int expectednumOfSignalEmissions = 1;

   296     const int expectedNumOfSignalArguments = 3;

   297     QCOMPARE(spy.count(), expectednumOfSignalEmissions);

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

   299     QVERIFY(expectedNumOfSignalArguments == arguments.count());

   300     QVERIFY(EAllTele == arguments.at(0).value<unsigned char *>()[0]);

   301     QVERIFY(KPSetNumberOfBsc == arguments.at(1).toInt());

   302     QVERIFY(ClirOn == arguments.at(2).value<PsCallLineIdentity>());

   303 }

   304 

   305 /*!

   306   UT_PSetCliWrapper::t_handleCnapStatus

   307  */

   308 void UT_PSetCliWrapper::t_handleCnapStatus()

   309 {

   310     QSignalSpy spy(m_wrapper, SIGNAL(handleCnapStatus(int)));

   311     

   312     const int status = 1;

   313     QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleCnapStatusL(status));

   314     

   315     const int expectednumOfSignalEmissions = 1;

   316     const int expectedNumOfSignalArguments = 1;

   317     QCOMPARE(spy.count(), expectednumOfSignalEmissions);

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

   319     QVERIFY(expectedNumOfSignalArguments == arguments.count());

   320     QVERIFY(status == arguments.at(0).toInt());

   321 }

   322 

   323 /*!

   324   UT_PSetCliWrapper::t_handleCliError

   325  */

   326 void UT_PSetCliWrapper::t_handleCliError()

   327 {

   328     QSignalSpy spy(m_wrapper, SIGNAL(handleCliError(int)));

   329     

   330     const int expectedErrorCode = KErrGeneral;

   331     QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleCliErrorL(expectedErrorCode));

   332     

   333     const int expectednumOfSignalEmissions = 1;

   334     const int expectedNumOfSignalArguments = 1;

   335     QCOMPARE(spy.count(), expectednumOfSignalEmissions);

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

   337     QVERIFY(expectedNumOfSignalArguments == arguments.count());

   338     QVERIFY(expectedErrorCode == arguments.at(0).toInt());

   339 }

   340 

   341 /*!

   342   UT_PSetCliWrapper::t_setEngineContact

   343  */

   344 void UT_PSetCliWrapper::t_setEngineContact()

   345 {

   346     // dummy test as no real implementation for the method currently

   347     m_wrapper->m_privateImpl->SetEngineContact(NULL);

   348 }

   349 

   350 /*!

   351   UT_PSetCliWrapper::t_exceptionSafety

   352  */

   353 void UT_PSetCliWrapper::t_exceptionSafety()

   354 {

   355     cleanup();

   356     

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

   358 }

   359 

   360 void UT_PSetCliWrapper::SimulateLeaveAtMockMethodCallL()

   361 {

   362     m_numOfLeaveSimulations++;

   363     User::Leave( KErrGeneral );

   364 }

   365 

   366 QTEST_MAIN_S60(UT_PSetCliWrapper)