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 /*

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

     8 * All rights reserved.

     9 * This component and the accompanying materials are made available

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

    11 * which accompanies this distribution, and is available

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

    13 *

    14 * Initial Contributors:

    15 * Nokia Corporation - initial contribution.

    16 *

    17 * Contributors:

    18 *

    19 * Description:

    20 *

    21 */

    22 

    23 #include "ut_psuiwaitingnotehandler.h"

    24 #include "psuiwaitingnotehandler.h"

    25 #include "psetcallwaitingwrapper.h"

    26 #include "qtestmains60.h"

    27 #include <smcmockclassincludes.h>

    28 

    29 class CPsetContainer

    30 {

    31 public:

    32     CPsetContainer(){};

    33     ~CPsetContainer(){};

    34 };

    35 

    36 /*!

    37   UT_psuiwaitingnotehandler::UT_psuiwaitingnotehandler

    38  */

    39 UT_psuiwaitingnotehandler::UT_psuiwaitingnotehandler() 

    40 {

    41     

    42 }

    43 

    44 /*!

    45   UT_psuiwaitingnotehandler::~UT_psuiwaitingnotehandler

    46  */

    47 UT_psuiwaitingnotehandler::~UT_psuiwaitingnotehandler()

    48 {

    49     

    50 }

    51 

    52 /*!

    53   UT_psuiwaitingnotehandler::init

    54  */

    55 void UT_psuiwaitingnotehandler::init()

    56 {

    57     initialize();

    58     m_psetContainer = new CPsetContainer();

    59     m_mockWaitingWrapper = new PSetCallWaitingWrapper(*m_psetContainer,this);

    60     m_waitingHandler = new PsUiWaitingNoteHandler(*m_mockWaitingWrapper);

    61 }

    62 

    63 /*!

    64   UT_psuiwaitingnotehandler::cleanup

    65  */

    66 void UT_psuiwaitingnotehandler::cleanup()

    67 {

    68     delete m_waitingHandler;

    69     delete m_mockWaitingWrapper;   

    70     delete m_psetContainer;

    71     reset();

    72 }

    73 

    74 /*!

    75   UT_psuiwaitingnotehandler::t_memleak

    76  */

    77 void UT_psuiwaitingnotehandler::t_memleak()

    78 {

    79     

    80 }

    81 

    82 /*!

    83   UT_psuiwaitingnotehandler::t_construction

    84  */

    85 void UT_psuiwaitingnotehandler::t_construction()

    86 {

    87     expect("QObject::connect").times(4);

    88     CPsetContainer psetContainer;

    89     PSetCallWaitingWrapper *mockWaitingWrapper = new PSetCallWaitingWrapper(psetContainer,this);

    90     PsUiWaitingNoteHandler *waitingHandler = new PsUiWaitingNoteHandler(*mockWaitingWrapper);

    91     delete waitingHandler;

    92     delete mockWaitingWrapper;

    93     QVERIFY(verify());

    94 }

    95 

    96 void UT_psuiwaitingnotehandler::t_handleCallWaitingGetStatus()

    97 {

    98     

    99     PSetCallWaitingWrapper::PsCallWaitingStatus status = 

   100             PSetCallWaitingWrapper::StatusNotProvisioned;

   101     QList<unsigned char> serviceGroups;

   102     expect("PsUiNotes::cancelNote");

   103     expect("PsUiSettingsWrapper::isFeatureCallWaitingDistiquishNotProvisionedEnabled").returns(true);

   104     expect("PsUiNotes::showGlobalNotificationDialog");

   105     m_waitingHandler->handleCallWaitingGetStatus(status,serviceGroups);

   106     QVERIFY(verify());

   107     

   108     status = PSetCallWaitingWrapper::StatusActive;

   109     expect("PsUiNotes::showGlobalNotificationDialog");

   110     m_waitingHandler->handleCallWaitingGetStatus(status,serviceGroups);

   111     QVERIFY(verify());

   112     

   113     status = PSetCallWaitingWrapper::StatusDisabled;

   114     expect("PsUiNotes::showGlobalNotificationDialog");

   115     m_waitingHandler->handleCallWaitingGetStatus(status,serviceGroups);

   116     QVERIFY(verify());

   117 }

   118 

   119 void UT_psuiwaitingnotehandler::t_handleCallWaitingChanged()

   120 {  

   121     PSetCallWaitingWrapper::PsCallWaitingCommand setting;

   122     int result;

   123     

   124     setting = PSetCallWaitingWrapper::ActivateCallWaiting;

   125     result = true;

   126     expect("PsUiNotes::showGlobalNote");

   127     m_waitingHandler->handleCallWaitingChanged(setting,result);

   128     QVERIFY(verify());

   129     

   130     setting = PSetCallWaitingWrapper::ActivateCallWaiting;

   131     result = false;

   132     expect("PsUiNotes::showGlobalNotificationDialog");

   133     m_waitingHandler->handleCallWaitingChanged(setting,result);

   134     QVERIFY(verify());

   135     

   136     setting = PSetCallWaitingWrapper::DeactivateCallWaiting;

   137     result = false;

   138     expect("PsUiNotes::showGlobalNotificationDialog");

   139     m_waitingHandler->handleCallWaitingChanged(setting,result);

   140     QVERIFY(verify());

   141     

   142     setting = PSetCallWaitingWrapper::CheckCallWaitingStatus;

   143     result = false;

   144     expect("PsUiNotes::showGlobalNotificationDialog");

   145     m_waitingHandler->handleCallWaitingChanged(setting,result);

   146     QVERIFY(verify());

   147 }

   148 

   149 void UT_psuiwaitingnotehandler::t_handleCallWaitingRequesting()

   150 {

   151     expect("PsUiNotes::showGlobalProgressNote");

   152     bool ongoing = true;

   153     bool interrupted = false;

   154     m_waitingHandler->handleCallWaitingRequesting(ongoing,interrupted);

   155     QVERIFY(verify());

   156     

   157     expect("PsUiNotes::cancelNote");

   158     ongoing = false;

   159     interrupted = true;

   160     m_waitingHandler->handleCallWaitingRequesting(ongoing,interrupted);

   161    

   162     QVERIFY(verify()); 

   163 }

   164 

   165 void UT_psuiwaitingnotehandler::t_handleCallWaitingError()

   166 {  

   167     expect("PsUiNotes::cancelNote");

   168     expect("PsUiNotes::showGlobalErrorNote");

   169     int error = -1;

   170     m_waitingHandler->handleCallWaitingError(error);

   171     

   172     QVERIFY(verify());

   173 }

   174 

   175 QTEST_MAIN_S60(UT_psuiwaitingnotehandler)