--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetcalldivertingwrapper/ut_psetcalldivertingwrapper.cpp Tue Aug 31 15:45:17 2010 +0300
@@ -0,0 +1,735 @@
+/*
+* 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)