260     setting.iServiceGroup = EServiceGroupVoice;

   260     setting.iServiceGroup = EServiceGroupVoice;

   261     setting.iPassword.Copy(KPassword());

   261     setting.iPassword.Copy(KPassword());

   262     EXPECT(CPsetCallBarring, SetBarringL)

   262     EXPECT(CPsetCallBarring, SetBarringL)

   263         .with(setting, EAllTeleAndBearer);

   263         .with(setting, EAllTeleAndBearer);

   264     m_wrapper->enableBarring(

   264     m_wrapper->enableBarring(

   265         ServiceGroupVoice, 

   266         ServiceGroupVoice, 

   266         PSetCallBarringWrapper::BarringTypeAllBarrings,

   267         PSetCallBarringWrapper::BarringTypeAllBarrings,

   267         QString("1234"));

   268         QString("1234"));

   268 

   269 

   269     setting.iType = EBarringTypeAllOutgoing;

   270     setting.iType = EBarringTypeAllOutgoing;

   270     EXPECT(CPsetCallBarring, SetBarringL)

   271     EXPECT(CPsetCallBarring, SetBarringL)

   271         .with(setting, EAllTeleAndBearer);

   272         .with(setting, EAllTeleAndBearer);

   272     m_wrapper->enableBarring(

   273     m_wrapper->enableBarring(

   273         ServiceGroupVoice, 

   275         ServiceGroupVoice, 

   274         PSetCallBarringWrapper::BarringTypeAllOutgoing,

   276         PSetCallBarringWrapper::BarringTypeAllOutgoing,

   275         QString("1234"));

   277         QString("1234"));

   276     

   278     

   277     setting.iType = EBarringTypeOutgoingInternational;

   279     setting.iType = EBarringTypeOutgoingInternational;

   278     EXPECT(CPsetCallBarring, SetBarringL)

   280     EXPECT(CPsetCallBarring, SetBarringL)

   279         .with(setting, EAllTeleAndBearer);

   281         .with(setting, EAllTeleAndBearer);

   280     m_wrapper->enableBarring(

   282     m_wrapper->enableBarring(

   281         ServiceGroupVoice, 

   284         ServiceGroupVoice, 

   282         PSetCallBarringWrapper::BarringTypeOutgoingInternational,

   285         PSetCallBarringWrapper::BarringTypeOutgoingInternational,

   283         QString("1234"));

   286         QString("1234"));

   284 

   287 

   285     setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;

   288     setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;

   286     EXPECT(CPsetCallBarring, SetBarringL)

   289     EXPECT(CPsetCallBarring, SetBarringL)

   287         .with(setting, EAllTeleAndBearer);

   290         .with(setting, EAllTeleAndBearer);

   288     m_wrapper->enableBarring(

   291     m_wrapper->enableBarring(

   289         ServiceGroupVoice, 

   293         ServiceGroupVoice, 

   290         PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,

   294         PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,

   291         QString("1234"));

   295         QString("1234"));

   292     

   296     

   293     setting.iType = EBarringTypeAllIncoming;

   297     setting.iType = EBarringTypeAllIncoming;

   294     EXPECT(CPsetCallBarring, SetBarringL)

   298     EXPECT(CPsetCallBarring, SetBarringL)

   295         .with(setting, EAllTeleAndBearer);

   299         .with(setting, EAllTeleAndBearer);

   296     m_wrapper->enableBarring(

   300     m_wrapper->enableBarring(

   297         ServiceGroupVoice, 

   302         ServiceGroupVoice, 

   298         PSetCallBarringWrapper::BarringTypeAllIncoming,

   303         PSetCallBarringWrapper::BarringTypeAllIncoming,

   299         QString("1234"));

   304         QString("1234"));

   300     

   305     

   301     setting.iType = EBarringTypeIncomingWhenRoaming;

   306     setting.iType = EBarringTypeIncomingWhenRoaming;

   302     EXPECT(CPsetCallBarring, SetBarringL)

   307     EXPECT(CPsetCallBarring, SetBarringL)

   303         .with(setting, EAllTeleAndBearer);

   308         .with(setting, EAllTeleAndBearer);

   304     m_wrapper->enableBarring(

   309     m_wrapper->enableBarring(

   305         ServiceGroupVoice, 

   311         ServiceGroupVoice, 

   306         PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,

   312         PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,

   307         QString("1234"));

   313         QString("1234"));

   308     

   314     

   309     setting.iType = EBarringTypeAllServices;

   315     setting.iType = EBarringTypeAllServices;

   310     EXPECT(CPsetCallBarring, SetBarringL)

   316     EXPECT(CPsetCallBarring, SetBarringL)

   311         .with(setting, EAllTeleAndBearer);

   317         .with(setting, EAllTeleAndBearer);

   312     m_wrapper->enableBarring(

   318     m_wrapper->enableBarring(

   313         ServiceGroupVoice, 

   320         ServiceGroupVoice, 

   314         PSetCallBarringWrapper::BarringTypeAllServices,

   321         PSetCallBarringWrapper::BarringTypeAllServices,

   315         QString("1234"));

   322         QString("1234"));

   316 

   323 

   317     setting.iType = EBarringTypeAllOutgoingServices;

   324     setting.iType = EBarringTypeAllOutgoingServices;

   318     EXPECT(CPsetCallBarring, SetBarringL)

   325     EXPECT(CPsetCallBarring, SetBarringL)

   319         .with(setting, EAllTeleAndBearer);

   326         .with(setting, EAllTeleAndBearer);

   320     m_wrapper->enableBarring(

   327     m_wrapper->enableBarring(

   321         ServiceGroupVoice, 

   329         ServiceGroupVoice, 

   322         PSetCallBarringWrapper::BarringTypeAllOutgoingServices,

   330         PSetCallBarringWrapper::BarringTypeAllOutgoingServices,

   323         QString("1234"));

   331         QString("1234"));

   324     

   332     

   325     setting.iType = EBarringTypeAllIncomingServices;

   333     setting.iType = EBarringTypeAllIncomingServices;

   326     EXPECT(CPsetCallBarring, SetBarringL)

   334     EXPECT(CPsetCallBarring, SetBarringL)

   327         .with(setting, EAllTeleAndBearer);

   335         .with(setting, EAllTeleAndBearer);

   328     m_wrapper->enableBarring(

   336     m_wrapper->enableBarring(

   329         ServiceGroupVoice, 

   338         ServiceGroupVoice, 

   330         PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   339         PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   331         QString("1234"));

   340         QString("1234"));

   332 

   341 

   333 // error handling    

   342 // error handling    

   334     EXPECT(CPsetCallBarring, SetBarringL)

   343     EXPECT(CPsetCallBarring, SetBarringL)

   335         .willOnce(invokeWithoutArguments(simulateLeaveL));

   344         .willOnce(invokeWithoutArguments(simulateLeaveL));

   336     EXPECT_EXCEPTION(

   345     EXPECT_EXCEPTION(

   337         m_wrapper->enableBarring(

   346         m_wrapper->enableBarring(

   338             ServiceGroupVoice, 

   348             ServiceGroupVoice, 

   339             PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   349             PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   340             QString("1234"));

   350             QString("1234"));

   341     )

   351     )

   342     

   352     

   356     setting.iServiceGroup = EServiceGroupVoice;

   366     setting.iServiceGroup = EServiceGroupVoice;

   357     setting.iPassword.Copy(KPassword());

   367     setting.iPassword.Copy(KPassword());

   358     EXPECT(CPsetCallBarring, SetBarringL)

   368     EXPECT(CPsetCallBarring, SetBarringL)

   359         .with(setting, EAllTeleAndBearer);

   369         .with(setting, EAllTeleAndBearer);

   360     m_wrapper->disableBarring(

   370     m_wrapper->disableBarring(

   361         ServiceGroupVoice, 

   372         ServiceGroupVoice, 

   362         PSetCallBarringWrapper::BarringTypeAllBarrings,

   373         PSetCallBarringWrapper::BarringTypeAllBarrings,

   363         QString("1234"));

   374         QString("1234"));

   364 

   375 

   365     setting.iType = EBarringTypeAllOutgoing;

   376     setting.iType = EBarringTypeAllOutgoing;

   366     EXPECT(CPsetCallBarring, SetBarringL)

   377     EXPECT(CPsetCallBarring, SetBarringL)

   367         .with(setting, EAllTeleAndBearer);

   378         .with(setting, EAllTeleAndBearer);

   368     m_wrapper->disableBarring(

   379     m_wrapper->disableBarring(

   369         ServiceGroupVoice, 

   381         ServiceGroupVoice, 

   370         PSetCallBarringWrapper::BarringTypeAllOutgoing,

   382         PSetCallBarringWrapper::BarringTypeAllOutgoing,

   371         QString("1234"));

   383         QString("1234"));

   372     

   384     

   373     setting.iType = EBarringTypeOutgoingInternational;

   385     setting.iType = EBarringTypeOutgoingInternational;

   374     EXPECT(CPsetCallBarring, SetBarringL)

   386     EXPECT(CPsetCallBarring, SetBarringL)

   375         .with(setting, EAllTeleAndBearer);

   387         .with(setting, EAllTeleAndBearer);

   376     m_wrapper->disableBarring(

   388     m_wrapper->disableBarring(

   377         ServiceGroupVoice, 

   390         ServiceGroupVoice, 

   378         PSetCallBarringWrapper::BarringTypeOutgoingInternational,

   391         PSetCallBarringWrapper::BarringTypeOutgoingInternational,

   379         QString("1234"));

   392         QString("1234"));

   380 

   393 

   381     setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;

   394     setting.iType = EBarringTypeOutgoingInternationalExceptToHomeCountry;

   382     EXPECT(CPsetCallBarring, SetBarringL)

   395     EXPECT(CPsetCallBarring, SetBarringL)

   383         .with(setting, EAllTeleAndBearer);

   396         .with(setting, EAllTeleAndBearer);

   384     m_wrapper->disableBarring(

   397     m_wrapper->disableBarring(

   385         ServiceGroupVoice, 

   399         ServiceGroupVoice, 

   386         PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,

   400         PSetCallBarringWrapper::BarringTypeOutgoingInternationalExceptToHomeCountry,

   387         QString("1234"));

   401         QString("1234"));

   388     

   402     

   389     setting.iType = EBarringTypeAllIncoming;

   403     setting.iType = EBarringTypeAllIncoming;

   390     EXPECT(CPsetCallBarring, SetBarringL)

   404     EXPECT(CPsetCallBarring, SetBarringL)

   391         .with(setting, EAllTeleAndBearer);

   405         .with(setting, EAllTeleAndBearer);

   392     m_wrapper->disableBarring(

   406     m_wrapper->disableBarring(

   393         ServiceGroupVoice, 

   408         ServiceGroupVoice, 

   394         PSetCallBarringWrapper::BarringTypeAllIncoming,

   409         PSetCallBarringWrapper::BarringTypeAllIncoming,

   395         QString("1234"));

   410         QString("1234"));

   396     

   411     

   397     setting.iType = EBarringTypeIncomingWhenRoaming;

   412     setting.iType = EBarringTypeIncomingWhenRoaming;

   398     EXPECT(CPsetCallBarring, SetBarringL)

   413     EXPECT(CPsetCallBarring, SetBarringL)

   399         .with(setting, EAllTeleAndBearer);

   414         .with(setting, EAllTeleAndBearer);

   400     m_wrapper->disableBarring(

   415     m_wrapper->disableBarring(

   401         ServiceGroupVoice, 

   417         ServiceGroupVoice, 

   402         PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,

   418         PSetCallBarringWrapper::BarringTypeIncomingWhenRoaming,

   403         QString("1234"));

   419         QString("1234"));

   404     

   420     

   405     setting.iType = EBarringTypeAllServices;

   421     setting.iType = EBarringTypeAllServices;

   406     EXPECT(CPsetCallBarring, SetBarringL)

   422     EXPECT(CPsetCallBarring, SetBarringL)

   407         .with(setting, EAllTeleAndBearer);

   423         .with(setting, EAllTeleAndBearer);

   408     m_wrapper->disableBarring(

   424     m_wrapper->disableBarring(

   409         ServiceGroupVoice, 

   426         ServiceGroupVoice, 

   410         PSetCallBarringWrapper::BarringTypeAllServices,

   427         PSetCallBarringWrapper::BarringTypeAllServices,

   411         QString("1234"));

   428         QString("1234"));

   412 

   429 

   413     setting.iType = EBarringTypeAllOutgoingServices;

   430     setting.iType = EBarringTypeAllOutgoingServices;

   414     EXPECT(CPsetCallBarring, SetBarringL)

   431     EXPECT(CPsetCallBarring, SetBarringL)

   415         .with(setting, EAllTeleAndBearer);

   432         .with(setting, EAllTeleAndBearer);

   416     m_wrapper->disableBarring(

   433     m_wrapper->disableBarring(

   417         ServiceGroupVoice, 

   435         ServiceGroupVoice, 

   418         PSetCallBarringWrapper::BarringTypeAllOutgoingServices,

   436         PSetCallBarringWrapper::BarringTypeAllOutgoingServices,

   419         QString("1234"));

   437         QString("1234"));

   420     

   438     

   421     setting.iType = EBarringTypeAllIncomingServices;

   439     setting.iType = EBarringTypeAllIncomingServices;

   422     EXPECT(CPsetCallBarring, SetBarringL)

   440     EXPECT(CPsetCallBarring, SetBarringL)

   423         .with(setting, EAllTeleAndBearer);

   441         .with(setting, EAllTeleAndBearer);

   424     m_wrapper->disableBarring(

   442     m_wrapper->disableBarring(

   425         ServiceGroupVoice, 

   444         ServiceGroupVoice, 

   426         PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   445         PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   427         QString("1234"));

   446         QString("1234"));

   428     

   447     

   429 // error handling    

   448 // error handling    

   430     EXPECT(CPsetCallBarring, SetBarringL)

   449     EXPECT(CPsetCallBarring, SetBarringL)

   431         .willOnce(invokeWithoutArguments(simulateLeaveL));

   450         .willOnce(invokeWithoutArguments(simulateLeaveL));

   432     EXPECT_EXCEPTION(

   451     EXPECT_EXCEPTION(

   433         m_wrapper->disableBarring(

   452         m_wrapper->disableBarring(

   434             ServiceGroupVoice, 

   454             ServiceGroupVoice, 

   435             PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   455             PSetCallBarringWrapper::BarringTypeAllIncomingServices,

   436             QString("1234"));

   456             QString("1234"));

   437     )

   457     )

   438     

   458     

   700             PSetCallBarringWrapper::BarringStatus, 

   720             PSetCallBarringWrapper::BarringStatus, 

   701             bool)));

   721             bool)));

   702     

   722     

   703     TCallBarringSetting setting;

   723     TCallBarringSetting setting;

   704     m_wrapper->enableBarring(

   724     m_wrapper->enableBarring(

   705         ServiceGroupVoice, 

   726         ServiceGroupVoice, 

   706         PSetCallBarringWrapper::BarringTypeAllBarrings,

   727         PSetCallBarringWrapper::BarringTypeAllBarrings,

   707         QString("1234"));

   728         QString("1234"));

   708     QT_TRAP_THROWING(

   729     QT_TRAP_THROWING(

   709         m_wrapper->m_privateImpl->HandleBarringModeChangedL(

   730         m_wrapper->m_privateImpl->HandleBarringModeChangedL(

   739             PSetCallBarringWrapper::BarringStatus, 

   760             PSetCallBarringWrapper::BarringStatus, 

   740             bool)));

   761             bool)));

   741     

   762     

   742     TCallBarringSetting setting;

   763     TCallBarringSetting setting;

   743     m_wrapper->disableBarring(

   764     m_wrapper->disableBarring(

   744         ServiceGroupVoice, 

   766         ServiceGroupVoice, 

   745         PSetCallBarringWrapper::BarringTypeAllBarrings,

   767         PSetCallBarringWrapper::BarringTypeAllBarrings,

   746         QString("1234"));

   768         QString("1234"));

   747     QT_TRAP_THROWING(

   769     QT_TRAP_THROWING(

   748         m_wrapper->m_privateImpl->HandleBarringModeChangedL(

   770         m_wrapper->m_privateImpl->HandleBarringModeChangedL(