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:  Unit tests for PhoneResourceAdapter.

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include <QtGui>

    20 #include <hbapplication.h>

    21 #include <QSignalSpy>

    22 #include <QVariant>

    23 #include <mockservice.h>

    24 #include <cpeengineinfo.h>

    25 #include <pevirtualengine.h>

    26 #include "qtestmains60.h"

    27 #include "phonecallheadermanager.h"

    28 #include "phoneuiqtviewif_stub.h"

    29 #include "bubblemanagerif_stub.h"

    30 #include "phonebubblewrapper.h"

    31 #include "phonecallheaderutil.h"

    32 

    33 class TestPhoneCallHeaderManager : public QObject, MockService

    34 {

    35     Q_OBJECT

    36 public:

    37     TestPhoneCallHeaderManager();

    38     virtual ~TestPhoneCallHeaderManager();

    39 

    40 public slots:

    41     void initTestCase();

    42     void cleanupTestCase();

    43     void init();

    44     void cleanup(); 

    45     

    46 private slots:

    47     void testCreateCallHeader();

    48     void testCreateEmergencyCallHeader();

    49     void testRemoveCallHeader();

    50     void testUpdateCallHeaderState();

    51     void testUpdateCallHeaderRemoteInfo();

    52     void testUpdateCallHeaderRemoteInfoAndLabel();

    53     void testHandleCipheringInfoChange();

    54     void testConferenceBubble();

    55     void testExpandedConferenceCallHeader();

    56     void testRemoveAllCallHeaders();

    57     void testIsVideoCall();

    58 

    59 private:

    60     

    61 private:

    62     BubbleManagerIFStub *mBubbleManagerIFStub;

    63     PhoneUIQtViewIFStub *mPhoneUIQtViewIFStub;

    64     PhoneBubbleWrapper *mPhoneBubbleWrapper;

    65     CPEEngineInfo *iEngineInfo;

    66     PhoneCallHeaderManager *mCallHeaderManager; // class under test

    67 };

    68 

    69 TestPhoneCallHeaderManager::TestPhoneCallHeaderManager ()

    70 {

    71 }

    72 

    73 TestPhoneCallHeaderManager::~TestPhoneCallHeaderManager ()

    74 {

    75 }

    76 

    77 void TestPhoneCallHeaderManager::initTestCase ()

    78 {

    79     mBubbleManagerIFStub =  new BubbleManagerIFStub();

    80     mPhoneUIQtViewIFStub = new PhoneUIQtViewIFStub(*mBubbleManagerIFStub);

    81     TRAP_IGNORE( iEngineInfo = CPEEngineInfo::NewL());

    82     mPhoneBubbleWrapper = new PhoneBubbleWrapper(*mBubbleManagerIFStub);

    83     mCallHeaderManager = new PhoneCallHeaderManager(

    84             *mPhoneBubbleWrapper, *mPhoneUIQtViewIFStub);

    85     

    86     mCallHeaderManager->setEngineInfo(iEngineInfo);

    87 }

    88 

    89 void TestPhoneCallHeaderManager::cleanupTestCase ()

    90 {

    91     delete mCallHeaderManager;

    92     delete mPhoneUIQtViewIFStub;

    93     delete mBubbleManagerIFStub;

    94     delete mPhoneBubbleWrapper;

    95     delete iEngineInfo;

    96 }

    97 

    98 void TestPhoneCallHeaderManager::init ()

    99 {

   100     initialize();

   101 }

   102 

   103 void TestPhoneCallHeaderManager::cleanup ()

   104 {

   105     reset();

   106 }

   107 

   108 void TestPhoneCallHeaderManager::testCreateCallHeader ()

   109 {

   110     int callId = 1;

   111     iEngineInfo->SetCallState(EPEStateRinging, callId );

   112     

   113     EXPECT( PhoneCallHeaderUtil, SetIncomingCallHeaderParams);

   114     EXPECT( PhoneBubbleWrapper, createCallHeader);

   115     mCallHeaderManager->createCallHeader(callId);

   116     QVERIFY(verify());

   117     

   118     iEngineInfo->SetCallState(EPEStateConnecting, callId );

   119     mIsConferenceExpanded = true;

   120     mSetExpandedConferenceCalled = false;

   121     

   122     EXPECT( PhoneCallHeaderUtil, SetOutgoingCallHeaderParams);

   123     mCallHeaderManager->createCallHeader(callId);

   124     QVERIFY(verify());

   125     QVERIFY(mSetExpandedConferenceCalled);

   126     

   127     mSetExpandedConferenceCalled = false;

   128     mIsConferenceExpanded = false;

   129 }

   130 

   131 void TestPhoneCallHeaderManager::testCreateEmergencyCallHeader()

   132 {

   133     int callId = 1;

   134 

   135     EXPECT( PhoneBubbleWrapper, createCallHeader);

   136     EXPECT( PhoneBubbleWrapper, setLabel);

   137     EXPECT( PhoneBubbleWrapper, setCli);

   138     EXPECT( PhoneBubbleWrapper, setCiphering);

   139     mCallHeaderManager->createEmergencyCallHeader(callId);

   140     QVERIFY(verify());

   141 }

   142 

   143 void TestPhoneCallHeaderManager::testRemoveCallHeader()

   144 {

   145     int callId = 1;

   146     int bubbleId = 1;

   147     QMap<int,int> bubbleMap;

   148     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);

   149     EXPECT( PhoneBubbleWrapper, removeCallHeader).times(0);

   150     mCallHeaderManager->removeCallHeader(callId);

   151     QVERIFY(verify());

   152     reset();

   153     

   154     bubbleMap.insert(callId, bubbleId);

   155 

   156     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);

   157     EXPECT( PhoneBubbleWrapper, removeCallHeader).with(callId);

   158     mCallHeaderManager->removeCallHeader(callId);

   159     QVERIFY(verify());

   160     reset();

   161 }

   162 

   163 void TestPhoneCallHeaderManager::testUpdateCallHeaderState()

   164 {

   165     int callId = 1;

   166     int bubbleId = -1;

   167     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   168     EXPECT( PhoneBubbleWrapper, setState).times(0);

   169     mCallHeaderManager->updateCallHeaderState(callId);

   170     QVERIFY(verify());

   171     reset();

   172     

   173     bubbleId = 1;

   174 

   175     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   176     EXPECT( PhoneBubbleWrapper, setState).times(1);

   177     mCallHeaderManager->updateCallHeaderState(callId);

   178     QVERIFY(verify());

   179     reset();

   180 }

   181 

   182 void TestPhoneCallHeaderManager::testUpdateCallHeaderRemoteInfo()

   183 {

   184     int callId = 1;

   185     int bubbleId = -1;

   186     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   187     EXPECT( PhoneBubbleWrapper, setCli).times(0);

   188     mCallHeaderManager->updateCallHeaderRemoteInfo(callId);

   189     QVERIFY(verify());

   190     reset();

   191     

   192     bubbleId = 1;

   193 

   194     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   195     EXPECT( PhoneBubbleWrapper, setCli).times(1);

   196     mCallHeaderManager->updateCallHeaderRemoteInfo(callId);

   197     QVERIFY(verify());

   198     reset();

   199 }

   200 

   201 void TestPhoneCallHeaderManager::testUpdateCallHeaderRemoteInfoAndLabel()

   202 {

   203     int callId = 1;

   204     int bubbleId = -1;

   205     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   206     EXPECT( PhoneBubbleWrapper, setLabel).times(0);

   207     mCallHeaderManager->updateCallHeaderRemoteInfoAndLabel(callId);

   208     QVERIFY(verify());

   209     reset();

   210     

   211     bubbleId = 1;

   212 

   213     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   214     EXPECT( PhoneBubbleWrapper, setLabel).times(1);

   215     mCallHeaderManager->updateCallHeaderRemoteInfoAndLabel(callId);

   216     QVERIFY(verify());

   217     reset();

   218 }

   219 

   220 void TestPhoneCallHeaderManager::testHandleCipheringInfoChange()

   221 {

   222     iEngineInfo->SetCallSecureStatus( ETrue, 0 );

   223     iEngineInfo->SetCallSecureStatus( EFalse, 1 );

   224     int callId = KPEConferenceCallID;

   225     int bubbleId = -1;

   226     QList<int> conferenceList;

   227     conferenceList.append(0);

   228     conferenceList.append(1);

   229     EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);

   230     EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);

   231     EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);

   232     EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);

   233     EXPECT( PhoneBubbleWrapper, setCiphering);

   234     mCallHeaderManager->handleCipheringInfoChange(callId);

   235     QVERIFY(verify());

   236     reset();

   237     

   238     callId = 1;

   239 

   240     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   241     EXPECT( PhoneBubbleWrapper, setCiphering).times(0);

   242     mCallHeaderManager->handleCipheringInfoChange(callId);

   243     QVERIFY(verify());

   244     reset();

   245     

   246     bubbleId = 1;

   247     

   248     EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);

   249     EXPECT( PhoneBubbleWrapper, setCiphering);

   250     mCallHeaderManager->handleCipheringInfoChange(callId);

   251     QVERIFY(verify());

   252     reset();

   253 }

   254 

   255 void TestPhoneCallHeaderManager::testConferenceBubble()

   256 {

   257     int callId = 7;

   258     EXPECT( PhoneBubbleWrapper, createConferenceBubble);

   259     mCallHeaderManager->createConferenceBubble(callId);

   260     QVERIFY(verify());

   261     reset();

   262     

   263     EXPECT( PhoneBubbleWrapper, removeConferenceBubble);

   264     mCallHeaderManager->removeConferenceBubble();

   265     QVERIFY(verify());

   266     reset();

   267     

   268     QMap<int,int> bubbleMap;

   269     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);

   270     EXPECT( PhoneBubbleWrapper, removeCallHeader).with(callId);

   271     mCallHeaderManager->removeCallFromConference(callId);

   272     QVERIFY(verify());

   273     reset();

   274     

   275     EXPECT( PhoneBubbleWrapper, removeCallFromConference).with(callId);

   276     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);

   277     mCallHeaderManager->setPrivateFromConference(callId);

   278     QVERIFY(verify());

   279     reset();

   280 }

   281 

   282 void TestPhoneCallHeaderManager::testExpandedConferenceCallHeader()

   283 {

   284 

   285     QMap<int,int> bubbleMap;

   286     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap).times(2);    

   287     mCallHeaderManager->setExpandedConferenceCallHeader();

   288     QVERIFY(verify());

   289     QVERIFY(false == mIsExpandedConference);

   290     reset();

   291     

   292     bubbleMap.insert(1, 2);

   293     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);

   294     EXPECT( PhoneBubbleWrapper, callIdByBubbleId).returns(KConferenceCallId);

   295     mCallHeaderManager->setExpandedConferenceCallHeader();

   296     QVERIFY(verify());

   297     QVERIFY(true == mIsExpandedConference);

   298     reset();

   299 }

   300 

   301 void TestPhoneCallHeaderManager::testRemoveAllCallHeaders()

   302 {

   303 

   304     QList<int> conferenceListMap;

   305     QMap<int,int> bubbleMap;

   306     EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceListMap);

   307     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);    

   308     mCallHeaderManager->removeAllCallHeaders();

   309     QVERIFY(verify());

   310     reset();

   311     

   312     conferenceListMap.append(1);

   313     bubbleMap.insert(1,1);

   314     bubbleMap.insert(KEmergencyCallId, KEmergencyCallId);

   315     

   316     EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceListMap);

   317     EXPECT( PhoneBubbleWrapper, removeConferenceBubble);

   318     EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap).times(2);

   319     EXPECT( PhoneBubbleWrapper, removeCallHeader).with(1);

   320     mCallHeaderManager->removeAllCallHeaders();

   321     QVERIFY(verify());

   322     reset();

   323 }

   324 

   325 void TestPhoneCallHeaderManager::testIsVideoCall()

   326 {

   327     iEngineInfo->SetCallTypeCommand(EPECallTypeVideo);

   328     QVERIFY(mCallHeaderManager->isVideoCall( -1 ));

   329     

   330     iEngineInfo->SetCallTypeCommand(EPECallTypeVoIP);

   331     QVERIFY(false == mCallHeaderManager->isVideoCall( -1 ));

   332 

   333     int callId = 1;

   334     iEngineInfo->SetCallType(EPECallTypeVoIP, callId);

   335     QVERIFY(false == mCallHeaderManager->isVideoCall( callId ));

   336     

   337     iEngineInfo->SetCallType(EPECallTypeVideo, callId);

   338     QVERIFY(mCallHeaderManager->isVideoCall( callId ));

   339 }

   340 

   341 QTEST_MAIN_S60(TestPhoneCallHeaderManager)

   342 #include "unit_tests.moc"