cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetcalldivertingwrapper/ut_psetcalldivertingwrapper.cpp
/*
* 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:
*
*/
#include <PsetContainer.h>
#include <PsetCallDiverting.h>
#include <mpsetdivertobs.h>
#include "ut_psetcalldivertingwrapper.h"
#include "mock_cphcltemergencycall.h"
#include "testutilities.h"
#define private public
#include "psetcalldivertingwrapper.h"
#include "psetcalldivertingwrapper_p.h"
class DivertObserver : public MPsetDivertObserver
{
void HandleDivertingChangedL(
const TCallDivertSetting& aSetting, TBool aPlural)
{
Q_UNUSED(aSetting);
Q_UNUSED(aPlural);
}
void HandleDivertingStatusL(CMobilePhoneCFList& aSetting, TBool aPlural)
{
Q_UNUSED(aSetting);
Q_UNUSED(aPlural);
}
void HandleDivertingErrorL(TInt aReason)
{
Q_UNUSED(aReason);
}
void HandleCFRequestingL(TBool aOngoing,
TBool aInterrupted)
{
Q_UNUSED(aOngoing);
Q_UNUSED(aInterrupted);
}
void SetEngineContact(MPsetCallDiverting* aDivertEngine)
{
Q_UNUSED(aDivertEngine);
}
};
void SimulateLeaveL()
{
User::Leave(KErrGeneral);
}
/*!
UT_PSetCallDivertingWrapper::UT_PSetWrapperCallDiverting
*/
UT_PSetCallDivertingWrapper::UT_PSetCallDivertingWrapper()
: mWrapper(NULL), mSetContainerMock(NULL)
{
}
/*!
UT_PSetCallDivertingWrapper::~UT_PSetWrapperCallDiverting
*/
UT_PSetCallDivertingWrapper::~UT_PSetCallDivertingWrapper()
{
delete mWrapper;
delete mSetContainerMock;
mPsetCallDivertingMock = NULL;
}
/*!
UT_PSetCallDivertingWrapper::init
*/
void UT_PSetCallDivertingWrapper::init()
{
initialize();
CPhCltEmergencyCallMock::iSimulateEmergencyNumberMatch = false;
mSetContainerMock = new CPsetContainer();
RMobilePhone dummyHandle;
DivertObserver dummyObsever;
QT_TRAP_THROWING(mPsetCallDivertingMock
= CPsetCallDiverting::NewL(dummyObsever, dummyHandle));
expect("CPsetContainer::CreateCFObjectL").returns(mPsetCallDivertingMock);
// Wrapper takes ownership of callDivertingMock during construction.
// Mock must be deleted here if exception happens during construction.
QScopedPointer<CPsetCallDiverting> divertingMockPtr(mPsetCallDivertingMock);
mWrapper = new PSetCallDivertingWrapper(*mSetContainerMock, NULL);
divertingMockPtr.take();
}
/*!
UT_PSetCallDivertingWrapper::cleanup
*/
void UT_PSetCallDivertingWrapper::cleanup()
{
reset();
delete mWrapper;
mWrapper = NULL;
delete mSetContainerMock;
mSetContainerMock = NULL;
mPsetCallDivertingMock = NULL;
}
/*!
UT_PSetCallDivertingWrapper::t_construction
*/
void UT_PSetCallDivertingWrapper::t_construction()
{
if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") != 0) {
expect("CPsetContainer::CreateCFObjectL").
willOnce(invokeWithoutArguments(SimulateLeaveL));
PSetCallDivertingWrapper *wrapper = NULL;
EXPECT_EXCEPTION(
wrapper = new PSetCallDivertingWrapper(*mSetContainerMock, NULL);
delete wrapper;
wrapper = NULL;
)
QVERIFY(verify());
expect("CPhCltEmergencyCallMock::NewL").
willOnce(invokeWithoutArguments(SimulateLeaveL));
EXPECT_EXCEPTION(
wrapper = new PSetCallDivertingWrapper(*mSetContainerMock, NULL);
delete wrapper;
wrapper = NULL;
)
QVERIFY(verify());
}
}
/*!
UT_PSetCallDivertingWrapper::t_setCallDivertingWithValidParameters
*/
void UT_PSetCallDivertingWrapper::t_setCallDivertingWithValidParameters()
{
PSCallDivertingCommand divertingCmd;
divertingCmd.iCondition = DivertConditionUnconditional;
divertingCmd.iSetting = RegisterDiverting;
divertingCmd.iStatus = DivertingStatusUnknown;
divertingCmd.iServiceGroup = ServiceGroupVoice;
divertingCmd.iNumber = "1234567890";
divertingCmd.iNoReplyTimer = 0;
TCallDivertSetting expectedParam;
expectedParam.iCondition = EDivertConditionUnconditional;
expectedParam.iSetting = ERegisterDiverting;
expectedParam.iStatus = EDivertingStatusUnknown;
expectedParam.iServiceGroup = EServiceGroupVoice;
expectedParam.iNumber
= TPtrC16(reinterpret_cast<const TUint16*>(divertingCmd.iNumber.utf16()));
expectedParam.iNoReplyTimer
= static_cast<TInt>(divertingCmd.iNoReplyTimer);
TBool isVmbx = EFalse;
expect("CPsetCallDiverting::SetDivertingL").
with(expectedParam, ETelephony, isVmbx);
mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_setCallDivertingWithInvalidNumber
*/
void UT_PSetCallDivertingWrapper::t_setCallDivertingWithInvalidNumber()
{
PSCallDivertingCommand divertingCmd;
divertingCmd.iCondition = DivertConditionUnconditional;
divertingCmd.iSetting = RegisterDiverting;
divertingCmd.iStatus = DivertingStatusUnknown;
divertingCmd.iServiceGroup = ServiceGroupVoice;
divertingCmd.iNoReplyTimer = 0;
expect("CPsetCallDiverting::SetDivertingL").times(0);
// DTMF digits "*#pw" are not allowed characters
divertingCmd.iNumber = "*";
int result = mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(result == KErrGsmSSUnknownAlphabet);
divertingCmd.iNumber = "#";
result = mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(result == KErrGsmSSUnknownAlphabet);
divertingCmd.iNumber = "p";
result = mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(result == KErrGsmSSUnknownAlphabet);
divertingCmd.iNumber = "w";
result = mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(result == KErrGsmSSUnknownAlphabet);
// plus allowed only in the beginning of the number
divertingCmd.iNumber = "++";
result = mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(result == KErrGsmSSUnknownAlphabet);
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_setCallDivertingWithEmergencyNumber
*/
void UT_PSetCallDivertingWrapper::t_setCallDivertingWithEmergencyNumber()
{
PSCallDivertingCommand divertingCmd;
divertingCmd.iCondition = DivertConditionUnconditional;
divertingCmd.iSetting = RegisterDiverting;
divertingCmd.iStatus = DivertingStatusUnknown;
divertingCmd.iServiceGroup = ServiceGroupVoice;
divertingCmd.iNumber = "112";
divertingCmd.iNoReplyTimer = 0;
expect("CPsetCallDiverting::SetDivertingL").times(0);
CPhCltEmergencyCallMock::iSimulateEmergencyNumberMatch = ETrue;
expect("CPhCltEmergencyCallMock::IsEmergencyPhoneNumber").returns(KErrNone);
int result = mWrapper->setCallDiverting(divertingCmd, ETelephony);
QVERIFY(result == KErrGsmSSIllegalOperation);
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_setCallDivertingException
*/
void UT_PSetCallDivertingWrapper::t_setCallDivertingException()
{
PSCallDivertingCommand divertingCmd;
divertingCmd.iCondition = DivertConditionUnconditional;
divertingCmd.iSetting = RegisterDiverting;
divertingCmd.iStatus = DivertingStatusUnknown;
divertingCmd.iServiceGroup = ServiceGroupVoice;
divertingCmd.iNumber = "1234567890";
divertingCmd.iNoReplyTimer = 0;
expect("CPsetCallDiverting::SetDivertingL").
willOnce(invokeWithoutArguments(this, &simulateLeaveOnMockMethodCallL));
EXPECT_EXCEPTION(
mWrapper->setCallDiverting(divertingCmd, ETelephony);
)
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_getCallDivertingStatus
*/
void UT_PSetCallDivertingWrapper::t_getCallDivertingStatus()
{
expect("CPsetCallDiverting::GetDivertingStatusL").
with(EServiceGroupVoice, EDivertConditionUnconditional, ETelephony);
mWrapper->getCallDivertingStatus(
ServiceGroupVoice, DivertConditionUnconditional, ETelephony);
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_getCallDivertingStatusException
*/
void UT_PSetCallDivertingWrapper::t_getCallDivertingStatusException()
{
expect("CPsetCallDiverting::GetDivertingStatusL").
with(EServiceGroupVoice, EDivertConditionUnconditional, ETelephony).
willOnce(invokeWithoutArguments(this, &simulateLeaveOnMockMethodCallL));
EXPECT_EXCEPTION(
mWrapper->getCallDivertingStatus(
ServiceGroupVoice, DivertConditionUnconditional, ETelephony);
)
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_cancelProcess
*/
void UT_PSetCallDivertingWrapper::t_cancelProcess()
{
expect("CPsetCallDiverting::CancelCurrentRequest");
mWrapper->cancelProcess();
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_getDefaultNumbers
*/
void UT_PSetCallDivertingWrapper::t_getDefaultNumbers()
{
expect("CPsetCallDiverting::GetDefaultNumbersL").times(1);
QStringList defNumbers;
mWrapper->getDefaultNumbers(defNumbers);
// 2 numbers added in mock_psetcalldiverting.cpp
QVERIFY(2 == defNumbers.count());
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_getDefaultNumbersException
*/
void UT_PSetCallDivertingWrapper::t_getDefaultNumbersException()
{
expect("CPsetCallDiverting::GetDefaultNumbersL").
willOnce(invokeWithoutArguments(this, &simulateLeaveOnMockMethodCallL));
QStringList defNumbers;
EXPECT_EXCEPTION(
mWrapper->getDefaultNumbers(defNumbers);
)
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_setNewDefaultNumber
*/
void UT_PSetCallDivertingWrapper::t_setNewDefaultNumber()
{
expect("CPsetCallDiverting::SetNewDefaultNumberL").times(1);
expect("CPsetCallDiverting::SwapDefaultNumberL").times(0);
// number not added in mock_psetcalldiverting.cpp
QString defNumber = "444444";
mWrapper->setNewDefaultNumber(defNumber);
expect("CPsetCallDiverting::GetDefaultNumbersL")
.willOnce(invoke(SimulateLeaveL));
EXPECT_EXCEPTION(
mWrapper->setNewDefaultNumber(defNumber);
)
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber
*/
void UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber()
{
// Fail case #1, illegal argument
QString defNumber;
int ret;
expect("CVoiceMailbox::GetStoredEntry").returns(-2).times(1);
ret = mWrapper->getVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
// Fail case #2, Not supported.
expect("CVoiceMailbox::GetStoredEntry").returns(-5).times(1);
ret = mWrapper->getVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, -1);
// Fail case #3, number nok
expect("CVoiceMailbox::GetStoredEntry").times(1);
expect("CVoiceMailboxEntry::GetVmbxNumber").returns(-1).times(1);
ret = mWrapper->getVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
// ok case#1, number and save ok but no new number.
expect("CVoiceMailbox::GetStoredEntry").returns(-1).times(1);
ret = mWrapper->getVoiceMailBoxNumber(defNumber, ServiceGroupData);
QCOMPARE(ret, 0);
// ok case#2, number ok
expect("CVoiceMailbox::GetStoredEntry").times(1);
expect("CVoiceMailboxEntry::GetVmbxNumber").times(1);
ret = mWrapper->getVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
expect("CVoiceMailbox::NewL")
.willOnce(invoke(SimulateLeaveL));
EXPECT_EXCEPTION(
mWrapper->getVoiceMailBoxNumber(defNumber, ServiceGroupFax);
)
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_queryVoiceMailBoxNumber
*/
void UT_PSetCallDivertingWrapper::t_queryVoiceMailBoxNumber()
{
// Fail case #1, illegal argument
QString defNumber;
int ret;
expect("CVoiceMailbox::GetStoredEntry").returns(-2).times(1);
ret = mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
// Fail case #2, Not supported.
expect("CVoiceMailbox::GetStoredEntry").returns(-5).times(1);
ret = mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, -1);
// Fail case #3, New number not given.
expect("CVoiceMailbox::GetStoredEntry").times(1);
expect("CVoiceMailbox::QueryNewEntry").returns(-5).times(1);
ret = mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
// Fail case #4, save nok
expect("CVoiceMailbox::GetStoredEntry").returns(-1).times(1);
expect("CVoiceMailbox::QueryNewEntry").times(1);
expect("CVoiceMailbox::SaveEntry").returns(-4).times(1);
ret = mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupData);
QCOMPARE(ret, 0);
// ok case#1, number and save ok but no new number.
expect("CVoiceMailbox::GetStoredEntry").returns(-1).times(1);
expect("CVoiceMailbox::QueryNewEntry").times(1);
expect("CVoiceMailbox::SaveEntry").times(1);
expect("CVoiceMailboxEntry::GetVmbxNumber").returns(-5).times(1);
ret = mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
// ok case#2, number ok
expect("CVoiceMailbox::GetStoredEntry").times(1);
expect("CVoiceMailbox::QueryNewEntry").times(1);
expect("CVoiceMailbox::SaveEntry").times(1);
expect("CVoiceMailboxEntry::GetVmbxNumber").times(1);
ret = mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupVoice);
QCOMPARE(ret, 0);
expect("CVoiceMailbox::NewL")
.willOnce(invoke(SimulateLeaveL));
EXPECT_EXCEPTION(
mWrapper->queryVoiceMailBoxNumber(defNumber, ServiceGroupFax);
)
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_swapDefaultNumber
*/
void UT_PSetCallDivertingWrapper::t_swapDefaultNumber()
{
expect("CPsetCallDiverting::SetNewDefaultNumberL").times(0);
expect("CPsetCallDiverting::SwapDefaultNumberL").times(1);
// same number added in mock_psetcalldiverting.cpp
QString defNumber = "222222";
mWrapper->setNewDefaultNumber(defNumber);
QVERIFY(true == verify());
}
Q_DECLARE_METATYPE(PSCallDivertingCommand)
/*!
UT_PSetCallDivertingWrapper::t_handleDivertingChanged
*/
void UT_PSetCallDivertingWrapper::t_handleDivertingChanged()
{
qRegisterMetaType<PSCallDivertingCommand>("PSCallDivertingCommand");
QSignalSpy spy(mWrapper,
SIGNAL(handleDivertingChanged(const PSCallDivertingCommand&, bool)));
TCallDivertSetting setting;
setting.iCondition = EDivertConditionUnconditional;
setting.iSetting = EActivateDiverting;
setting.iStatus = EDivertingStatusUnknown;
setting.iServiceGroup = EServiceGroupAllTeleservices;
setting.iNumber = KNullDesC();
TBool plural = ETrue;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));
setting.iCondition = EDivertConditionBusy;
setting.iStatus = EDivertingStatusActive;
setting.iServiceGroup = EServiceGroupVoice;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));
setting.iCondition = EDivertConditionNoReply;
setting.iStatus = EDivertingStatusInactive;
setting.iServiceGroup = EServiceGroupData;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));
setting.iCondition = EDivertConditionNotReachable;
setting.iStatus = EDivertingStatusNotRegistered;
setting.iServiceGroup = EServiceGroupFax;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));
setting.iCondition = EDivertConditionAllCalls;
setting.iStatus = EDivertingStatusNotProvisioned;
setting.iServiceGroup = EServiceGroupFax;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));
setting.iCondition = EDivertConditionAllConditionalCases;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingChangedL(setting, plural));
QCOMPARE(spy.count(), 6);
PSCallDivertingCommand actualCmd =
qvariant_cast<PSCallDivertingCommand>(spy.at(0).at(0));
QVERIFY(actualCmd.iCondition == DivertConditionUnconditional);
QVERIFY(actualCmd.iSetting == ActivateDiverting);
QVERIFY(actualCmd.iStatus == DivertingStatusUnknown);
QVERIFY(actualCmd.iServiceGroup == ServiceGroupAllTeleservices);
QVERIFY(actualCmd.iNumber == QString::fromUtf16(setting.iNumber.Ptr(),
setting.iNumber.Length()));
QVERIFY(spy.at(0).at(1).toBool() == true);
actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(1).at(0));
QVERIFY(actualCmd.iCondition == DivertConditionBusy);
QVERIFY(actualCmd.iStatus == DivertingStatusActive);
QVERIFY(actualCmd.iServiceGroup == ServiceGroupVoice);
actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(2).at(0));
QVERIFY(actualCmd.iCondition == DivertConditionNoReply);
QVERIFY(actualCmd.iStatus == DivertingStatusInactive);
QVERIFY(actualCmd.iServiceGroup == ServiceGroupData);
actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(3).at(0));
QVERIFY(actualCmd.iCondition == DivertConditionNotReachable);
QVERIFY(actualCmd.iStatus == DivertingStatusNotRegistered);
QVERIFY(actualCmd.iServiceGroup == ServiceGroupFax);
actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(4).at(0));
QVERIFY(actualCmd.iCondition == DivertConditionAllCalls);
QVERIFY(actualCmd.iStatus == DivertingStatusNotProvisioned);
QVERIFY(actualCmd.iServiceGroup == ServiceGroupFax);
actualCmd = qvariant_cast<PSCallDivertingCommand>(spy.at(5).at(0));
QVERIFY(actualCmd.iCondition == DivertConditionAllConditionalCases);
QVERIFY(true == verify());
}
/*!
UT_PSetCallDivertingWrapper::t_handleDivertingStatus
*/
void UT_PSetCallDivertingWrapper::t_handleDivertingStatus()
{
qRegisterMetaType<QList<PSCallDivertingStatus*> >("QList<PSCallDivertingStatus*>&");
QSignalSpy spy(mWrapper,
SIGNAL(handleDivertingStatus(QList<PSCallDivertingStatus*>&, bool)));
// With empty list
CMobilePhoneCFList* cfList = NULL;
QT_TRAP_THROWING(cfList = CMobilePhoneCFList::NewL());
QScopedPointer<CMobilePhoneCFList> cfListDeleter(cfList);
TBool plural = ETrue;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingStatusL(*cfList, plural));
QCOMPARE(spy.count(), 1);
QVERIFY(spy.at(0).at(1).toBool() == true);
spy.clear();
// With list entry
RMobilePhone::TMobilePhoneCFInfoEntryV1 entry;
entry.iStatus = RMobilePhone::ECallForwardingStatusNotProvisioned;
entry.iCondition = RMobilePhone::ECallForwardingAllConditionalCases;
cfList->AddEntryL(entry);
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingStatusL(*cfList, plural));
QCOMPARE(spy.count(), 1);
QList<PSCallDivertingStatus*> result =
*reinterpret_cast<const QList<PSCallDivertingStatus*> *>(spy.at(0).at(0).constData());
QVERIFY(result.at(0)->iStatus == DivertingStatusNotProvisioned);
QVERIFY(result.at(0)->iCondition == DivertConditionAllConditionalCases);
QVERIFY(spy.at(0).at(1).toBool() == true);
spy.clear();
// With list, two entries
delete cfList;
QT_TRAP_THROWING(cfList = CMobilePhoneCFList::NewL());
entry.iStatus = RMobilePhone::ECallForwardingStatusNotActive;
entry.iCondition = RMobilePhone::ECallForwardingBusy;
cfList->AddEntryL(entry); // Takes copy
RMobilePhone::TMobilePhoneCFInfoEntryV1 entry2;
entry2.iStatus = RMobilePhone::ECallForwardingStatusActive;
entry2.iCondition = RMobilePhone::ECallForwardingUnconditional;
cfList->AddEntryL(entry2);
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleDivertingStatusL(*cfList, plural));
QCOMPARE(spy.count(), 1);
result = *reinterpret_cast<const QList<PSCallDivertingStatus*> *>(spy.at(0).at(0).constData());
QVERIFY(result.at(0)->iStatus == DivertingStatusInactive);
QVERIFY(result.at(0)->iCondition == DivertConditionBusy);
QVERIFY(result.at(1)->iStatus == DivertingStatusActive);
QVERIFY(result.at(1)->iCondition == DivertConditionUnconditional);
QVERIFY(spy.at(0).at(1).toBool() == true);
spy.clear();
}
/*!
UT_PSetCallDivertingWrapper::t_handleDivertingError
*/
void UT_PSetCallDivertingWrapper::t_handleDivertingError()
{
QSignalSpy spy(mWrapper, SIGNAL(handleDivertingError(int)));
QT_TRAP_THROWING(mWrapper->m_Priv->HandleDivertingErrorL(KErrGeneral));
QCOMPARE(spy.count(), 1);
QVERIFY(spy.at(0).at(0).toInt() == KErrGeneral);
}
/*!
UT_PSetCallDivertingWrapper::t_handleCFRequesting
*/
void UT_PSetCallDivertingWrapper::t_handleCFRequesting()
{
QSignalSpy spy(mWrapper, SIGNAL(handleCFRequesting(bool, bool)));
TBool ongoing = ETrue;
TBool interrupted = ETrue;
QT_TRAP_THROWING(
mWrapper->m_Priv->HandleCFRequestingL(ongoing, interrupted));
QCOMPARE(spy.count(), 1);
QVERIFY(spy.at(0).at(0).toBool() == true);
QVERIFY(spy.at(0).at(1).toBool() == true);
}
/*!
UT_PSetCallDivertingWrapper::t_setEngineContact
TODO: dummy test because no implementation for the method currently.
*/
void UT_PSetCallDivertingWrapper::t_setEngineContact()
{
mWrapper->m_Priv->SetEngineContact(mPsetCallDivertingMock);
}
/*!
UT_PSetCallDivertingWrapper::t_handleEmergencyDial
TODO: dummy test because no implementation for the method currently.
*/
void UT_PSetCallDivertingWrapper::t_handleEmergencyDial()
{
QT_TRAP_THROWING(mWrapper->m_Priv->HandleEmergencyDialL(KErrNone));
}
/*!
UT_PSetCallDivertingWrapper::t_convertPsCallDivertingCondition
*/
void UT_PSetCallDivertingWrapper::t_convertPsCallDivertingCondition()
{
QVERIFY(EDivertConditionUnconditional ==
mWrapper->m_Priv->convert(DivertConditionUnknown));
QVERIFY(EDivertConditionUnconditional ==
mWrapper->m_Priv->convert(DivertConditionUnconditional));
QVERIFY(EDivertConditionBusy ==
mWrapper->m_Priv->convert(DivertConditionBusy));
QVERIFY(EDivertConditionNoReply ==
mWrapper->m_Priv->convert(DivertConditionNoReply));
QVERIFY(EDivertConditionNotReachable ==
mWrapper->m_Priv->convert(DivertConditionNotReachable));
QVERIFY(EDivertConditionAllCalls ==
mWrapper->m_Priv->convert(DivertConditionAllCalls));
QVERIFY(EDivertConditionAllConditionalCases ==
mWrapper->m_Priv->convert(DivertConditionAllConditionalCases));
}
/*!
UT_PSetCallDivertingWrapper::t_convertPsCallDivertingStatus
*/
void UT_PSetCallDivertingWrapper::t_convertPsCallDivertingStatus()
{
QVERIFY(EDivertingStatusActive ==
mWrapper->m_Priv->convert(DivertingStatusActive));
QVERIFY(EDivertingStatusInactive ==
mWrapper->m_Priv->convert(DivertingStatusInactive));
QVERIFY(EDivertingStatusNotRegistered ==
mWrapper->m_Priv->convert(DivertingStatusNotRegistered));
QVERIFY(EDivertingStatusNotProvisioned ==
mWrapper->m_Priv->convert(DivertingStatusNotProvisioned));
}
/*!
UT_PSetCallDivertingWrapper::t_convertPsCallDivertingSetting
*/
void UT_PSetCallDivertingWrapper::t_convertPsCallDivertingSetting()
{
QVERIFY(EActivateDiverting ==
mWrapper->m_Priv->convert(ActivateDiverting));
QVERIFY(ECancelDiverting ==
mWrapper->m_Priv->convert(CancelDiverting));
QVERIFY(ERegisterDiverting ==
mWrapper->m_Priv->convert(RegisterDiverting));
QVERIFY(EEraseDiverting ==
mWrapper->m_Priv->convert(EraseDiverting));
QVERIFY(ECheckStatus ==
mWrapper->m_Priv->convert(CheckStatus));
const int invalidEnumeration = -1;
QVERIFY(ECheckStatus == mWrapper->m_Priv->convert(
static_cast<PsCallDivertingSetting>(invalidEnumeration)));
}
/*!
UT_PSetCallDivertingWrapper::t_exceptionSafety
*/
void UT_PSetCallDivertingWrapper::t_exceptionSafety()
{
cleanup();
OomTestExecuter::runAllTests(*this, "t_exceptionSafety");
}
/*!
UT_PSetCallDivertingWrapper::simulateLeaveOnMockMethodCallL
*/
void UT_PSetCallDivertingWrapper::simulateLeaveOnMockMethodCallL()
{
User::Leave(KErrGeneral);
}
QTEST_MAIN_S60(UT_PSetCallDivertingWrapper)