--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetcallbarringwrapper/ut_psetcallbarringwrapper.cpp Tue Aug 31 15:45:17 2010 +0300
@@ -0,0 +1,825 @@
+/*
+* 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 <mpsetbarringobs.h>
+#include <psetwrappertypes.h>
+#include <nwdefs.h>
+#include "ut_psetcallbarringwrapper.h"
+#include "testutilities.h"
+#define private public
+#include <psetcallbarringwrapper.h>
+#include "psetcallbarringwrapper_p.h"
+
+const int KInvalidEnumeration = -1;
+
+class BarringObserver : public MPsetBarringObserver
+{
+ void HandleBarringModeChangedL(
+ TBarringProgram aType,
+ TBarringStatus aStatus,
+ TBool aPlural )
+ {
+ Q_UNUSED(aType);
+ Q_UNUSED(aStatus);
+ Q_UNUSED(aPlural);
+ }
+
+ void HandleBarringModeStatusL(
+ TUint8 aBsc[KPSetNumberOfBsc],
+ TBarringStatus aStatus )
+ {
+ Q_UNUSED(aBsc);
+ Q_UNUSED(aStatus);
+ }
+
+ void HandleBarringErrorL(
+ TInt aReason )
+ {
+ Q_UNUSED(aReason);
+ }
+
+ void HandleCBRequestingL(
+ TBool aTrue,
+ TBool aInterrupted )
+ {
+ Q_UNUSED(aTrue);
+ Q_UNUSED(aInterrupted);
+ }
+
+ void SetEngineContact(
+ MPsetCallBarring* aBarringEngine )
+ {
+ Q_UNUSED(aBarringEngine);
+ }
+
+ void CbPasswordChangedL(
+ TBool aSuccess )
+ {
+ Q_UNUSED(aSuccess);
+ }
+};
+
+void simulateLeaveL()
+{
+ User::Leave(KErrGeneral);
+}
+
+/*!
+ UT_PSetCallBarringWrapper::UT_PSetCallBarringWrapper
+ */
+UT_PSetCallBarringWrapper::UT_PSetCallBarringWrapper()
+ :
+ m_psetContainerMock(NULL),
+ m_wrapper(NULL)
+{
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::~UT_PSetCallBarringWrapper
+ */
+UT_PSetCallBarringWrapper::~UT_PSetCallBarringWrapper()
+{
+ delete m_psetContainerMock;
+ delete m_wrapper;
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::init
+ */
+void UT_PSetCallBarringWrapper::init()
+{
+ initialize();
+
+ m_psetContainerMock = new CPsetContainer();
+
+ BarringObserver dummyObserver;
+ RMobilePhone dummyPhone;
+
+ CPsetCallBarring *barringMock = NULL;
+ TRAPD(result, barringMock = CPsetCallBarring::NewL(dummyObserver, dummyPhone));
+ QScopedPointer<CPsetCallBarring> barringMockGuard(barringMock);
+ EXPECT(CPsetContainer, CreateCBObjectL)
+ .returns(barringMock);
+ m_wrapper = new PSetCallBarringWrapper(*m_psetContainerMock, NULL);
+ barringMockGuard.take();
+
+ QVERIFY(verify());
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::cleanup
+ */
+void UT_PSetCallBarringWrapper::cleanup()
+{
+ reset();
+
+ delete m_psetContainerMock;
+ m_psetContainerMock = NULL;
+ delete m_wrapper;
+ m_wrapper = NULL;
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_construction
+ */
+void UT_PSetCallBarringWrapper::t_construction()
+{
+ EXPECT(CPsetContainer, CreateCBObjectL).
+ willOnce(invokeWithoutArguments(this, simulateLeaveAtMockMethodCall));
+ PSetCallBarringWrapper *wrapper = NULL;
+ EXPECT_EXCEPTION(
+ wrapper = new PSetCallBarringWrapper(*m_psetContainerMock, NULL););
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_barringStatus
+ */
+void UT_PSetCallBarringWrapper::t_barringStatus()
+{
+// test status query with different service groups
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllBarrings);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupData, EBarringTypeAllBarrings);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupFax, EBarringTypeAllBarrings);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupAllTeleservices, EBarringTypeAllBarrings);
+ // invalid/unknown enumeration as service group identifier
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllBarrings);
+
+ //TODO: remove SeviceGroupUnknown enumeration?
+ //m_wrapper->barringStatus(ServiceGroupUnknown);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->barringStatus(ServiceGroupData,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->barringStatus(ServiceGroupFax,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->barringStatus(ServiceGroupAllTeleservices,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ // invalid/unknown enumeration as service group identifier
+ m_wrapper->barringStatus(
+ static_cast<PsService>(KInvalidEnumeration),
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+
+// test status query with different barring types
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllOutgoing);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeOutgoingInternational);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice,
+ EBarringTypeOutgoingInternationalExceptToHomeCountry);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllIncoming);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeIncomingWhenRoaming);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllServices);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllOutgoingServices);
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllIncomingServices);
+ // invalid/unknown enumeration as barring type
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .with(EServiceGroupVoice, EBarringTypeAllBarrings);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllOutgoing);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeOutgoingInternational);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::
+ BarringTypeOutgoingInternationalExceptToHomeCountry);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncoming);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllServices);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllOutgoingServices);
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncomingServices);
+ // invalid/unknown enumeration as barring type
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ static_cast<PSetCallBarringWrapper::BarringType>(KInvalidEnumeration));
+
+ QVERIFY(verify());
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_barringStatusExceptionOccurs
+ */
+void UT_PSetCallBarringWrapper::t_barringStatusExceptionOccurs()
+{
+ EXPECT(CPsetCallBarring, GetBarringStatusL)
+ .willOnce(invokeWithoutArguments(this, simulateLeaveAtMockMethodCall));
+
+ EXPECT_EXCEPTION(
+ m_wrapper->barringStatus(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ )
+
+ QVERIFY(verify());
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_enableBarring
+ */
+void UT_PSetCallBarringWrapper::t_enableBarring()
+{
+ _LIT(KPassword, "1234");
+ TCallBarringSetting setting;
+ setting.iType = EBarringTypeAllBarrings;
+ setting.iSetting = EActivateBarring;
+ setting.iServiceGroup = EServiceGroupVoice;
+ setting.iPassword.Copy(KPassword());
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllOutgoing;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllOutgoing,
+ QString("1234"));
+
+ setting.iType = EBarringTypeOutgoingInternational;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeOutgoingInternational,
+ QString("1234"));
+
+ setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllIncoming;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncoming,
+ QString("1234"));
+
+ setting.iType = EBarringTypeIncomingWhenRoaming;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllServices;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllServices,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllOutgoingServices;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllOutgoingServices,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllIncomingServices;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncomingServices,
+ QString("1234"));
+
+// error handling
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .willOnce(invokeWithoutArguments(simulateLeaveL));
+ EXPECT_EXCEPTION(
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncomingServices,
+ QString("1234"));
+ )
+
+ QVERIFY(verify());
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_disableBarring
+ */
+void UT_PSetCallBarringWrapper::t_disableBarring()
+{
+ _LIT(KPassword, "1234");
+ TCallBarringSetting setting;
+ setting.iType = EBarringTypeAllBarrings;
+ setting.iSetting = ECancelBarring;
+ setting.iServiceGroup = EServiceGroupVoice;
+ setting.iPassword.Copy(KPassword());
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllOutgoing;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllOutgoing,
+ QString("1234"));
+
+ setting.iType = EBarringTypeOutgoingInternational;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeOutgoingInternational,
+ QString("1234"));
+
+ setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllIncoming;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncoming,
+ QString("1234"));
+
+ setting.iType = EBarringTypeIncomingWhenRoaming;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllServices;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllServices,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllOutgoingServices;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllOutgoingServices,
+ QString("1234"));
+
+ setting.iType = EBarringTypeAllIncomingServices;
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .with(setting, EAllTeleAndBearer);
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncomingServices,
+ QString("1234"));
+
+// error handling
+ EXPECT(CPsetCallBarring, SetBarringL)
+ .willOnce(invokeWithoutArguments(simulateLeaveL));
+ EXPECT_EXCEPTION(
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllIncomingServices,
+ QString("1234"));
+ )
+
+ QVERIFY(verify());
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_changeBarringPassword
+ */
+void UT_PSetCallBarringWrapper::t_changeBarringPassword()
+{
+ QString oldPassword = "1234";
+ QString newPassword = "4321";
+ QString verifiedPassword = "4321";
+ RMobilePhone::TMobilePhonePasswordChangeV2 passwordChange;
+ passwordChange.iOldPassword.Copy(oldPassword.utf16());
+ passwordChange.iNewPassword.Copy(newPassword.utf16());
+ passwordChange.iVerifiedPassword.Copy(verifiedPassword.utf16());
+ EXPECT(CPsetCallBarring, ChangePasswordL)
+ .with(passwordChange);
+
+ m_wrapper->changeBarringPassword(
+ oldPassword, newPassword, verifiedPassword);
+
+// error handling
+ EXPECT(CPsetCallBarring, ChangePasswordL)
+ .willOnce(invokeWithoutArguments(simulateLeaveL));
+ EXPECT_EXCEPTION(
+ m_wrapper->changeBarringPassword(
+ oldPassword, newPassword, verifiedPassword);
+ )
+
+ QVERIFY(verify());
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_HandleBarringModeChangedL
+ */
+void UT_PSetCallBarringWrapper::t_HandleBarringModeChangedL()
+{
+ TBool plural = EFalse;
+ QT_TRAP_THROWING(
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllBarrings, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllOutgoing, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeOutgoingInternational, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeOutgoingInternationalExceptToHomeCountry, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllIncoming, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeIncomingWhenRoaming, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllServices, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllOutgoingServices, EBarringStatusActive, plural);
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllIncomingServices, EBarringStatusActive, plural);
+ )
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_HandleBarringErrorL
+ */
+void UT_PSetCallBarringWrapper::t_HandleBarringErrorL()
+{
+ // TODO: dummy test as functionality not yet implemented
+ QT_TRAP_THROWING(
+ m_wrapper->m_privateImpl->HandleBarringErrorL(KErrGeneral);
+ )
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_HandleCBRequestingL
+ */
+void UT_PSetCallBarringWrapper::t_HandleCBRequestingL()
+{
+ // TODO: dummy test as functionality not yet implemented
+ QT_TRAP_THROWING(
+ m_wrapper->m_privateImpl->HandleCBRequestingL(EFalse, EFalse);
+ )
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_SetEngineContact
+ */
+void UT_PSetCallBarringWrapper::t_SetEngineContact()
+{
+ // TODO: dummy test as functionality not yet implemented
+ m_wrapper->m_privateImpl->SetEngineContact(NULL);
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_CbPasswordChangedL
+ */
+void UT_PSetCallBarringWrapper::t_CbPasswordChangedL()
+{
+ TBool success = EFalse;
+ QT_TRAP_THROWING(
+ m_wrapper->m_privateImpl->CbPasswordChangedL(ETrue);
+ m_wrapper->m_privateImpl->CbPasswordChangedL(EFalse);
+ )
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_HandleBarringModeStatusL
+ */
+Q_DECLARE_METATYPE(PSetCallBarringWrapper::BarringStatus)
+Q_DECLARE_METATYPE(QList<unsigned char>)
+void UT_PSetCallBarringWrapper::t_HandleBarringModeStatusL()
+{
+ qRegisterMetaType<PSetCallBarringWrapper::BarringStatus>
+ ("PSetCallBarringWrapper::BarringStatus");
+ qRegisterMetaType<QList<unsigned char> >("QList<unsigned char>");
+ QSignalSpy spy(m_wrapper,
+ SIGNAL(barringStatusRequestCompleted(
+ int,
+ const QList<unsigned char> &,
+ PSetCallBarringWrapper::BarringStatus)));
+
+ TUint8 basicServiceGroupIds[KPSetNumberOfBsc];
+ basicServiceGroupIds[0] = EServiceGroupVoice;
+ basicServiceGroupIds[1] = KPSetUnusedValue;
+// test with different barring statuses
+ QT_TRAP_THROWING(
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds, EBarringStatusActive);
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds, EBarringStatusInactive);
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds, EBarringStatusNotProvisioned);
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds, EBarringStatusUnavailable);
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds, EBarringStatusUnknown);
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ // invalid/unknown enumeration as barring status
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds,
+ static_cast<TBarringStatus>(KInvalidEnumeration));
+ m_wrapper->m_privateImpl->RequestComplete();
+ )
+
+ if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") == 0) {
+ // Signal emissions from RequestComplete will fail with exception safety
+ // tests so it's not possible to verify signal data.
+ return;
+ }
+
+ QCOMPARE(spy.count(), 6);
+ QList<unsigned char> resultBasicServiceGroupIds =
+ qvariant_cast<QList<unsigned char> >(spy.at(0).at(1));
+ QVERIFY(ServiceGroupVoice == resultBasicServiceGroupIds[0]);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusActive ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(0).at(2)));
+
+ resultBasicServiceGroupIds =
+ qvariant_cast<QList<unsigned char> >(spy.at(1).at(1));
+ QVERIFY(ServiceGroupVoice == resultBasicServiceGroupIds[0]);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusInactive ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(1).at(2)));
+
+ resultBasicServiceGroupIds =
+ qvariant_cast<QList<unsigned char> >(spy.at(2).at(1));
+ QVERIFY(ServiceGroupVoice == resultBasicServiceGroupIds[0]);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusNotProvisioned ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(2).at(2)));
+
+ resultBasicServiceGroupIds =
+ qvariant_cast<QList<unsigned char> >(spy.at(3).at(1));
+ QVERIFY(ServiceGroupVoice == resultBasicServiceGroupIds[0]);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusUnavailable ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(3).at(2)));
+
+ resultBasicServiceGroupIds =
+ qvariant_cast<QList<unsigned char> >(spy.at(4).at(1));
+ QVERIFY(ServiceGroupVoice == resultBasicServiceGroupIds[0]);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusUnknown ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(4).at(2)));
+
+ // invalid/unknown enumeration as barring status
+ resultBasicServiceGroupIds =
+ qvariant_cast<QList<unsigned char> >(spy.at(5).at(1));
+ QVERIFY(ServiceGroupVoice == resultBasicServiceGroupIds[0]);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusUnknown ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(5).at(2)));
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_HandleBarringModeStatusNoBasicServiceGroupIdsL
+ */
+void UT_PSetCallBarringWrapper::t_HandleBarringModeStatusNoBasicServiceGroupIdsL()
+{
+ TUint8 basicServiceGroupIds[KPSetNumberOfBsc];
+ basicServiceGroupIds[0] = KPSetUnusedValue;
+ QSignalSpy spy(m_wrapper,
+ SIGNAL(barringStatusRequestCompleted(
+ int,
+ const QList<unsigned char> &,
+ PSetCallBarringWrapper::BarringStatus)));
+
+ QT_TRAP_THROWING(
+ m_wrapper->barringStatus(ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ m_wrapper->m_privateImpl->HandleBarringModeStatusL(
+ basicServiceGroupIds, EBarringStatusActive);
+ m_wrapper->m_privateImpl->RequestComplete();
+ )
+
+ if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") == 0) {
+ // Signal emissions from RequestComplete will fail with exception safety
+ // tests so it's not possible to verify signal data.
+ return;
+ }
+
+ QCOMPARE(spy.count(), 1);
+ QVERIFY(PSetCallBarringWrapper::BarringStatusActive ==
+ qvariant_cast<PSetCallBarringWrapper::BarringStatus>(spy.at(0).at(2)));
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_enableBarringRequestComplete
+ */
+Q_DECLARE_METATYPE(PSetCallBarringWrapper::BarringType)
+void UT_PSetCallBarringWrapper::t_enableBarringRequestComplete()
+{
+ qRegisterMetaType<PSetCallBarringWrapper::BarringType>(
+ "PSetCallBarringWrapper::BarringType");
+ QSignalSpy spy(
+ m_wrapper,
+ SIGNAL(enableBarringRequestCompleted(int,
+ PSetCallBarringWrapper::BarringType,
+ PSetCallBarringWrapper::BarringStatus,
+ bool)));
+
+ TCallBarringSetting setting;
+ m_wrapper->enableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings,
+ QString("1234"));
+ QT_TRAP_THROWING(
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllBarrings, EBarringStatusActive, EFalse);
+ );
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") == 0) {
+ // Signal emissions from RequestComplete will fail with exception safety
+ // tests so it's not possible to verify signal data.
+ return;
+ }
+
+ QCOMPARE(spy.count(), 1);
+ QCOMPARE(spy.at(0).at(0).toInt(), 0);
+ QCOMPARE(spy.at(0).at(1).value<PSetCallBarringWrapper::BarringType>(),
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ QCOMPARE(spy.at(0).at(2).value<PSetCallBarringWrapper::BarringStatus>(),
+ PSetCallBarringWrapper::BarringStatusActive);
+ QCOMPARE(spy.at(0).at(3).toBool(), false);
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_disableBarringRequestComplete
+ */
+void UT_PSetCallBarringWrapper::t_disableBarringRequestComplete()
+{
+ QSignalSpy spy(
+ m_wrapper,
+ SIGNAL(disableBarringRequestCompleted(int,
+ PSetCallBarringWrapper::BarringType,
+ PSetCallBarringWrapper::BarringStatus,
+ bool)));
+
+ TCallBarringSetting setting;
+ m_wrapper->disableBarring(
+ ServiceGroupVoice,
+ PSetCallBarringWrapper::BarringTypeAllBarrings,
+ QString("1234"));
+ QT_TRAP_THROWING(
+ m_wrapper->m_privateImpl->HandleBarringModeChangedL(
+ EBarringTypeAllBarrings, EBarringStatusNotProvisioned, EFalse);
+ );
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") == 0) {
+ // Signal emissions from RequestComplete will fail with exception safety
+ // tests so it's not possible to verify signal data.
+ return;
+ }
+
+ QCOMPARE(spy.count(), 1);
+ QCOMPARE(spy.at(0).at(0).toInt(), 0);
+ QCOMPARE(spy.at(0).at(1).value<PSetCallBarringWrapper::BarringType>(),
+ PSetCallBarringWrapper::BarringTypeAllBarrings);
+ QCOMPARE(spy.at(0).at(2).value<PSetCallBarringWrapper::BarringStatus>(),
+ PSetCallBarringWrapper::BarringStatusNotProvisioned);
+ QCOMPARE(spy.at(0).at(3).toBool(), false);
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_changeBarringPasswordRequestComplete
+ */
+void UT_PSetCallBarringWrapper::t_changeBarringPasswordRequestComplete()
+{
+ QSignalSpy spy(
+ m_wrapper,
+ SIGNAL(barringPasswordChangeRequestCompleted(int)));
+
+ QString oldPassword = "1234";
+ QString newPassword = "4321";
+ QString verifiedPassword = "4321";
+ m_wrapper->changeBarringPassword(
+ oldPassword, newPassword, verifiedPassword);
+
+ m_wrapper->m_privateImpl->RequestComplete();
+
+ if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") == 0) {
+ // Signal emissions from RequestComplete will fail with exception safety
+ // tests so it's not possible to verify signal data.
+ return;
+ }
+
+ QCOMPARE(spy.count(), 1);
+ QCOMPARE(spy.at(0).at(0).toInt(), 0);
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_RequestStatusChanged
+ */
+void UT_PSetCallBarringWrapper::t_RequestStatusChanged()
+{
+ m_wrapper->m_privateImpl->RequestStatusChanged(0);
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::t_exceptionSafety
+ */
+void UT_PSetCallBarringWrapper::t_exceptionSafety()
+{
+ cleanup();
+
+ OomTestExecuter::runAllTests(*this, "t_exceptionSafety");
+}
+
+
+/*!
+ UT_PSetCallBarringWrapper::simulateLeaveAtMockMethodCall
+ */
+void UT_PSetCallBarringWrapper::simulateLeaveAtMockMethodCall()
+{
+ User::Leave(KErrGeneral);
+}
+
+QTEST_MAIN_S60(UT_PSetCallBarringWrapper)