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();

   106     

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

   108     m_callspluginGroup->showCallDurationStateChanged();

   109     

   110     QVERIFY(verify());

   111 }

   112 

   113 /*!

   114   UT_CpCallsPluginGroup::t_callWaitingCurrentIndexChanged

   115  */

   116 void UT_CpCallsPluginGroup::t_callWaitingCurrentIndexChanged()

   117 {

   118     QList<unsigned char> basicServiceGroupIds;

   119 

   120     // check status case

   121     EXPECT(PSetCallWaitingWrapper::getCallWaitingStatus);

   122     m_callspluginGroup->callWaitingCurrentIndexChanged();

   123 

   124     // active case

   125     m_callspluginGroup->handleCallWaitingGetStatus(

   126         PSetCallWaitingWrapper::StatusActive, basicServiceGroupIds);

   127     EXPECT(PSetCallWaitingWrapper::setCallWaiting);

   128     m_callspluginGroup->callWaitingCurrentIndexChanged();

   129 

   130     // deactive case

   131     m_callspluginGroup->handleCallWaitingGetStatus(

   132         PSetCallWaitingWrapper::StatusDisabled, basicServiceGroupIds);

   133     EXPECT(PSetCallWaitingWrapper::setCallWaiting);

   134     m_callspluginGroup->callWaitingCurrentIndexChanged();

   135 

   136     QVERIFY(verify());

   137 }

   138 

   139 /*!

   140   UT_CpCallsPluginGroup::t_cliCurrentIndexChanged

   141  */

   142 void UT_CpCallsPluginGroup::t_cliCurrentIndexChanged()

   143 {

   144     EXPECT(SsSettingsWrapper::set);

   145     m_callspluginGroup->cliCurrentIndexChanged(1);

   146     

   147     QVERIFY(verify());

   148     reset();

   149     

   150     //Do nothing, index is out of range

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

   152     m_callspluginGroup->cliCurrentIndexChanged(-1);

   153     

   154     QVERIFY(verify());

   155 }

   156 

   157 /*!

   158   UT_CpCallsPluginGroup::t_handleCallWaitingChanged

   159  */

   160 void UT_CpCallsPluginGroup::t_handleCallWaitingChanged()

   161 {

   162     EXPECT(CpPhoneNotes::cancelNote);

   163     EXPECT(CpPhoneNotes::showGlobalNote);

   164     m_callspluginGroup->handleCallWaitingChanged(

   165         PSetCallWaitingWrapper::ActivateCallWaiting , 0);

   166     

   167     EXPECT(CpPhoneNotes::cancelNote);

   168     EXPECT(CpPhoneNotes::showGlobalNote);

   169     m_callspluginGroup->handleCallWaitingChanged(

   170         PSetCallWaitingWrapper::DeactivateCallWaiting, 0);

   171     

   172     EXPECT(CpPhoneNotes::cancelNote);

   173     EXPECT(CpPhoneNotes::showGlobalNote);

   174     m_callspluginGroup->handleCallWaitingChanged(

   175         PSetCallWaitingWrapper::CheckCallWaitingStatus, 0);

   176     

   177     EXPECT(CpPhoneNotes::cancelNote);

   178     EXPECT(CpPhoneNotes::showGlobalNote);

   179     m_callspluginGroup->handleCallWaitingChanged(

   180         PSetCallWaitingWrapper::DeactivateCallWaiting , -1);

   181     

   182     QVERIFY(verify());

   183 }

   184 

   185 /*!

   186   UT_CpCallsPluginGroup::t_handleCallWaitingRequesting

   187  */

   188 void UT_CpCallsPluginGroup::t_handleCallWaitingRequesting()

   189 {

   190     EXPECT(CpPhoneNotes::cancelNote);

   191     m_callspluginGroup->handleCallWaitingRequesting( false, true ); 

   192     

   193     EXPECT(CpPhoneNotes::showGlobalProgressNote);

   194     m_callspluginGroup->handleCallWaitingRequesting( true, false );

   195     

   196     EXPECT(CpPhoneNotes::cancelNote);

   197     EXPECT(CpPhoneNotes::showGlobalProgressNote);

   198 //    m_callspluginGroup->handleCallWaitingRequesting( true, true );

   199 

   200 //    QVERIFY(verify());

   201     reset();

   202     

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

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

   205     m_callspluginGroup->handleCallWaitingRequesting( false, false );

   206     

   207     QVERIFY(verify());

   208 }

   209 

   210 /*!

   211   UT_CpCallsPluginGroup::t_handleCallWaitingError

   212  */

   213 void UT_CpCallsPluginGroup::t_handleCallWaitingError()

   214 {

   215     EXPECT(CpPhoneNotes::cancelNote);

   216     EXPECT(CpPhoneNotes::showGlobalErrorNote);

   217     m_callspluginGroup->handleCallWaitingError( -1 );

   218     

   219     QVERIFY(verify());

   220 }

   221 

   222 /*!

   223   UT_CpCallsPluginGroup::t_softRejectTextChanged

   224  */

   225 void UT_CpCallsPluginGroup::t_softRejectTextChanged()

   226 {

   227     int iRet=0;

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

   229     m_callspluginGroup->softRejectTextChanged();

   230     

   231     QVERIFY(verify());

   232 }

   233 

   234 /*!

   235   UT_CpCallsPluginGroup::t_handleCallWaitingGetStatus

   236  */

   237 void UT_CpCallsPluginGroup::t_handleCallWaitingGetStatus()

   238 {

   239     QList<unsigned char> basicServiceGroupIds;

   240     

   241     EXPECT(CpPhoneNotes::cancelNote);

   242     m_callspluginGroup->handleCallWaitingGetStatus(

   243         PSetCallWaitingWrapper::StatusNotProvisioned, basicServiceGroupIds);

   244     

   245     EXPECT(CpPhoneNotes::cancelNote);

   246     m_callspluginGroup->handleCallWaitingGetStatus(

   247         PSetCallWaitingWrapper::StatusActive, basicServiceGroupIds);

   248     QVERIFY(verify());

   249 }

   250 

   251 /*!

   252   UT_CpCallsPluginGroup::t_handleCallWaitingGetStatusDistinguishEnabled

   253  */

   254 void UT_CpCallsPluginGroup::t_handleCallWaitingGetStatusDistinguishEnabled()

   255 {

   256     QList<unsigned char> basicServiceGroupIds;

   257     

   258     EXPECT(CpPhoneNotes::cancelNote);

   259     EXPECT(CpPhoneNotes::showGlobalNote);

   260     m_callspluginGroup->handleCallWaitingGetStatus(

   261         PSetCallWaitingWrapper::StatusNotProvisioned, basicServiceGroupIds);

   262     

   263     QVERIFY(verify());

   264 }

   265 

   266 /*!

   267   UT_CpCallsPluginGroup::cleanup

   268  */

   269 void UT_CpCallsPluginGroup::cleanup()

   270 {

   271     reset();

   272     

   273     delete m_callspluginGroup;

   274     m_callspluginGroup = NULL;

   275 }

   276 

   277 /*!

   278   UT_CpCallsPluginGroup::t_memleak

   279  */

   280 void UT_CpCallsPluginGroup::t_memleak()

   281 {

   282     

   283 }

   284 

   285 QTEST_MAIN_S60(UT_CpCallsPluginGroup)