/**
* @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-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-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-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-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-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-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-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-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);
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0004
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the Swap API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsyCallControlMultipartyFUNegative::TestSwapL()
{
// Note: Equiv non-negative test is CCTsyCallControlMultipartyFU::TestUseCase0006L
TConfig config;
config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceSwap::KLtsyDispatchCallControlMultipartyConferenceSwapApiId, 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;
DriverCreateConferenceCallAndHoldItL(mobileService, callId1, callId2);
TInt callId3 = 3;
DriverDialCallL(callId3, mobileService);
DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse);
DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing, EFalse);
DriverHangUpCallL(callId3, KErrGsmCCNormalCallClearing);
// Client side test
RMobileLine mobileLine;
CleanupClosePushL(mobileLine);
RMobileCall mobileCall;
CleanupClosePushL(mobileCall);
RMobileLine mobileLine2;
CleanupClosePushL(mobileLine2);
RMobileCall mobileCall2;
CleanupClosePushL(mobileCall2);
RMobileConferenceCall confCall;
CleanupClosePushL(confCall);
ClientCreateConferenceCallAndHoldItL(mobileService, mobileCall,
mobileLine, mobileCall2, mobileLine2, confCall);
TRequestStatus notifyCall1Status;
RMobileCall::TMobileCallStatus call1Status;
mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status);
TRequestStatus notifyCall2Status;
RMobileCall::TMobileCallStatus call2Status;
mobileCall2.NotifyMobileCallStatusChange(notifyCall2Status, call2Status);
// Dial a new call and attempt to swap the conference with it
RMobileLine mobileLine3;
CleanupClosePushL(mobileLine3);
RMobileCall mobileCall3;
CleanupClosePushL(mobileCall3);
ClientDialCallL(mobileLine3, mobileCall3, mobileService);
User::WaitForRequest(notifyCall1Status);
ASSERT_EQUALS(KErrNone, notifyCall1Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status);
mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status);
TRequestStatus swapStatus;
confCall.Swap(swapStatus);
User::WaitForRequest(swapStatus);
ASSERT_EQUALS(KErrNotSupported, swapStatus.Int());
User::WaitForRequest(notifyCall1Status);
ASSERT_EQUALS(KErrNone, notifyCall1Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusHold, call1Status);
User::WaitForRequest(notifyCall2Status);
ASSERT_EQUALS(KErrNone, notifyCall2Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusHold, call2Status);
RMobileConferenceCall::TMobileConferenceStatus confStatus;
ASSERT_EQUALS(KErrNone, confCall.GetConferenceStatus(confStatus));
ASSERT_EQUALS(RMobileConferenceCall::EConferenceHold, confStatus);
// Hang up the calls
ClientHangUpCallL(mobileCall);
ClientHangUpCallL(mobileCall2);
ClientHangUpCallL(mobileCall3);
User::After(100000); // Allow the lifetimer to be updated before ending the test
mobileCall.Close();
mobileCall2.Close();
mobileCall3.Close();
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(10, &config);
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0002
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the AddCall API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsyCallControlMultipartyFUNegative::TestAddCallL()
{
// Note: based on non-negative test CCTsyCallControlMultipartyFU::TestUseCase0007L()
TConfig config;
config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceAddCall::KLtsyDispatchCallControlMultipartyConferenceAddCallApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup, this));
OpenPhoneL();
TInt callId1 = 1;
TInt callId2 = 2;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
DriverCreateConferenceCallAndHoldItL(mobileService, callId1, callId2);
TInt callId3 = 3;
DriverDialCallL(callId3, mobileService);
DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse);
DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing, EFalse);
DriverHangUpCallL(callId3, 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);
mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status);
TRequestStatus notifyCall2Status;
RMobileCall::TMobileCallStatus call2Status;
mobileCall2.NotifyMobileCallStatusChange(notifyCall2Status, call2Status);
ClientSwapConferenceCallL(confCall, RMobileConferenceCall::EConferenceSwapped,
RMobileConferenceCall::EConferenceHold);
User::WaitForRequest(notifyCall1Status);
ASSERT_EQUALS(KErrNone, notifyCall1Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusHold, call1Status);
User::WaitForRequest(notifyCall2Status);
ASSERT_EQUALS(KErrNone, notifyCall2Status.Int());
ASSERT_EQUALS(RMobileCall::EStatusHold, call2Status);
// Dial a new call and attempt to add it to the conference
RMobileLine mobileLine3;
CleanupClosePushL(mobileLine3);
RMobileCall mobileCall3;
CleanupClosePushL(mobileCall3);
ClientDialCallL(mobileLine3, mobileCall3, mobileService);
RMobileCall::TMobileCallInfoV1 callInfo;
RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(callInfo);
ASSERT_EQUALS(KErrNone, mobileCall3.GetMobileCallInfo(callInfoPckg));
TRequestStatus status;
confCall.AddCall(status, callInfo.iCallName);
User::WaitForRequest(status);
ASSERT_EQUALS(status.Int(), KErrNotSupported);
// Hang up the calls
ClientHangUpCallL(mobileCall);
ClientHangUpCallL(mobileCall2);
ClientHangUpCallL(mobileCall3);
User::After(100000); // Allow the lifetimer to be updated before ending the test
mobileCall.Close();
mobileCall2.Close();
mobileCall3.Close();
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(9, &config);
}
