/*!
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Unit tests for PhoneResourceAdapter.
*
*/
#include <QtTest/QtTest>
#include <QtGui>
#include <hbapplication.h>
#include <QSignalSpy>
#include <QVariant>
#include <mockservice.h>
#include <cpeengineinfo.h>
#include <pevirtualengine.h>
#include "qtestmains60.h"
#include "phonecallheadermanager.h"
#include "phoneuiqtviewif_stub.h"
#include "bubblemanagerif_stub.h"
#include "phonebubblewrapper.h"
#include "phonecallheaderutil.h"
class TestPhoneCallHeaderManager : public QObject, MockService
{
Q_OBJECT
public:
TestPhoneCallHeaderManager();
virtual ~TestPhoneCallHeaderManager();
public slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
private slots:
void testCreateCallHeader();
void testCreateEmergencyCallHeader();
void testRemoveCallHeader();
void testUpdateCallHeaderState();
void testUpdateCallHeaderRemoteInfo();
void testUpdateCallHeaderRemoteInfoAndLabel();
void testHandleCipheringInfoChange();
void testConferenceBubble();
void testExpandedConferenceCallHeader();
void testRemoveAllCallHeaders();
void testIsVideoCall();
private:
private:
BubbleManagerIFStub *mBubbleManagerIFStub;
PhoneUIQtViewIFStub *mPhoneUIQtViewIFStub;
PhoneBubbleWrapper *mPhoneBubbleWrapper;
CPEEngineInfo *iEngineInfo;
PhoneCallHeaderManager *mCallHeaderManager; // class under test
};
TestPhoneCallHeaderManager::TestPhoneCallHeaderManager ()
{
}
TestPhoneCallHeaderManager::~TestPhoneCallHeaderManager ()
{
}
void TestPhoneCallHeaderManager::initTestCase ()
{
mBubbleManagerIFStub = new BubbleManagerIFStub();
mPhoneUIQtViewIFStub = new PhoneUIQtViewIFStub(*mBubbleManagerIFStub);
TRAP_IGNORE( iEngineInfo = CPEEngineInfo::NewL());
mPhoneBubbleWrapper = new PhoneBubbleWrapper(*mBubbleManagerIFStub);
mCallHeaderManager = new PhoneCallHeaderManager(
*mPhoneBubbleWrapper, *mPhoneUIQtViewIFStub);
mCallHeaderManager->setEngineInfo(iEngineInfo);
}
void TestPhoneCallHeaderManager::cleanupTestCase ()
{
delete mCallHeaderManager;
delete mPhoneUIQtViewIFStub;
delete mBubbleManagerIFStub;
delete mPhoneBubbleWrapper;
delete iEngineInfo;
}
void TestPhoneCallHeaderManager::init ()
{
initialize();
}
void TestPhoneCallHeaderManager::cleanup ()
{
reset();
}
void TestPhoneCallHeaderManager::testCreateCallHeader ()
{
int callId = 1;
iEngineInfo->SetCallState(EPEStateRinging, callId );
EXPECT( PhoneCallHeaderUtil, SetIncomingCallHeaderParams);
EXPECT( PhoneBubbleWrapper, createCallHeader);
mCallHeaderManager->createCallHeader(callId);
QVERIFY(verify());
iEngineInfo->SetCallState(EPEStateConnecting, callId );
mIsConferenceExpanded = true;
mSetExpandedConferenceCalled = false;
EXPECT( PhoneCallHeaderUtil, SetOutgoingCallHeaderParams);
mCallHeaderManager->createCallHeader(callId);
QVERIFY(verify());
QVERIFY(mSetExpandedConferenceCalled);
mSetExpandedConferenceCalled = false;
mIsConferenceExpanded = false;
}
void TestPhoneCallHeaderManager::testCreateEmergencyCallHeader()
{
int callId = 1;
EXPECT( PhoneBubbleWrapper, createCallHeader);
EXPECT( PhoneBubbleWrapper, setLabel);
EXPECT( PhoneBubbleWrapper, setCli);
EXPECT( PhoneBubbleWrapper, setCiphering);
mCallHeaderManager->createEmergencyCallHeader(callId);
QVERIFY(verify());
}
void TestPhoneCallHeaderManager::testRemoveCallHeader()
{
int callId = 1;
int bubbleId = 1;
QMap<int,int> bubbleMap;
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);
EXPECT( PhoneBubbleWrapper, removeCallHeader).times(0);
mCallHeaderManager->removeCallHeader(callId);
QVERIFY(verify());
reset();
bubbleMap.insert(callId, bubbleId);
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);
EXPECT( PhoneBubbleWrapper, removeCallHeader).with(callId);
mCallHeaderManager->removeCallHeader(callId);
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testUpdateCallHeaderState()
{
int callId = 1;
int bubbleId = -1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setState).times(0);
mCallHeaderManager->updateCallHeaderState(callId);
QVERIFY(verify());
reset();
bubbleId = 1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setState).times(1);
mCallHeaderManager->updateCallHeaderState(callId);
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testUpdateCallHeaderRemoteInfo()
{
int callId = 1;
int bubbleId = -1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setCli).times(0);
mCallHeaderManager->updateCallHeaderRemoteInfo(callId);
QVERIFY(verify());
reset();
bubbleId = 1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setCli).times(1);
mCallHeaderManager->updateCallHeaderRemoteInfo(callId);
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testUpdateCallHeaderRemoteInfoAndLabel()
{
int callId = 1;
int bubbleId = -1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setLabel).times(0);
mCallHeaderManager->updateCallHeaderRemoteInfoAndLabel(callId);
QVERIFY(verify());
reset();
bubbleId = 1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setLabel).times(1);
mCallHeaderManager->updateCallHeaderRemoteInfoAndLabel(callId);
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testHandleCipheringInfoChange()
{
iEngineInfo->SetCallSecureStatus( ETrue, 0 );
iEngineInfo->SetCallSecureStatus( EFalse, 1 );
int callId = KPEConferenceCallID;
int bubbleId = -1;
QList<int> conferenceList;
conferenceList.append(0);
conferenceList.append(1);
EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);
EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);
EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);
EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceList);
EXPECT( PhoneBubbleWrapper, setCiphering);
mCallHeaderManager->handleCipheringInfoChange(callId);
QVERIFY(verify());
reset();
callId = 1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setCiphering).times(0);
mCallHeaderManager->handleCipheringInfoChange(callId);
QVERIFY(verify());
reset();
bubbleId = 1;
EXPECT( PhoneBubbleWrapper, bubbleId).returns(bubbleId);
EXPECT( PhoneBubbleWrapper, setCiphering);
mCallHeaderManager->handleCipheringInfoChange(callId);
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testConferenceBubble()
{
int callId = 7;
EXPECT( PhoneBubbleWrapper, createConferenceBubble);
mCallHeaderManager->createConferenceBubble(callId);
QVERIFY(verify());
reset();
EXPECT( PhoneBubbleWrapper, removeConferenceBubble);
mCallHeaderManager->removeConferenceBubble();
QVERIFY(verify());
reset();
QMap<int,int> bubbleMap;
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);
EXPECT( PhoneBubbleWrapper, removeCallHeader).with(callId);
mCallHeaderManager->removeCallFromConference(callId);
QVERIFY(verify());
reset();
EXPECT( PhoneBubbleWrapper, removeCallFromConference).with(callId);
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);
mCallHeaderManager->setPrivateFromConference(callId);
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testExpandedConferenceCallHeader()
{
QMap<int,int> bubbleMap;
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap).times(2);
mCallHeaderManager->setExpandedConferenceCallHeader();
QVERIFY(verify());
QVERIFY(false == mIsExpandedConference);
reset();
bubbleMap.insert(1, 2);
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);
EXPECT( PhoneBubbleWrapper, callIdByBubbleId).returns(KConferenceCallId);
mCallHeaderManager->setExpandedConferenceCallHeader();
QVERIFY(verify());
QVERIFY(true == mIsExpandedConference);
reset();
}
void TestPhoneCallHeaderManager::testRemoveAllCallHeaders()
{
QList<int> conferenceListMap;
QMap<int,int> bubbleMap;
EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceListMap);
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap);
mCallHeaderManager->removeAllCallHeaders();
QVERIFY(verify());
reset();
conferenceListMap.append(1);
bubbleMap.insert(1,1);
bubbleMap.insert(KEmergencyCallId, KEmergencyCallId);
EXPECT( PhoneBubbleWrapper, conferenceCallList).returns(conferenceListMap);
EXPECT( PhoneBubbleWrapper, removeConferenceBubble);
EXPECT( PhoneBubbleWrapper, bubbles).returns(bubbleMap).times(2);
EXPECT( PhoneBubbleWrapper, removeCallHeader).with(1);
mCallHeaderManager->removeAllCallHeaders();
QVERIFY(verify());
reset();
}
void TestPhoneCallHeaderManager::testIsVideoCall()
{
iEngineInfo->SetCallTypeCommand(EPECallTypeVideo);
QVERIFY(mCallHeaderManager->isVideoCall( -1 ));
iEngineInfo->SetCallTypeCommand(EPECallTypeVoIP);
QVERIFY(false == mCallHeaderManager->isVideoCall( -1 ));
int callId = 1;
iEngineInfo->SetCallType(EPECallTypeVoIP, callId);
QVERIFY(false == mCallHeaderManager->isVideoCall( callId ));
iEngineInfo->SetCallType(EPECallTypeVideo, callId);
QVERIFY(mCallHeaderManager->isVideoCall( callId ));
}
QTEST_MAIN_S60(TestPhoneCallHeaderManager)
#include "unit_tests.moc"