diff -r 594d59766373 -r 7d48bed6ce0c cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetcallbarringwrapper/ut_psetcallbarringwrapper.cpp
--- /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)