--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetcalldivertingwrapper/ut_psetcalldivertingwrapper.cpp Fri Mar 19 09:40:14 2010 +0200
@@ -0,0 +1,646 @@
+/*
+* 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);
+ }
+};
+
+/*!
+ 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_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);
+
+ QVERIFY(true == verify());
+}
+
+/*!
+ UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber
+ */
+void UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber()
+{
+ // Fail case
+ expect("CVoiceMailbox::GetStoredEntry").returns(-2).times(1);
+
+ QString defNumber;
+ mWrapper->getVoiceMailBoxNumber(defNumber);
+
+ QVERIFY(true == verify());
+}
+
+/*!
+ UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber2
+ */
+void UT_PSetCallDivertingWrapper::t_getVoiceMailBoxNumber2()
+{
+ expect("CVoiceMailbox::GetStoredEntry").times(1);
+ expect("CVoiceMailboxEntry::GetVmbxNumber").returns(-1).times(1);
+
+ QString defNumber;
+ mWrapper->getVoiceMailBoxNumber(defNumber);
+
+ 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
+ TODO: tests using signalspy fail in alloc failure mode because
+ QList<QVariant> is not exception safe in QT 4.6.0.
+ */
+void UT_PSetCallDivertingWrapper::t_exceptionSafety()
+{
+ cleanup();
+
+ OomTestExecuter::runTest(*this, &t_setCallDivertingWithValidParameters);
+ //OomTestExecuter::runTest(*this, &t_setCallDivertingWithInvalidNumber);
+ //OomTestExecuter::runTest(*this, &t_setCallDivertingWithEmergencyNumber);
+ OomTestExecuter::runTest(*this, &t_setCallDivertingException);
+ OomTestExecuter::runTest(*this, &t_getCallDivertingStatus);
+ OomTestExecuter::runTest(*this, &t_getCallDivertingStatusException);
+ OomTestExecuter::runTest(*this, &t_cancelProcess);
+ OomTestExecuter::runTest(*this, &t_getDefaultNumbers);
+ OomTestExecuter::runTest(*this, &t_getDefaultNumbersException);
+ OomTestExecuter::runTest(*this, &t_setNewDefaultNumber);
+ OomTestExecuter::runTest(*this, &t_swapDefaultNumber);
+ //OomTestExecuter::runTest(*this, &t_handleDivertingChanged);
+ //OomTestExecuter::runTest(*this, &t_handleDivertingStatus);
+ //OomTestExecuter::runTest(*this, &t_handleDivertingError);
+ //OomTestExecuter::runTest(*this, &t_handleCFRequesting);
+ OomTestExecuter::runTest(*this, &t_setEngineContact);
+ OomTestExecuter::runTest(*this, &t_handleEmergencyDial);
+ OomTestExecuter::runTest(*this, &t_convertPsCallDivertingCondition);
+ OomTestExecuter::runTest(*this, &t_convertPsCallDivertingStatus);
+ OomTestExecuter::runTest(*this, &t_convertPsCallDivertingSetting);
+}
+
+/*!
+ UT_PSetCallDivertingWrapper::simulateLeaveOnMockMethodCallL
+ */
+void UT_PSetCallDivertingWrapper::simulateLeaveOnMockMethodCallL()
+{
+ User::Leave(KErrGeneral);
+}
+
+QTEST_MAIN_S60(UT_PSetCallDivertingWrapper)