/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobilePhoneSetCallBarringStatus is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::SetCallBarringStatus()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0005L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSetCallBarringStatus::KLtsyDispatchSupplementaryServicesSetCallBarringStatusApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMobilePhone::TMobilePhoneCBCondition setCondition = RMobilePhone::EBarIncomingRoaming;
RMobilePhone::TMobilePhoneCBChangeV1 setInfo;
setInfo.iAction = RMobilePhone::EServiceActionDeactivate;
setInfo.iServiceGroup = RMobilePhone::EPadAccess;
_LIT(KPassword,"1234");
setInfo.iPassword = KPassword;
iPhone.SetCallBarringStatus(requestStatus, setCondition, setInfo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(this); // this
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0001
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the NackSmsStored API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestNackSmsStoredL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsNackSmsStored::KLtsyDispatchSmsNackSmsStoredApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, err);
CleanupClosePushL(messaging);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus reqStatus;
TRequestStatus mockLtsyStatus;
RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
_LIT8(KMessage, "Happy New Year");
TBuf8<100> forMsg;
// receiving message:
messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
TSmsMsg smsMsg;
TSmsMsg* smsMsgPtr(&smsMsg);
TBool ind(EFalse);
smsMsg.iSmsClass2 = ETrue;
smsMsg.iDeleteAfterClientAck = ETrue;
smsMsg.iSmsMsg.Copy(KMessage);
TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
compTsyData.SerialiseL(data);
iMockLTSY.CompleteL(KMockLtsyDispatchSmsNotifyReceiveSmsMessageIndId, KErrNone, data);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone, reqStatus.Int());
AssertMockLtsyStatusL();
TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
TInt rpCause(0);
TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);
data.Close();
expTsyData.SerialiseL(data);
messaging.NackSmsStored(reqStatus, KMessage, rpCause);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, &config); // messaging, this, data, config
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0006
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobilePhoneSetCallForwardingStatus is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::SetCallForwardingStatus()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0006L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSetCallForwardingStatus::KLtsyDispatchSupplementaryServicesSetCallForwardingStatusApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMobilePhone::TMobilePhoneCFCondition setCondition = RMobilePhone::ECallForwardingNoReply;
RMobilePhone::TMobilePhoneCFChangeV1 callForwardinginfo;
callForwardinginfo.iAction = RMobilePhone::EServiceActionRegister;
callForwardinginfo.iNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;
callForwardinginfo.iNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
_LIT(KTelNumber,"+74951000000");
callForwardinginfo.iNumber.iTelNumber.Copy(KTelNumber);
callForwardinginfo.iServiceGroup = RMobilePhone::EVoiceService;
callForwardinginfo.iTimeout = 20;
iPhone.SetCallForwardingStatus(requestStatus, setCondition, callForwardinginfo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0008
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobilePhoneSetSSPassword is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::SetSSPassword()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0008L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSetSsPassword::KLtsyDispatchSupplementaryServicesSetSsPasswordApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
_LIT(KOldPassword,"oldPswd");
_LIT(KNewPassword,"newPswd");
RMobilePhone::TMobilePhonePasswordChangeV2 pwdChange;
pwdChange.iOldPassword.Copy(KOldPassword);
pwdChange.iNewPassword.Copy(KNewPassword);
pwdChange.iVerifiedPassword.Copy(KNewPassword);
TPckg<RMobilePhone::TMobilePhonePasswordChangeV2> password(pwdChange);
TUint16 service = 330; // Can be only 0 for all or 330 for Barring
iPhone.SetSSPassword(requestStatus,password,service);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(this); // this
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0016
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the SendAPDUReq API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestSendAPDUReqL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
TBuf8<3> info;
info.Append(1);
info.Append(1);
info.Append(1);
RBuf8 dataBuf;
CleanupClosePushL(dataBuf);
_LIT8(KApduDataExp,"APDU DATA EXP ");
dataBuf.CreateL(KApduDataExp);
RMmCustomAPI::TApdu apdu(info,dataBuf);
TRequestStatus status;
customApi.SendAPDUReq(status, apdu);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(4, &config); // dataBuf, customApi, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0009
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the StoreSmspListEntry API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestStoreSmspListEntryL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsStoreSmspListEntry::KLtsyDispatchSmsStoreSmspListEntryApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
CleanupClosePushL(messaging);
RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
CleanupStack::PushL(smspListPtr);
smspListPtr->AddEntryL(smspEntry);
TRequestStatus status;
messaging.StoreSmspListL(status, smspListPtr);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, &config); // smspListPtr, messaging, this, config
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobilePhoneGetWaitingStatusPhase1 is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes CRetrieveMobilePhoneCWList::Start()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0002L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesGetCallWaitingStatus::KLtsyDispatchSupplementaryServicesGetCallWaitingStatusApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
CFilteringActiveScheduler scheduler;
CActiveScheduler::Install(&scheduler);
CRetrieveMobilePhoneCWList* asyncRetrieveMobilePhoneCWList = CRetrieveMobilePhoneCWList::NewL(iPhone);
CleanupStack::PushL(asyncRetrieveMobilePhoneCWList);
CActiveRetriever::ResetRequestsNumber();
CActiveRetriever* activeRetriever = CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCWList);
CleanupStack::PushL(activeRetriever);
scheduler.AddRetrieverL(*activeRetriever);
RMobilePhone::TMobileInfoLocation location = RMobilePhone::EInfoLocationCachePreferred;
asyncRetrieveMobilePhoneCWList->Start(activeRetriever->iStatus, location);
activeRetriever->Activate();
scheduler.StartScheduler();
ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());
ASSERT_EQUALS(KErrNotSupported, activeRetriever->iStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(3, this); // activeRetriever, asyncRetrieveMobilePhoneCWList, this
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0011
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobileUssdMessagingSendMessageNoFdnCheck is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessageNoFdnCheck()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0011L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck::KLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheckApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMobileUssdMessaging ussdMessaging;
ASSERT_EQUALS(KErrNone, ussdMessaging.Open(iPhone));
CleanupClosePushL(ussdMessaging);
_LIT8(KMsg1,"SendMessage1.1");
RMobileUssdMessaging::TGsmUssdMessageData expSendData(KMsg1);
RMobileUssdMessaging::TMobileUssdAttributesV1 expSendAttr;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg sendAttrPckg(expSendAttr);
ussdMessaging.SendMessageNoFdnCheck(requestStatus, expSendData, sendAttrPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, this); // ussdMessaging, this
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0012
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobileUssdMessagingSendRelease is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0012L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSendUssdRelease::KLtsyDispatchSupplementaryServicesSendUssdReleaseApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMobileUssdMessaging ussdMessaging;
ASSERT_EQUALS(KErrNone, ussdMessaging.Open(iPhone));
CleanupClosePushL(ussdMessaging);
RMobilePhone::TMobilePhoneSendSSRequestV3 sendSSRequest;
RMobilePhone::TMobilePhoneSendSSRequestV3Pckg sendSSRequestPckg(sendSSRequest);
ussdMessaging.SendRelease(requestStatus, sendSSRequestPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, this); // ussdMessaging, this
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0006
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the SendMessageNoFdnCheck API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestSendMessageNoFdnCheckL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsSendSmsMessageNoFdnCheck::KLtsyDispatchSmsSendSmsMessageNoFdnCheckApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
CleanupClosePushL(messaging);
_LIT8(KMessage, "Hello");
RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
TRequestStatus status;
messaging.SendMessageNoFdnCheck(status, KMessage, smsAttrPckg);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, &config); // messaging, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0004
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the GetMessageStoreInfo (a.k.a GetSmsStoreInfo) API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestGetSmsStoreInfoL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
CleanupClosePushL(messaging);
RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);
TInt index(0);
TRequestStatus status;
messaging.GetMessageStoreInfo(status, index, pckgInfo);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, &config); // messaging, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0010
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the ChangeSecurityCode API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestChangeSecurityCodeL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimChangeSecurityCode::KLtsyDispatchSimChangeSecurityCodeApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
_LIT(KOldPwd,"oldPswd");
_LIT(KNewPwd,"newPswd");
RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange;
pwdChange.iNewPassword = KNewPwd;
pwdChange.iOldPassword = KOldPwd;
// Choose Phone Device Lock
RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
TRequestStatus status;
iPhone.ChangeSecurityCode(status, secCode, pwdChange);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, &config); // this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0025
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the GetSimAuthenticationEapSimData API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestGetSimAuthenticationEapSimDataL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimGetSimAuthenticationEapSimData::KLtsyDispatchSimGetSimAuthenticationEapSimDataApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
// generate a random parameter
TUint32 randomValue;
TBuf8<16> randomParameter;
for (TInt i = 0; i< 16; i++)
{
randomValue = Math::Random();
randomParameter.Append(randomValue);
}
RMmCustomAPI::TSimAuthenticationEapSim eapSim;
eapSim.iRandomParameters.Copy(randomParameter);
RMmCustomAPI::TSimDataPckg simDataPckg(eapSim);
TRequestStatus status;
customApi.GetWlanSimAuthenticationData(status, simDataPckg);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(3, &config); // customAPI, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0023
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the GetAnswerToReset (ATR) API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestGetAnswerToResetL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimGetAnswerToReset::KLtsyDispatchSimGetAnswerToResetApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
_LIT8(KAnswerToResetSend, "ExampleAnswerToResetSend");
TBuf8<100> answerToReset(KAnswerToResetSend);
TRequestStatus status;
customApi.GetATR(status, answerToReset);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(3, &config); // customAPI, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0022
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned for both async & sync APIs
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestDeActivateSimLockL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
_LIT(KPassword, "12345");
RMmCustomAPI::TSimLockPassword simLockPassword;
RMmCustomAPI::TLockNumber lockNumber;
lockNumber = RMmCustomAPI::EOperator;
simLockPassword.Copy(KPassword);
TRequestStatus status;
// async version
customApi.DeActivateSimLock(status, simLockPassword, lockNumber);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
// synchronous version
TInt ret = customApi.DeActivateSimLock(simLockPassword, lockNumber);
ASSERT_EQUALS(ret, KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(3, &config); // customAPI, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0003
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the CreateConference API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsyCallControlMultipartyFUNegative::TestCreateConferenceL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchCallControlMultipartyCreateConference::KLtsyDispatchCallControlMultipartyCreateConferenceApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
// Set up correct conditions to be able to create a conference
TInt callId1 = 1;
TInt callId2 = 2;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
DriverDialAndHoldFirstCallDialSecondCallL(mobileService, callId1, callId2);
RMobileLine mobileLine;
CleanupClosePushL(mobileLine);
RMobileCall mobileCall;
CleanupClosePushL(mobileCall);
RMobileLine mobileLine2;
CleanupClosePushL(mobileLine2);
RMobileCall mobileCall2;
CleanupClosePushL(mobileCall2);
ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
mobileCall2, mobileLine2);
RMobileConferenceCall confCall;
CleanupClosePushL(confCall);
ASSERT_EQUALS(KErrNone, confCall.Open(iPhone));
// Hang up cause for normal hang up
DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse);
DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing);
TRequestStatus status;
confCall.CreateConference(status);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
// Hang up the calls
ClientHangUpCallL(mobileCall);
ClientHangUpCallL(mobileCall2);
User::After(100000); // Allow the lifetimer to be updated before ending the test
mobileCall.Close();
mobileCall2.Close();
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, &config);
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0020
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the ReadSimFile API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestReadSimFileL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimReadSimFile::KLtsyDispatchSimReadSimFileApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
//example Ef(Imsi) path
RMmCustomAPI::TSimFilePath path;
path.Append(0x3F);
path.Append(0x00);
path.Append(0x7F);
path.Append(0x00);
path.Append(0x6F);
path.Append(0x07);
path.Append(0x00);
path.Append(0x00);
const TUint16 offset = 0;
const TUint16 size = 15;
RMmCustomAPI::TSimFileInfo simFileInfo;
simFileInfo.iPath = path;
simFileInfo.iOffSet = offset;
simFileInfo.iSize = size;
RMmCustomAPI::TSimFileInfoPckg simFileInfoPckg(simFileInfo);
TBuf8<20> responseBytes;
TRequestStatus status;
customApi.ReadSimFile(status, simFileInfoPckg, responseBytes);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(3, &config); // customAPI, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0008
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the DeleteAPNName API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestDeleteAPNNameL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimDeleteApnName::KLtsyDispatchSimDeleteApnNameApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus status;
iPhone.DeleteAPNName(status, 1);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, &config); // this, config
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobilePhoneSendNetworkServiceRequestNoFdnCheck is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::SendNetworkServiceRequestNoFdnCheck()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0001L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheckApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
_LIT(KMsg2,"SendNetworkServiceRequest1.2");
TName expServiceStringNoFDN(KMsg2);
iPhone.SendNetworkServiceRequestNoFdnCheck(requestStatus, expServiceStringNoFDN);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0013
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if ECustomClearCallBlackListIPC is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ClearCallBlackList()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0013L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesClearBlacklist::KLtsyDispatchSupplementaryServicesClearBlacklistApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
customApi.ClearCallBlackList(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, this); // customApi, this
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0005
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the SetApnControlListServiceStatus API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call SetAPNControlListServiceStatus, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestSetApnControlListServiceStatusL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimSetApnControlListServiceStatus::KLtsyDispatchSimSetApnControlListServiceStatusApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobilePhone::TAPNControlListServiceStatus statusSet = RMobilePhone::EAPNControlListServiceEnabled;
TRequestStatus status;
iPhone.SetAPNControlListServiceStatus(status, statusSet);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, &config); // this, config
}
/**
@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-NEGATIVE-UN0007
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test returned value if EMobilePhoneSetCallWaitingStatus is not supported by LTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::SetCallWaitingStatus()
@SYMTestExpectedResults Pass
@SYMTestType UT
*/
void CCTsySupplementaryServicesFUNegative::TestUnit0007L()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSupplementaryServicesSetCallWaitingStatus::KLtsyDispatchSupplementaryServicesSetCallWaitingStatusApiId, EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMobilePhone::TMobileService setService = RMobilePhone::EPadAccess;
RMobilePhone::TMobilePhoneServiceAction setAction = RMobilePhone::EServiceActionActivate;
iPhone.SetCallWaitingStatus(requestStatus, setService, setAction);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(this); // this
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0011
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the GetSubscriberId API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestGetSubscriberIdL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobilePhone::TMobilePhoneSubscriberId idGet;
TRequestStatus status;
iPhone.GetSubscriberId(status, idGet);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, &config); // this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0005
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the ReadSmspListPhase1L API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API via the CRetrieveMobilePhoneSmspList AO, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestGetSmspListL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsGetSmspList::KLtsyDispatchSmsGetSmspListApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
CleanupClosePushL(messaging);
//CFilteringActiveScheduler does not need to be used, this should be changed
//to a listretrieverao type class (see "listretrieverao.h")
CFilteringActiveScheduler* scheduler = new (ELeave) CFilteringActiveScheduler();
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
CRetrieveMobilePhoneSmspList* asyncRetrieveList
= CRetrieveMobilePhoneSmspList::NewL(messaging);
CleanupStack::PushL(asyncRetrieveList);
CActiveRetriever::ResetRequestsNumber();
CActiveRetriever* activeRetriever =
CActiveRetriever::NewL(*asyncRetrieveList);
CleanupStack::PushL(activeRetriever);
scheduler->AddRetrieverL(*activeRetriever);
asyncRetrieveList->Start(activeRetriever->iStatus);
activeRetriever->Activate();
scheduler->StartScheduler();
ASSERT_EQUALS(CActiveRetriever::ResetRequestsNumber(), 0);
ASSERT_EQUALS(activeRetriever->iStatus.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, &config); // activeRetriever, asyncRetrieveList, scheduler, , messaging, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0015
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the PowerSimOff API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestPowerSimOffL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customApi;
OpenCustomApiLC(customApi);
TRequestStatus status;
customApi.PowerSimOff(status);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(3, &config); // customApi, this, config
}
/**
* @SYMTestCaseID BBA-CTSYD-DIS-SIM-NEGATIVE-UN0002
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the SetIccMessageWaitingIndicators API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestSetIccMessageWaitingIndicatorsL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimSetIccMessageWaitingIndicators::KLtsyDispatchSimSetIccMessageWaitingIndicatorsApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobilePhone::TMobilePhoneMessageWaitingV1 mwiSet;
RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiSetRetPckg(mwiSet);
TRequestStatus status;
iPhone.SetIccMessageWaitingIndicators(status, mwiSetRetPckg);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, &config); // this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0007
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the ResumeSmsReception API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestResumeSmsReceptionL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
CleanupClosePushL(messaging);
TRequestStatus status;
messaging.ResumeSmsReception(status);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, &config); // messaging, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SIM-NEGATIVE-UN0001
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the GetServiceTable API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySimFUNegative::TestGetServiceTableL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneNegativeL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId);
RMobilePhone::TMobilePhoneServiceTableV1 tbData;
RMobilePhone::TMobilePhoneServiceTableV1Pckg pkg(tbData);
TRequestStatus status;
iPhone.GetServiceTable(status, RMobilePhone::EUSIMServiceTable, pkg);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrMMEtelWrongMode);
AssertMockLtsyStatusL();
config.Reset();
CleanupStack::PopAndDestroy(2, &config); // this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0001
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the Hangup API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsyCallControlMultipartyFUNegative::TestHangUpL()
{
// Note: based on original non-negative test void CCTsyCallControlMultipartyFU::TestUseCase0003L()
TConfig config;
config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup, this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
TInt callId1 = 1;
TInt callId2 = 2;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
DriverCreateConferenceCallL(mobileService, callId1, callId2);
DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse);
DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing);
// Client side test
RMobileLine mobileLine;
CleanupClosePushL(mobileLine);
RMobileCall mobileCall;
CleanupClosePushL(mobileCall);
RMobileLine mobileLine2;
CleanupClosePushL(mobileLine2);
RMobileCall mobileCall2;
CleanupClosePushL(mobileCall2);
ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
mobileCall2, mobileLine2);
RMobileConferenceCall confCall;
CleanupClosePushL(confCall);
TRequestStatus notifyCall1Status;
RMobileCall::TMobileCallStatus call1Status;
mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status);
ClientCreateConferenceCallL(confCall);
User::WaitForRequest(notifyCall1Status);
ASSERT_EQUALS(KErrNone, notifyCall1Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status);
TRequestStatus hangupStatus;
confCall.HangUp(hangupStatus);
User::WaitForRequest(hangupStatus);
ASSERT_EQUALS(KErrNotSupported, hangupStatus.Int());
// Boths calls should still be connected
RMobileCall::TMobileCallStatus callStatus;
ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus));
ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
ASSERT_EQUALS(KErrNone, mobileCall2.GetMobileCallStatus(callStatus));
ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
// Hang up the calls
ClientHangUpCallL(mobileCall);
ClientHangUpCallL(mobileCall2);
User::After(100000); // Allow the lifetimer to be updated before ending the test
mobileCall.Close();
mobileCall2.Close();
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, &config); // confCall, this, config
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0005
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the GoOneToOne API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsyCallControlMultipartyFUNegative::TestGoOneToOneL()
{
// Note: Equiv non-negative test CCTsyCallControlMultipartyFU::TestUseCase0008L()
TConfig config;
config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceGoOneToOne::KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup, this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
TInt callId1 = 1;
TInt callId2 = 2;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
DriverCreateConferenceCallL(mobileService, callId1, callId2);
RArray<TInt> callIds;
CleanupClosePushL( callIds );
callIds.AppendL( callId1 );
callIds.AppendL( callId2 );
TMockLtsyData1<RArray<TInt> > ltsyData(callIds);
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId, data);
iMockLTSY.CompleteL(MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId, KErrNone);
DriverCompleteSuccessfulHangUpNotificationsL(callId1, EFalse, KErrGsmCCNormalCallClearing, EFalse);
DriverCompleteSuccessfulHangUpNotificationsL(callId2, EFalse, KErrGsmCCNormalCallClearing, ETrue);
// Client Side Test
RMobileLine mobileLine;
CleanupClosePushL(mobileLine);
RMobileCall mobileCall;
CleanupClosePushL(mobileCall);
RMobileLine mobileLine2;
CleanupClosePushL(mobileLine2);
RMobileCall mobileCall2;
CleanupClosePushL(mobileCall2);
ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
mobileCall2, mobileLine2);
RMobileConferenceCall confCall;
CleanupClosePushL(confCall);
TRequestStatus notifyCall1Status;
RMobileCall::TMobileCallStatus call1Status;
mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status);
ClientCreateConferenceCallL(confCall);
User::WaitForRequest(notifyCall1Status);
ASSERT_EQUALS(KErrNone, notifyCall1Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status);
TRequestStatus oneToOneStatus;
mobileCall2.GoOneToOne(oneToOneStatus);
User::WaitForRequest(oneToOneStatus);
ASSERT_EQUALS(KErrNotSupported, oneToOneStatus.Int());
TInt numCalls;
ASSERT_EQUALS(KErrNone, confCall.EnumerateCalls(numCalls));
ASSERT_EQUALS(2, numCalls);
TRequestStatus hangupStatus;
confCall.HangUp(hangupStatus);
User::WaitForRequest(hangupStatus);
ASSERT_EQUALS(KErrNone, hangupStatus.Int());
mobileCall.Close();
mobileCall2.Close();
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(9, &config);
}
