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 "ut_callsplugingroup.h"

    19 #include "cpcallsplugingroup.h"

    20 #include "cpitemdatahelper.h"

    21 #include "qtestmains60.h"

    22 // mocked dependencies for the class under test

    23 #include "psetwrapper.h"

    24 #include "sssettingswrapper.h"

    25 #include "cpplugincommon.h"

    26 #include "cpphonenotes.h"

    27 

    28 /*!

    29   Dummy CPsetContainer class

    30  */

    31 class CPsetContainer

    32     {

    33 public:

    34     CPsetContainer(){};

    35     ~CPsetContainer(){};

    36     };

    37 

    38 /*!

    39   UT_CpCallsPluginGroup::UT_CpCallsPluginGroup

    40  */

    41 UT_CpCallsPluginGroup::UT_CpCallsPluginGroup() 

    42     : m_callspluginGroup(NULL)

    43 {

    44 

    45 }

    46 

    47 /*!

    48   UT_CpCallsPluginGroup::~UT_CpCallsPluginGroup

    49  */

    50 UT_CpCallsPluginGroup::~UT_CpCallsPluginGroup()

    51 {

    52     delete m_callspluginGroup;

    53 }

    54 

    55 /*!

    56   UT_CpCallsPluginGroup::init

    57  */

    58 void UT_CpCallsPluginGroup::init()

    59 {

    60     initialize();

    61     

    62     CpItemDataHelper itemDataHelper;

    63     CPsetContainer cont;

    64     PSetCallWaitingWrapper waitingWrapper(cont);

    65     

    66     EXPECT(PSetWrapper::callWaitingWrapper).returns(&waitingWrapper);

    67     

    68     static bool b=0;//CenrepKeyValueOff;

    69     if (b==0) {

    70         b=1;//CenrepKeyValueOn

    71     } else {

    72         b=0;

    73     }

    74     EXPECT(CpSettingsWrapper::showCallDuration).returns(b);

    75     

    76     static int i=0;//No Errors

    77     if (i==0) {

    78         i=1;//Error

    79     } else {

    80         i=0;

    81     }

    82     EXPECT(SsSettingsWrapper::get).returns(i); 

    83     

    84     EXPECT(CpSettingsWrapper::readSoftRejectText);

    85 

    86     if (qstrcmp(QTest::currentTestFunction(), 

    87         "t_handleCallWaitingGetStatusDistinguishEnabled") == 0) {

    88         EXPECT(

    89             CpSettingsWrapper::isFeatureCallWaitingDistiquishNotProvisionedEnabled)

    90             .returns(true);

    91     }

    92     

    93     m_callspluginGroup = new CpCallsPluginGroup(itemDataHelper);

    94     QVERIFY(verify());

    95 }

    96 

    97 /*!

    98   UT_CpCallsPluginGroup::t_showCallDurationStateChanged

    99  */

   100 void UT_CpCallsPluginGroup::t_showCallDurationStateChanged()

   101 {

   102     int iRet=0;

   103     

   104     EXPECT(CpSettingsWrapper::setShowCallDuration).returns(iRet);

   105     m_callspluginGroup->showCallDurationStateChanged(Qt::Checked);

   106     

   107     EXPECT(CpSettingsWrapper::setShowCallDuration).returns(iRet);

   108     m_callspluginGroup->showCallDurationStateChanged(Qt::Unchecked);

   109     

   110     QVERIFY(verify());

   111 }

   112 

   113 /*!

   114   UT_CpCallsPluginGroup::t_callWaitingCurrentIndexChanged

   115  */

   116 void UT_CpCallsPluginGroup::t_callWaitingCurrentIndexChanged()

   117 {

   118     EXPECT(PSetCallWaitingWrapper::setCallWaiting);

   119     m_callspluginGroup->callWaitingCurrentIndexChanged \

   120             (PSetCallWaitingWrapper::ActivateCallWaiting);

   121     

   122     EXPECT(PSetCallWaitingWrapper::setCallWaiting);

   123     m_callspluginGroup->callWaitingCurrentIndexChanged \

   124             (PSetCallWaitingWrapper::DeactivateCallWaiting);

   125     

   126     EXPECT(PSetCallWaitingWrapper::getCallWaitingStatus);

   127     m_callspluginGroup->callWaitingCurrentIndexChanged \

   128             (PSetCallWaitingWrapper::CheckCallWaitingStatus);

   129     

   130     QVERIFY(verify());

   131     reset();

   132     

   133     //Error, negative index , do nothing

   134     EXPECT(PSetCallWaitingWrapper::setCallWaiting).times(0);

   135     m_callspluginGroup->callWaitingCurrentIndexChanged(-1);

   136     //Do nothing, index is out of range

   137     EXPECT(PSetCallWaitingWrapper::setCallWaiting).times(0);

   138     m_callspluginGroup->callWaitingCurrentIndexChanged \

   139                 (PSetCallWaitingWrapper::CheckCallWaitingStatus + 100);

   140     

   141     QVERIFY(verify());

   142 }

   143 

   144 /*!

   145   UT_CpCallsPluginGroup::t_cliCurrentIndexChanged

   146  */

   147 void UT_CpCallsPluginGroup::t_cliCurrentIndexChanged()

   148 {

   149     EXPECT(SsSettingsWrapper::set);

   150     m_callspluginGroup->cliCurrentIndexChanged(1);

   151     

   152     QVERIFY(verify());

   153     reset();

   154     

   155     //Do nothing, index is out of range

   156     EXPECT(PSetCallWaitingWrapper::setCallWaiting).times(0);

   157     m_callspluginGroup->cliCurrentIndexChanged(-1);

   158     

   159     QVERIFY(verify());

   160 }

   161 

   162 /*!

   163   UT_CpCallsPluginGroup::t_handleCallWaitingChanged

   164  */

   165 void UT_CpCallsPluginGroup::t_handleCallWaitingChanged()

   166 {

   167     EXPECT(CpPhoneNotes::cancelNote);

   168     EXPECT(CpPhoneNotes::showGlobalNote);

   169     m_callspluginGroup->handleCallWaitingChanged(

   170         PSetCallWaitingWrapper::ActivateCallWaiting , 0);

   171     

   172     EXPECT(CpPhoneNotes::cancelNote);

   173     EXPECT(CpPhoneNotes::showGlobalNote);

   174     m_callspluginGroup->handleCallWaitingChanged(

   175         PSetCallWaitingWrapper::DeactivateCallWaiting, 0);

   176     

   177     EXPECT(CpPhoneNotes::cancelNote);

   178     EXPECT(CpPhoneNotes::showGlobalNote);

   179     m_callspluginGroup->handleCallWaitingChanged(

   180         PSetCallWaitingWrapper::CheckCallWaitingStatus, 0);

   181     

   182     EXPECT(CpPhoneNotes::cancelNote);

   183     EXPECT(CpPhoneNotes::showGlobalNote);

   184     m_callspluginGroup->handleCallWaitingChanged(

   185         PSetCallWaitingWrapper::DeactivateCallWaiting , -1);

   186     

   187     QVERIFY(verify());

   188 }

   189 

   190 /*!

   191   UT_CpCallsPluginGroup::t_handleCallWaitingRequesting

   192  */

   193 void UT_CpCallsPluginGroup::t_handleCallWaitingRequesting()

   194 {

   195     EXPECT(CpPhoneNotes::cancelNote);

   196     m_callspluginGroup->handleCallWaitingRequesting( false, true ); 

   197     

   198     EXPECT(CpPhoneNotes::showGlobalProgressNote);

   199     m_callspluginGroup->handleCallWaitingRequesting( true, false );

   200     

   201     EXPECT(CpPhoneNotes::cancelNote);

   202     EXPECT(CpPhoneNotes::showGlobalProgressNote);

   203     m_callspluginGroup->handleCallWaitingRequesting( true, true );

   204 

   205     QVERIFY(verify());

   206     reset();

   207     

   208     EXPECT(CpPhoneNotes::cancelNote).times(0);

   209     EXPECT(CpPhoneNotes::showGlobalProgressNote).times(0);

   210     m_callspluginGroup->handleCallWaitingRequesting( false, false );

   211     

   212     QVERIFY(verify());

   213 }

   214 

   215 /*!

   216   UT_CpCallsPluginGroup::t_handleCallWaitingError

   217  */

   218 void UT_CpCallsPluginGroup::t_handleCallWaitingError()

   219 {

   220     EXPECT(CpPhoneNotes::cancelNote);

   221     EXPECT(CpPhoneNotes::showGlobalErrorNote);

   222     m_callspluginGroup->handleCallWaitingError( -1 );

   223     

   224     QVERIFY(verify());

   225 }

   226 

   227 /*!

   228   UT_CpCallsPluginGroup::t_softRejectTextChanged

   229  */

   230 void UT_CpCallsPluginGroup::t_softRejectTextChanged()

   231 {

   232     int iRet=0;

   233     EXPECT(CpSettingsWrapper::writeSoftRejectText).returns(iRet);

   234     m_callspluginGroup->softRejectTextChanged();

   235     

   236     QVERIFY(verify());

   237 }

   238 

   239 /*!

   240   UT_CpCallsPluginGroup::t_handleCallWaitingGetStatus

   241  */

   242 void UT_CpCallsPluginGroup::t_handleCallWaitingGetStatus()

   243 {

   244     QList<unsigned char> basicServiceGroupIds;

   245     

   246     EXPECT(CpPhoneNotes::cancelNote);

   247     EXPECT(CpPhoneNotes::showGlobalNote);

   248     m_callspluginGroup->handleCallWaitingGetStatus(

   249         PSetCallWaitingWrapper::StatusNotProvisioned, basicServiceGroupIds);

   250     

   251     EXPECT(CpPhoneNotes::cancelNote);

   252     EXPECT(CpPhoneNotes::showGlobalNote);

   253     m_callspluginGroup->handleCallWaitingGetStatus(

   254         PSetCallWaitingWrapper::StatusActive, basicServiceGroupIds);

   255     

   256     EXPECT(CpPhoneNotes::cancelNote);

   257     EXPECT(CpPhoneNotes::showBasicServiceList);

   258     basicServiceGroupIds << 0;

   259     m_callspluginGroup->handleCallWaitingGetStatus(

   260         PSetCallWaitingWrapper::StatusActive, basicServiceGroupIds);

   261     

   262     QVERIFY(verify());

   263 }

   264 

   265 /*!

   266   UT_CpCallsPluginGroup::t_handleCallWaitingGetStatusDistinguishEnabled

   267  */

   268 void UT_CpCallsPluginGroup::t_handleCallWaitingGetStatusDistinguishEnabled()

   269 {

   270     QList<unsigned char> basicServiceGroupIds;

   271     

   272     EXPECT(CpPhoneNotes::cancelNote);

   273     EXPECT(CpPhoneNotes::showGlobalNote);

   274     m_callspluginGroup->handleCallWaitingGetStatus(

   275         PSetCallWaitingWrapper::StatusNotProvisioned, basicServiceGroupIds);

   276     

   277     QVERIFY(verify());

   278 }

   279 

   280 /*!

   281   UT_CpCallsPluginGroup::cleanup

   282  */

   283 void UT_CpCallsPluginGroup::cleanup()

   284 {

   285     reset();

   286     

   287     delete m_callspluginGroup;

   288     m_callspluginGroup = NULL;

   289 }

   290 

   291 /*!

   292   UT_CpCallsPluginGroup::t_memleak

   293  */

   294 void UT_CpCallsPluginGroup::t_memleak()

   295 {

   296     

   297 }

   298 

   299 QTEST_MAIN_S60(UT_CpCallsPluginGroup)