Latest bug-fixes with added tests.
// Copyright (c) 2007-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:
// The TEFUnit test suite for UssdMessaging in the Common TSY.
//
//
/**
@file
*/
#include "cctsyussdmessagingfu.h"
#include <etel.h>
#include <etelmm.h>
#include <et_clsvr.h>
#include <ctsy/mmtsy_names.h>
#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
#include "tmockltsydata.h"
#include <ctsy/serviceapi/gsmerror.h>
CTestSuite* CCTsyUssdMessagingFU::CreateSuiteL(const TDesC& aName)
{
SUB_SUITE;
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0006L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001cL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001dL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0002bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0004bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002cL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002dL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002eL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002fL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002gL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002hL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002iL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002jL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002kL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004cL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004dL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004eL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004fL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001eL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001cL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001dL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0004bL);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestGetCaps0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestGetCaps0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0006L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0007L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0008L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0009L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0010L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0011L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0013L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0014L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0016L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0017L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestAcceptRejectMisuse0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestAcceptRejectMisuse0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestMultipleIncomingUssdMessages0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageDefaultHandlerWithTestClient0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageDefaultHandlerWithTestClient0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageDefaultHandlerWithTestClient0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageDefaultHandlerWithTestClient0004L);
END_SUITE;
}
//
// Actual test cases
//
/**
@SYMTestCaseID BA-CTSY-USSDM-USM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessage
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessage0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data, KErrNotSupported);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrGeneral);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::SendMessage when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMobileUssdMessaging::SendMessage
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// TEST : to increase CMmUssdTsy::ExtFunc coverage
// covers "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() &&
// ( !IsRequestPossibleInOffline( aIpc ) ) )" condition
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRfStateInfo rfInfo = ERfsStateInfoInactive;
TMockLtsyData1<TRfStateInfo> mockData1(rfInfo);
data.Close();
mockData1.SerialiseL(data);
iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGsmOfflineOpNotAllowed, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::SendMessage
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileUssdMessaging::SendMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessage0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus mockLtsyStatus;
TRequestStatus requestStatus;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
//-------------------------------------------------------------------------
// Test cancelling of RMobileUssdMessaging::SendMessage
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
mockData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone, 10);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingSendMessage);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USM-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessage with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessage with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessage0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// function parameter
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMobileUssdMessaging::SendMessage
//-------------------------------------------------------------------------
TBuf8<1> badSizeDescriptor;
ussdMessaging.SendMessage(requestStatus, msgData, badSizeDescriptor);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USM-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::SendMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::SendMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessage0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMobileUssdMessaging ussdMessaging1;
ret = ussdMessaging1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging1);
RMobileUssdMessaging ussdMessaging2;
ret = ussdMessaging2.Open(phone2);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// parameters for first function
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes1;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes1(attributes1);
attributes1.iFlags = flags;
attributes1.iFormat = format;
attributes1.iType = type;
attributes1.iDcs = dcs;
TName name1 = _L("Name1");
TPckg<TName> msgData1(name1);
//-------------------------------------------------------------------------
// parameters for second function
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes2;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes2(attributes2);
flags = 10;
format = RMobileUssdMessaging::EFormatPackedString;
type = RMobileUssdMessaging::EUssdMOAcknowledgement;
dcs = 20;
attributes2.iFlags = flags;
attributes2.iFormat = format;
attributes2.iType = type;
attributes2.iDcs = dcs;
TName name2 = _L("Name2");
TPckg<TName> msgData2(name2);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name1, attributes1);
mockData2.SerialiseL(data);
RBuf8 data3;
CleanupClosePushL(data3);
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData3(completeName, completeAttributes);
mockData3.SerialiseL(data3);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMobileUssdMessaging::SendMessage
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data3);
ussdMessaging1.ReceiveMessage(requestStatus1, name, msgAttributes);
User::WaitForRequest(requestStatus1);
ret = requestStatus1.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging1.AcceptIncomingDialogue();
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone, 10);
ussdMessaging1.SendMessage(requestStatus1, msgData1, msgAttributes1);
ussdMessaging2.SendMessage(requestStatus2, msgData2, msgAttributes2);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, data, this,
// ussdMessaging1, ussdMessaging2, data3
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USM-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessage with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessage and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessage0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMobileUssdMessaging::SendMessage
//-------------------------------------------------------------------------
mockData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USM-0006
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessage DefaultHandler
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessage DefaultHandler
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessage0006L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data, KErrNotSupported);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrGeneral);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::SendMessage when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMobileUssdMessaging::SendMessage
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// TEST : to increase CMmUssdTsy::ExtFunc coverage
// covers "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() &&
// ( !IsRequestPossibleInOffline( aIpc ) ) )" condition
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRfStateInfo rfInfo = ERfsStateInfoInactive;
TMockLtsyData1<TRfStateInfo> mockData1(rfInfo);
data.Close();
mockData1.SerialiseL(data);
iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGsmOfflineOpNotAllowed, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendRelease
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::SendRelease when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrNone, data);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(opCode, sendV3.iOpCode);
ASSERT_EQUALS(0, completeSendV3.iAdditionalInfo.Compare(sendV3.iAdditionalInfo));
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMobileUssdMessaging::SendRelease
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging, dataTest
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0001b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendRelease
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0001bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease, KErrNotSupported);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrNone, data);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0006
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendRelease without USSD session in progress
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0001cL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus mockLtsyStatus;
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure because there is no USSD session in progress
//-------------------------------------------------------------------------
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrDisconnected, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0001d
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for failure on completion of pending comRMobileUssdMessaging::SendRelease request from LTSY->CTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0001dL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// Failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrGeneral, data);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging, dataTest
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::SendRelease
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// Test cancelling of RMobileUssdMessaging::SendRelease
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrNone, data, 10);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingSendRelease);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0002b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::SendRelease
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0002bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMTRequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrDisconnected, requestStatus.Int());
CleanupStack::PopAndDestroy(3); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendRelease with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMobileUssdMessaging::SendRelease
//-------------------------------------------------------------------------
TBuf8<1> badSizeDescriptor;
ussdMessaging.SendRelease(requestStatus, badSizeDescriptor);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::SendRelease
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
// Open second client
RTelServer telServer2;
ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMobileUssdMessaging ussdMessaging2;
ret = ussdMessaging2.Open(phone2);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// parameters for first function
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV31;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV31(sendV31);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV31;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV31.iOpCode = opCode;
completeSendV31.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData11(completeSendV31);
//-------------------------------------------------------------------------
// parameters for second function
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV32;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV32(sendV32);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMobileUssdMessaging::SendRelease
//-------------------------------------------------------------------------
mockData11.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrNone, data, 10);
ussdMessaging.SendRelease(requestStatus, pckgSendV31);
ussdMessaging2.SendRelease(requestStatus2, pckgSendV32);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrAccessDenied, requestStatus2.Int());
ASSERT_EQUALS(opCode, sendV31.iOpCode);
ASSERT_EQUALS(0, sendV31.iAdditionalInfo.Compare(KAdditionalInfo1));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this); // data, ussdMessaging2, ussdMessaging,
// phone2, telServer2, this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0004a
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::SendRelease
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::SendRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0004bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMTRequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Try to release the dialogue
//-------------------------------------------------------------------------
// Open second client
RTelServer telServer2;
ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMobileUssdMessaging ussdMessaging2;
ret = ussdMessaging2.Open(phone2);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging2);
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
//-------------------------------------------------------------------------
// Test: The second client requests RMobileUssdMessaging::SendRelease
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrDisconnected, data, 10);
TRequestStatus requestStatus2;
ussdMessaging2.SendRelease(requestStatus2, pckgSendV3);
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrDisconnected, requestStatus2.Int());
CleanupStack::PopAndDestroy(6, this); // data, ussdMessaging2, ussdMessaging,
// phone2, telServer2, this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USR-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendRelease with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendRelease and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendRelease0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMobileUssdMessaging::SendRelease
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: Successful completion request of
// RMobileUssdMessaging::ReceiveMessage when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(flags , attributes.iFlags );
ASSERT_EQUALS(format, attributes.iFormat);
ASSERT_EQUALS(type , attributes.iType );
ASSERT_EQUALS(dcs , attributes.iDcs );
ASSERT_EQUALS(0, name.Compare(completeName));
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileUssdMessaging::ReceiveMessage (including via calling Close)
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// Test cancelling of RMobileUssdMessaging::ReceiveMessage
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data, 10);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
//-------------------------------------------------------------------------
// Test Close after calling RMobileUssdMessaging::ReceiveMessage
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data, 10);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
ussdMessaging.Close();
User::After(2 * 1000000);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Two clients present, first client calls Cancel before message received.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST: Two clients have called ReceiveMessage. No session in progress.
// First client calls CancelAsyncRequest with value EMobileUssdMessagingReceiveMessage.
// Request completes with TRequestStatus set to KErrCancel.
// At same time a message received from network. This is offered to second client.
//-------------------------------------------------------------------------
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
ussd1.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForAnyRequest();
ASSERT_EQUALS(KErrCancel, requestStatus1.Int());
User::WaitForAnyRequest();
// Second client receives offer of dialogue.
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
CleanupStack::PopAndDestroy(4, this); // this, data, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002c
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Two clients present, first client calls Cancel AFTER accepting dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002cL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST : Two clients have called ReceiveMessage.
// First client accepts a dialogue THEN calls cancel.
// Request completes with TRequestStatus set to KErrCancel.
//-------------------------------------------------------------------------
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
ussd1.AcceptIncomingDialogue();
User::After(1000000);
ussd1.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
CleanupStack::PopAndDestroy(4, this); // this, data, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002d
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Two clients present, second client calls Cancel.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002dL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST: Two clients have called ReceiveMessage. First accepts a dialogue.
// SECOND client calls CancelAsyncRequest with value EMobileUssdMessagingReceiveMessage.
// Request completes with TRequestStatus set to KErrCancel.
//-------------------------------------------------------------------------
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
ussd1.AcceptIncomingDialogue();
User::After(1000000);
ussd2.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
User::WaitForRequest(requestStatus2);
// Second client receives offer of dialogue.
ASSERT_EQUALS(KErrCancel, requestStatus2.Int());
ussd2.AcceptIncomingDialogue();
CleanupStack::PopAndDestroy(4, this); // this, data, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002e
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Two clients present, second client calls Close().
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002eL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST: Two clients have called ReceiveMessage. No session in progress.
// Second client calls Close(). First client is offered a dialogue and accepts as normal.
//-------------------------------------------------------------------------
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussd1.Close();
User::WaitForAnyRequest();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ussd2.RejectIncomingDialogue();
CleanupStack::PopAndDestroy(4, this); // this, data, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002f
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Cancel one of the clients in the middle of a delivery.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002fL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
RMobileUssdMessaging ussd3;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
TInt ret3 = ussd3.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
ASSERT_EQUALS(KErrNone, ret3);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
CleanupClosePushL(ussd3);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TRequestStatus requestStatus3;
TRequestStatus mockLtsyStatus;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST : Test to cancel one of the clients in the middle of a delivery.
// 1) Have three clients. 2) Request offered to 1st. 3) 2nd client then cancels.
// 4) 1st client rejects request. 5) 3rd client should now be offered request.
//-------------------------------------------------------------------------
ret1 = ussd1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
ussd3.ReceiveMessage(requestStatus3 ,name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForAnyRequest();
AssertMockLtsyStatusL();
// Offered to first client
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
// Cancel second client and First client rejects dialogue
ussd2.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
User::After(1000000);
ussd1.RejectIncomingDialogue();
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrCancel, requestStatus2.Int());
// dialogue offered to third client
ussd3.AcceptIncomingDialogue();
User::WaitForRequest(requestStatus3);
ASSERT_EQUALS(KErrNone, requestStatus3.Int());
CleanupStack::PopAndDestroy(5, this); // this, data, ussd1, ussd2, ussd3
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002g
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Have two clients. Request offered to 1st. 1st client cancels. 2nd client should now be offered request.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002gL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TRequestStatus mockLtsyStatus;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST : Have two clients. 1) Request offered to 1st. 2) 1st client cancels.
// 3) 2nd client should now be offered request.
//-------------------------------------------------------------------------
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForAnyRequest();
AssertMockLtsyStatusL();
// Offered to first client
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
// Cancel first client
ussd2.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrCancel, requestStatus2.Int());
// dialogue offered to second client
ussd1.RejectIncomingDialogue();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
CleanupStack::PopAndDestroy(4, this); // this, data, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002h
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancelling of RMobileUssdMessaging::ReceiveMessage with multiple interested clients.
@SYMTestPriority High
@SYMTestActions Cancel one of the clients in the middle of a delivery.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002hL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
RMobileUssdMessaging ussd3;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
TInt ret3 = ussd3.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
ASSERT_EQUALS(KErrNone, ret3);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
CleanupClosePushL(ussd3);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TRequestStatus requestStatus3;
TRequestStatus mockLtsyStatus;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST : Test to cancel one of the clients in the middle of a delivery.
// 1) Have three clients. 2) Request offered to 1st. 3) 1nd client then cancels.
// 4) 2st client accepts request. The cancel is processed prior to 2nd client accepting.
//-------------------------------------------------------------------------
ret1 = ussd1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ussd1.ReceiveMessage(requestStatus1 ,name, msgAttributes);
ussd2.ReceiveMessage(requestStatus2 ,name, msgAttributes);
ussd3.ReceiveMessage(requestStatus3 ,name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForAnyRequest();
// Offered to first client...
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
// Client cancels.
ussd1.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
// Offered to second client. Client accepts.
ussd2.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
User::WaitForAnyRequest();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
CleanupStack::PopAndDestroy(5, this); // this, data, ussd1, ussd2, ussd3
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002i
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support of RMobileUssdMessaging::ReceiveMessage for consecutive reception of two USSD dialogues/messages by two different clients.
@SYMTestPriority High
@SYMTestActions Two clients present, second client calls Cancel.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002iL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMTNotify;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST: The first client accepts the first USSD notification.
// The SECOND client accepts the second USSD notification.
//-------------------------------------------------------------------------
//first notification
ussd1.ReceiveMessage(requestStatus1, name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForRequest(requestStatus1);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
ussd1.AcceptIncomingDialogue();
//second notification
ussd2.ReceiveMessage(requestStatus2, name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ussd2.AcceptIncomingDialogue();
CleanupStack::PopAndDestroy(4, this); // this, data, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002j
@SYMComponent telephony_ctsy
@SYMTestCaseDesc est support of RMobileUssdMessaging::ReceiveMessage for reception of USSD notification while other client is handling USSD session.
@SYMTestPriority High
@SYMTestActions Two clients present which receive and accept network initiated USSD messages.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002jL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 dataCl1;
CleanupClosePushL(dataCl1);
RBuf8 dataCl2;
CleanupClosePushL(dataCl2);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType typeNotify = RMobileUssdMessaging::EUssdMTNotify;
RMobileUssdMessaging::TMobileUssdMessageType typeReply = RMobileUssdMessaging::EUssdMTRequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributesClient1;
completeAttributesClient1.iFlags = flags;
completeAttributesClient1.iFormat = format;
completeAttributesClient1.iType = typeNotify;
completeAttributesClient1.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributesClient1);
mockData2.SerialiseL(dataCl1);
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributesClient2;
completeAttributesClient2.iFlags = flags;
completeAttributesClient2.iFormat = format;
completeAttributesClient2.iType = typeReply;
completeAttributesClient2.iDcs = dcs;
TBuf8<KMaxName> completeNameCl2 = _L8("Name2");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2Cl2(completeNameCl2, completeAttributesClient2);
mockData2Cl2.SerialiseL(dataCl2);
//-------------------------------------------------------------------------
// TEST: The first client accepts a network initiated USSD request.
// The SECOND client accepts a USSD notification.
//-------------------------------------------------------------------------
//network initiated USSD request
ussd1.ReceiveMessage(requestStatus1, name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, dataCl1);
User::WaitForRequest(requestStatus1);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
ussd1.AcceptIncomingDialogue();
//USSD notification
ussd2.ReceiveMessage(requestStatus2, name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, dataCl2);
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ussd2.AcceptIncomingDialogue();
CleanupStack::PopAndDestroy(5, this); // this, dataCl1, dataCl2, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0002k
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support of RMobileUssdMessaging::ReceiveMessage for network iniated requests.
@SYMTestPriority High
@SYMTestActions Two clients handling network initiated requests.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0002kL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 dataCl1;
CleanupClosePushL(dataCl1);
RBuf8 dataCl2;
CleanupClosePushL(dataCl2);
RMobileUssdMessaging ussd1;
RMobileUssdMessaging ussd2;
TInt ret1 = ussd1.Open(iPhone);
TInt ret2 = ussd2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret1);
ASSERT_EQUALS(KErrNone, ret2);
CleanupClosePushL(ussd1);
CleanupClosePushL(ussd2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType typeNotify = RMobileUssdMessaging::EUssdMTNotify;
RMobileUssdMessaging::TMobileUssdMessageType typeReply = RMobileUssdMessaging::EUssdMTRequest;
TUint8 dcs = 200;
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributesClient1;
completeAttributesClient1.iFlags = flags;
completeAttributesClient1.iFormat = format;
completeAttributesClient1.iType = typeNotify;
completeAttributesClient1.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributesClient1);
mockData2.SerialiseL(dataCl1);
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributesClient2;
completeAttributesClient2.iFlags = flags;
completeAttributesClient2.iFormat = format;
completeAttributesClient2.iType = typeReply;
completeAttributesClient2.iDcs = dcs;
TBuf8<KMaxName> completeNameCl2 = _L8("Name2");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2Cl2(completeNameCl2, completeAttributesClient2);
mockData2Cl2.SerialiseL(dataCl2);
//-------------------------------------------------------------------------
// TEST: The first client accepts a network initiated USSD request.
// The SECOND client rejects a USSD notification.
//-------------------------------------------------------------------------
//network initiated USSD request
ussd1.ReceiveMessage(requestStatus1, name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, dataCl1);
User::WaitForRequest(requestStatus1);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
ussd1.AcceptIncomingDialogue();
//USSD notification
ussd2.ReceiveMessage(requestStatus2, name, msgAttributes);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, dataCl2);
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ussd2.RejectIncomingDialogue();
CleanupStack::PopAndDestroy(5, this); // this, dataCl1, dataCl2, ussd1, ussd2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::ReceiveMessage with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::ReceiveMessage with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// Test C: Test passing out of bounds parameters to
// RPacketQoS::SetProfileParameters
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
TBuf8<1> badName;
ussdMessaging.ReceiveMessage(requestStatus, badName, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMobileUssdMessaging::ReceiveMessage
//-------------------------------------------------------------------------
TBuf8<KMaxName> name;
TBuf8<1> badSizeDescriptor;
ussdMessaging.ReceiveMessage(requestStatus, name, badSizeDescriptor);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RThread thread1;
RThread thread2;
// Populate the test data with a handle to a memory chunk
RChunk chunk1;
RChunk chunk2;
TInt *chunkValue1;
TInt *chunkValue2;
chunk1.CreateLocal((TBool)4, (TInt) 4);
chunk2.CreateLocal((TBool)4, (TInt) 4);
chunkValue1 = (TInt *)chunk1.Base();
chunkValue2 = (TInt *)chunk2.Base();
*chunkValue1 = 0;
*chunkValue2 = 0;
TTestDataWithChunk testData1(chunk1);
TTestDataWithChunk testData2(chunk2);
TInt err = CreateClients( thread1, thread2, testData1, testData2);
ASSERT_EQUALS(KErrNone, err);
//-------------------------------------------------------------------------
// Test : Test multiple clients requesting RMobileUssdMessaging::ReceiveMessage
// First client accepts, not offered to second client.
//-------------------------------------------------------------------------
// Create the threads
testData1.iAcceptDialogue = ETrue;
testData1.iAfterTimePeriod = 0;
testData2.iAcceptDialogue = ETrue;
testData2.iAfterTimePeriod = 0;
MultipleClientRequestsL(thread1, thread2);
thread1.Close();
thread2.Close();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0004b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0004bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RThread thread1;
RThread thread2;
// Populate the test data with a handle to a memory chunk
RChunk chunk1;
RChunk chunk2;
TInt *chunkValue1;
TInt *chunkValue2;
chunk1.CreateLocal((TBool)4, (TInt) 4);
chunk2.CreateLocal((TBool)4, (TInt) 4);
chunkValue1 = (TInt *)chunk1.Base();
chunkValue2 = (TInt *)chunk2.Base();
*chunkValue1 = 0;
*chunkValue2 = 0;
TTestDataWithChunk testData1(chunk1);
TTestDataWithChunk testData2(chunk2);
TInt err = CreateClients( thread1, thread2, testData1, testData2);
ASSERT_EQUALS(KErrNone, err);
//-------------------------------------------------------------------------
// Test : Test multiple clients requesting RMobileUssdMessaging::ReceiveMessage
// First client rejects, second accepts.
//-------------------------------------------------------------------------
// Create the threads
testData1.iAcceptDialogue = EFalse;
testData1.iAfterTimePeriod = 0;
testData2.iAcceptDialogue = ETrue;
testData2.iAfterTimePeriod = 0;
MultipleClientRequestsL(thread1, thread2);
thread1.Close();
thread2.Close();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0004c
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0004cL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RThread thread1;
RThread thread2;
// Populate the test data with a handle to a memory chunk
RChunk chunk1;
RChunk chunk2;
TInt *chunkValue1;
TInt *chunkValue2;
chunk1.CreateLocal((TBool)4, (TInt) 4);
chunk2.CreateLocal((TBool)4, (TInt) 4);
chunkValue1 = (TInt *)chunk1.Base();
chunkValue2 = (TInt *)chunk2.Base();
*chunkValue1 = 0;
*chunkValue2 = 0;
TTestDataWithChunk testData1(chunk1);
TTestDataWithChunk testData2(chunk2);
TInt err = CreateClients( thread1, thread2, testData1, testData2);
ASSERT_EQUALS(KErrNone, err);
//-------------------------------------------------------------------------
// Test : Test multiple clients requesting ReceiveMessage,
// first client fails to accept in time. Second client accepts before time-out.
//-------------------------------------------------------------------------
testData1.iAcceptDialogue = ETrue;
testData1.iAfterTimePeriod = 6; //Time-out
testData2.iAcceptDialogue = ETrue;
testData2.iAfterTimePeriod = 2; //Time-in
MultipleClientRequestsL(thread1, thread2);
thread1.Close();
thread2.Close();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0004d
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0004dL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RThread thread1;
RThread thread2;
// Populate the test data with a handle to a memory chunk
RChunk chunk1;
RChunk chunk2;
TInt *chunkValue1;
TInt *chunkValue2;
chunk1.CreateLocal((TBool)4, (TInt) 4);
chunk2.CreateLocal((TBool)4, (TInt) 4);
chunkValue1 = (TInt *)chunk1.Base();
chunkValue2 = (TInt *)chunk2.Base();
*chunkValue1 = 0;
*chunkValue2 = 0;
TTestDataWithChunk testData1(chunk1);
TTestDataWithChunk testData2(chunk2);
TInt err = CreateClients( thread1, thread2, testData1, testData2);
ASSERT_EQUALS(KErrNone, err);
//-------------------------------------------------------------------------
// Test: Test multiple clients requesting ReceiveMessage,
// Both clients reject, no default/catch-all
//-------------------------------------------------------------------------
testData1.iAcceptDialogue = EFalse;
testData1.iAfterTimePeriod = 0;
testData1.iAcceptDialogue = EFalse;
testData2.iAfterTimePeriod = 0;
MultipleClientRequestsL(thread1, thread2);
thread1.Close();
thread2.Close();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0004e
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0004eL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RThread thread1;
RThread thread2;
// Populate the test data with a handle to a memory chunk
RChunk chunk1;
RChunk chunk2;
TInt *chunkValue1;
TInt *chunkValue2;
chunk1.CreateLocal((TBool)4, (TInt) 4);
chunk2.CreateLocal((TBool)4, (TInt) 4);
chunkValue1 = (TInt *)chunk1.Base();
chunkValue2 = (TInt *)chunk2.Base();
*chunkValue1 = 0;
*chunkValue2 = 0;
TTestDataWithChunk testData1(chunk1);
TTestDataWithChunk testData2(chunk2);
TInt err = CreateClients( thread1, thread2, testData1, testData2);
ASSERT_EQUALS(KErrNone, err);
//-------------------------------------------------------------------------
// Test: Test multiple clients requesting ReceiveMessage,
// First client times out before accepting (too late), Second client rejects message.
//-------------------------------------------------------------------------
testData1.iAcceptDialogue = ETrue;
testData1.iAfterTimePeriod = 0;
testData2.iAcceptDialogue = EFalse;
testData2.iAfterTimePeriod = 2;
MultipleClientRequestsL(thread1, thread2);
thread1.Close();
thread2.Close();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0004f
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessage0004fL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RThread thread1;
RThread thread2;
// Populate the test data with a handle to a memory chunk
RChunk chunk1;
RChunk chunk2;
TInt *chunkValue1;
TInt *chunkValue2;
chunk1.CreateLocal((TBool)4, (TInt) 4);
chunk2.CreateLocal((TBool)4, (TInt) 4);
chunkValue1 = (TInt *)chunk1.Base();
chunkValue2 = (TInt *)chunk2.Base();
*chunkValue1 = 0;
*chunkValue2 = 0;
TTestDataWithChunk testData1(chunk1);
TTestDataWithChunk testData2(chunk2);
testData1.iAcceptDialogue = EFalse;
testData1.iAfterTimePeriod = 0;
testData2.iAcceptDialogue = ETrue;
testData2.iAfterTimePeriod = 0;
TInt err = CreateClients( thread1, thread2, testData1, testData2);
ASSERT_EQUALS(KErrNone, err);
//-------------------------------------------------------------------------
// Test : Test multiple clients requesting RMobileUssdMessaging::ReceiveMessage
// Message completes with an error. First client rejects, second accepts.
//-------------------------------------------------------------------------
RBuf8 data;
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
thread1.Logon(requestStatus1);
thread2.Logon(requestStatus2);
thread1.Resume();
thread2.Resume();
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrCorrupt, data);
User::WaitForAnyRequest();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
data.Close();
thread1.Close();
thread2.Close();
CleanupStack::PopAndDestroy(this); // this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMOAcknowledgement;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2Release(completeSendV3,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2Release.SerialiseL(data2);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::NotifyNetworkRelease when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNone, data);
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(opCode, sendV3.iOpCode);
ASSERT_EQUALS(0, sendV3.iAdditionalInfo.Compare(KAdditionalInfo1));
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMobileUssdMessaging::NotifyNetworkRelease
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNone, data);
// other version of API (with optional TMobileUssdAttributesV1 parameter)
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNone, data2);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(4, this); // data2, ussdMessaging, data, this,
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0001a
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for failure on completion of pending comRMobileUssdMessaging::SendRelease request from LTSY->CTSY
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0001eL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMOAcknowledgement;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2Release(completeSendV3,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2Release.SerialiseL(data2);
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrGeneral, data);
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
CleanupStack::PopAndDestroy(4, this); // data2, ussdMessaging, data, this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0001b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::NotifyNetworkRelease with optional paramter
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0001bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMOAcknowledgement;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2Release(completeSendV3,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2Release.SerialiseL(data2);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::NotifyNetworkRelease when result is not cached.
// other version of API (with optional TMobileUssdAttributesV1 parameter)
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNone, data2);
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3, pckgAttrV1);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(opCode, sendV3.iOpCode);
ASSERT_EQUALS(0, sendV3.iAdditionalInfo.Compare(KAdditionalInfo1));
ASSERT_EQUALS(completeAttrV1.iFlags ,attrV1.iFlags);
ASSERT_EQUALS(completeAttrV1.iFormat ,attrV1.iFormat);
ASSERT_EQUALS(completeAttrV1.iType ,attrV1.iType);
CleanupStack::PopAndDestroy(4, this); // data2, ussdMessaging, data, this,
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0001c
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0001cL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMOAcknowledgement;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2Release(completeSendV3,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2Release.SerialiseL(data2);
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
// other version of API (with optional TMobileUssdAttributesV1 parameter)
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNotReady, data2);
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3, pckgAttrV1);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotReady, requestStatus.Int());
CleanupStack::PopAndDestroy(4, this); // data2, ussdMessaging, data, this,
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0001d
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::NotifyNetworkRelease before accepting a dialogue
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0001dL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// function parameters
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
// optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMOAcknowledgement;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2Release(completeSendV3,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2Release.SerialiseL(data2);
//Testing NotifyNetworkRelease() before accepting the dialogue,
//so that the requests are not always very sequential
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3, pckgAttrV1);
ussdMessaging.AcceptIncomingDialogue();
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrDisconnected, requestStatus.Int());
CleanupStack::PopAndDestroy(4, this); // data2, ussdMessaging, data, this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
//-------------------------------------------------------------------------
// Test cancelling of RMobileUssdMessaging::NotifyNetworkRelease
//-------------------------------------------------------------------------
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3);
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingNotifyNetworkRelease);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
// again with the optional parameter
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3, pckgAttrV1);
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingNotifyNetworkRelease);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); // this, ussdMessaging, data
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::NotifyNetworkRelease with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::NotifyNetworkRelease with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Terminate the dialogue
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMobileUssdMessaging::NotifyNetworkRelease
//-------------------------------------------------------------------------
TBuf8<1> badSizeDescriptor;
ussdMessaging.NotifyNetworkRelease(requestStatus, badSizeDescriptor);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
// again with the optional parameter
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
ussdMessaging.NotifyNetworkRelease(requestStatus, pckgSendV3, badSizeDescriptor);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3); // this, ussdMessaging, data
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
RBuf8 data;
CleanupClosePushL(data);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMobileUssdMessaging ussdMessaging1;
ret = ussdMessaging1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging1);
RMobileUssdMessaging ussdMessaging2;
ret = ussdMessaging2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging2);
//-------------------------------------------------------------------------
// The first client needs to send a message. This will cause a session to be opened
// which will be owned by the first client.
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockSendData2(name, attributes);
mockSendData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging1.SendMessage(requestStatus1, msgData, msgAttributes);
User::WaitForRequest(requestStatus1);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
//-------------------------------------------------------------------------
// parameters for first function
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV31;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV31(sendV31);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV31;
TUint8 opCode1 = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV31.iOpCode = opCode1;
completeSendV31.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData11(completeSendV31);
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMTRequest;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2(completeSendV31,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2.SerialiseL(data2);
//-------------------------------------------------------------------------
// parameters for second function
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV32;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV32(sendV32);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMobileUssdMessaging::NotifyNetworkRelease
//-------------------------------------------------------------------------
mockData11.SerialiseL(data2);
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNone, data2, 10);
ussdMessaging1.NotifyNetworkRelease(requestStatus1, pckgSendV31);
ussdMessaging2.NotifyNetworkRelease(requestStatus2, pckgSendV32);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(opCode1, sendV31.iOpCode);
ASSERT_EQUALS(0, sendV31.iAdditionalInfo.Compare(KAdditionalInfo1));
ASSERT_EQUALS(opCode1, sendV32.iOpCode);
ASSERT_EQUALS(0, sendV32.iAdditionalInfo.Compare(KAdditionalInfo1));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, data, this
// ussdMessaging1, ussdMessaging2, data2 (inv. order)
}
////
/**
@SYMTestCaseID BA-CTSY-USSDM-UNNR-0004b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::NotifyNetworkRelease
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestNotifyNetworkRelease0004bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
RBuf8 data;
CleanupClosePushL(data);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMobileUssdMessaging ussdMessaging1;
ret = ussdMessaging1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging1);
RMobileUssdMessaging ussdMessaging2;
ret = ussdMessaging2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging2);
//-------------------------------------------------------------------------
// The first client needs to send a message. This will cause a session to be opened
// which will be owned by the first client.
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockSendData2(name, attributes);
mockSendData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging1.SendMessage(requestStatus1, msgData, msgAttributes);
User::WaitForRequest(requestStatus1);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
//-------------------------------------------------------------------------
// parameters for first function
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV31;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV31(sendV31);
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV31;
TUint8 opCode1 = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV31.iOpCode = opCode1;
completeSendV31.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData11(completeSendV31);
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttrV1;
completeAttrV1.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType;
completeAttrV1.iFormat = RMobileUssdMessaging::EFormatPackedString;
completeAttrV1.iType = RMobileUssdMessaging::EUssdMTRequest;
TMockLtsyData2< RMobilePhone::TMobilePhoneSendSSRequestV3,
RMobileUssdMessaging::TMobileUssdAttributesV1 >
mockData2(completeSendV31,completeAttrV1);
RBuf8 data2;
CleanupClosePushL(data2);
mockData2.SerialiseL(data2);
//-------------------------------------------------------------------------
// parameters for second function
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV32;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV32(sendV32);
//-------------------------------------------------------------------------
// Test B: Test multiple clients requesting RMobileUssdMessaging::NotifyNetworkRelease
// with optional second parameter
//-------------------------------------------------------------------------
ussdMessaging1.Close();
ret = ussdMessaging1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging2.Close();
ret = ussdMessaging2.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV1;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV1(attrV1);
RMobileUssdMessaging::TMobileUssdAttributesV1 attrV12;
RMobileUssdMessaging::TMobileUssdAttributesV1Pckg pckgAttrV12(attrV12);
iMockLTSY.CompleteL(EMobileUssdMessagingNotifyNetworkRelease, KErrNone, data2, 5);
ussdMessaging1.NotifyNetworkRelease(requestStatus1, pckgSendV31, pckgAttrV1);
ussdMessaging2.NotifyNetworkRelease(requestStatus2, pckgSendV32, pckgAttrV12);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(opCode1, sendV31.iOpCode);
ASSERT_EQUALS(0, sendV31.iAdditionalInfo.Compare(KAdditionalInfo1));
ASSERT_EQUALS(opCode1, sendV32.iOpCode);
ASSERT_EQUALS(0, sendV32.iAdditionalInfo.Compare(KAdditionalInfo1));
ASSERT_EQUALS(completeAttrV1.iFlags ,attrV1.iFlags);
ASSERT_EQUALS(completeAttrV1.iFormat ,attrV1.iFormat);
ASSERT_EQUALS(completeAttrV1.iType ,attrV1.iType);
ASSERT_EQUALS(completeAttrV1.iFlags ,attrV12.iFlags);
ASSERT_EQUALS(completeAttrV1.iFormat ,attrV12.iFormat);
ASSERT_EQUALS(completeAttrV1.iType ,attrV12.iType);
CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, data, this
// ussdMessaging1, ussdMessaging2, data2 (inv. order)
}
////
/**
@SYMTestCaseID BA-CTSY-USSDM-USMNFC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessageNoFdnCheck
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessageNoFdnCheck
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageNoFdnCheck0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
mockData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessageNoFdnCheck, data, KErrNotSupported);
ussdMessaging.SendMessageNoFdnCheck(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessageNoFdnCheck, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessageNoFdnCheck, KErrGeneral);
ussdMessaging.SendMessageNoFdnCheck(requestStatus, msgData, msgAttributes);
//Wrong IPC is passed to ResetTsyReqHandle() EMultimodeUssdSendMessage
//instead of EMultimodeUssdSendMessageNoFdnCheck by call of
//CMmUssdTsy::CompleteSendMessageNoFdnCheck(). This reduces to panic
//with EEtelFaultNotRecognisedTsyHandle.
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::SendMessageNoFdnCheck when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessageNoFdnCheck, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessageNoFdnCheck, KErrNone);
ussdMessaging.SendMessageNoFdnCheck(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMobileUssdMessaging::SendMessageNoFdnCheck
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessageNoFdnCheck, KErrNone);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, ussdMessaging, this
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMNFC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::SendMessageNoFdnCheck
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileUssdMessaging::SendMessageNoFdnCheck
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageNoFdnCheck0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus mockLtsyStatus;
TRequestStatus requestStatus;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
//-------------------------------------------------------------------------
// Test cancelling of RMobileUssdMessaging::SendMessageNoFdnCheck
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
mockData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessageNoFdnCheck, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessageNoFdnCheck, KErrNone, 10);
ussdMessaging.SendMessageNoFdnCheck(requestStatus, msgData, msgAttributes);
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingSendMessageNoFdnCheck);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
CleanupStack::PopAndDestroy(3); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMNFC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessageNoFdnCheck with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessageNoFdnCheck with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageNoFdnCheck0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// function parameter
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMobileUssdMessaging::SendMessage
//-------------------------------------------------------------------------
TBuf8<1> badSizeDescriptor;
ussdMessaging.SendMessageNoFdnCheck(requestStatus, msgData, badSizeDescriptor);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMNFC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::SendMessageNoFdnCheck
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::SendMessageNoFdnCheck
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageNoFdnCheck0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMobileUssdMessaging ussdMessaging1;
ret = ussdMessaging1.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging1);
RMobileUssdMessaging ussdMessaging2;
ret = ussdMessaging2.Open(phone2);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// parameters for first function
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes1;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes1(attributes1);
attributes1.iFlags = flags;
attributes1.iFormat = format;
attributes1.iType = type;
attributes1.iDcs = dcs;
TName name1 = _L("Name1");
TPckg<TName> msgData1(name1);
//-------------------------------------------------------------------------
// parameters for second function
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes2;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes2(attributes2);
flags = 10;
format = RMobileUssdMessaging::EFormatPackedString;
type = RMobileUssdMessaging::EUssdMOAcknowledgement;
dcs = 20;
attributes2.iFlags = flags;
attributes2.iFormat = format;
attributes2.iType = type;
attributes2.iDcs = dcs;
TName name2 = _L("Name2");
TPckg<TName> msgData2(name2);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name1, attributes1);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMobileUssdMessaging::SendMessageNoFdnCheck
//-------------------------------------------------------------------------
mockData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessageNoFdnCheck, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessageNoFdnCheck, KErrNone, 10);
ussdMessaging1.SendMessageNoFdnCheck(requestStatus1, msgData1, msgAttributes1);
ussdMessaging2.SendMessageNoFdnCheck(requestStatus2, msgData2, msgAttributes2);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
CleanupStack::PopAndDestroy(6, this); // phone2, telServer2, data, this,
// ussdMessaging1, ussdMessaging2
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMNFC-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessageNoFdnCheck with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::SendMessageNoFdnCheck and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageNoFdnCheck0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMobileUssdMessaging::SendMessageNoFdnCheck
//-------------------------------------------------------------------------
mockData2.SerialiseL(data);
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessageNoFdnCheck, data);
ussdMessaging.SendMessageNoFdnCheck(requestStatus, msgData, msgAttributes);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UGC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::GetCaps
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::GetCaps
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestGetCaps0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TUint32 format = RMobileUssdMessaging::KCapsPackedString;
TUint32 types = KUssdTypeCaps;
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMobileUssdMessaging::GetCaps when result is not cached.
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdCapsV1 capsV1;
TPckg<RMobileUssdMessaging::TMobileUssdCapsV1> pckg(capsV1);
ret = ussdMessaging.GetCaps(pckg);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_EQUALS(format, capsV1.iUssdFormat); // hard coded value
ASSERT_EQUALS(types , capsV1.iUssdTypes ); // hard coded value
CleanupStack::PopAndDestroy(2, this); // this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UGC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::GetCaps with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::GetCaps with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestGetCaps0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMobileUssdMessaging::GetCaps
//-------------------------------------------------------------------------
TBuf8<1> badSizeDescriptor;
ret = ussdMessaging.GetCaps(badSizeDescriptor);
ASSERT_EQUALS(KErrArgument, ret);
CleanupStack::PopAndDestroy(2, this); // this, ussdMessaging
}
TInt CCTsyUssdMessagingFU::CreateClients(RThread& aT1, RThread& aT2, TTestDataWithChunk& aC1, TTestDataWithChunk& aC2)
{
TInt KStackSize=0x8000;
TInt KHeapSize=0x8000;
TInt KMaxHeapSize=0x80000;
TInt ret = KErrNone;
ret = aT1.Create(_L("UssdClient1"), TestReceiveMessage,
KStackSize, KHeapSize, KMaxHeapSize, &aC1);
if (ret !=KErrNone)
{
return ret;
}
ret = aT2.Create(_L("UssdClient2"), TestReceiveMessage,
KStackSize, KHeapSize, KMaxHeapSize, &aC2);
return ret;
}
void CCTsyUssdMessagingFU::MultipleClientRequestsL(RThread& aT1, RThread& aT2)
{
RBuf8 data;
TRequestStatus reqStatus1;
TRequestStatus reqStatus2;
TBool req1Complete=EFalse;
TBool req2Complete=EFalse;
aT1.Logon(reqStatus1);
aT2.Logon(reqStatus2);
aT1.Resume();
aT2.Resume();
CompleteMockRequestL(data, EMobileUssdMessagingReceiveMessage, iMockLTSY);
while ( req1Complete==EFalse || req2Complete==EFalse )
{
User::WaitForAnyRequest();
if (reqStatus1 != KRequestPending && req1Complete==EFalse)
{
ASSERT_EQUALS(reqStatus1.Int(), KErrNone);
req1Complete=ETrue;
}
if (reqStatus2 != KRequestPending && req2Complete==EFalse)
{
ASSERT_EQUALS(reqStatus2.Int(), KErrNone);
req2Complete=ETrue;
}
} // while statement
data.Close();
}
//
TInt CCTsyUssdMessagingFU::TestReceiveMessage(TAny* aThreadData )
{
// Create a cleanup stack object
CTrapCleanup* cleanup=CTrapCleanup::New();
if (cleanup==NULL)
return KErrNoMemory;
RMockLtsy mockLtsy;
TInt err=mockLtsy.Connect();
// ASSERT_EQUALS(KErrNone, err);
RBuf8 data;
TTestUssdData* testData = static_cast<TTestUssdData*>(aThreadData);
RTelServer server;
RMobilePhone phone;
TInt ret = server.Connect();
if (ret != KErrNone)
{
server.Close();
return ret;
}
ret = phone.Open(server,KMmTsyPhoneName);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
TRequestStatus requestStatus;
RMobileUssdMessaging::TGsmUssdMessageData name;
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging ussdMessaging;
ret = ussdMessaging.Open(phone);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
TBool waiting = EFalse;
if (testData->iAfterTimePeriod > 0)
{
// Wait, mimic a bad client taking too long...
User::After(testData->iAfterTimePeriod * 100000);
}
if (testData->iAcceptDialogue)
{
// Client wants the dialogue
if (ussdMessaging.AcceptIncomingDialogue() != KErrTimedOut)
{
// This client should have the dialogue.
// To check, wait for next message (in the session/dialogue)
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
CompleteMockRequestL(data, EMobileUssdMessagingReceiveMessage, mockLtsy);
waiting = ETrue;
}
}
else
{
// Client not interested
ussdMessaging.RejectIncomingDialogue();
}
if (waiting)
{
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
}
User::After(2 * 1000000);
ussdMessaging.Close();
phone.Close();
server.Close();
data.Close();
delete cleanup;
return KErrNone;
}
void CCTsyUssdMessagingFU::CompleteMockRequestL(RBuf8& aData, TInt aMsgType, RMockLtsy& aMockLTSY)
{
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData(completeName, completeAttributes);
TRAPD(ret, mockData.SerialiseL(aData));
aMockLTSY.CompleteL(aMsgType, KErrNone, aData, 15);
}
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClientL(RArray<TUssdClientTestData> & aClientTestData, TBool aRandomLoopingTest)
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
//-------------------------------------------------------------------------
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
const TInt numClients = aClientTestData.Count();
RProcess* proc = new RProcess[numClients];
TRequestStatus* req = new TRequestStatus[numClients];
for (TInt i=0; i<numClients; ++i)
{
TInt err = proc[i].Create(aClientTestData[i].iExe, aClientTestData[i].iClientParams);
// If a client isn't created properly, we need to clean up previously created ones here
if (err != KErrNone)
{
for (TInt c=0; c<i-1; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
}
// Fail the test if any client has not been created properly
ASSERT_EQUALS(err, KErrNone);
}
// All processes created successfully, start their execution
for (TInt i = 0; i < numClients; i++)
{
proc[i].Logon(req[i]);
proc[i].Resume();
// Pause here so that clients register in the order specified (i.e. As ordered in the array)
// Resolves timing issues in WDP/SMP.
User::After(500000);
}
if (aRandomLoopingTest)
{
// Special case just for TestReceiveMessageWithTestClient0017L
for (TInt i=0; i<20; ++i)
{
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data, 1);
User::After(750000);
}
for (TInt i = 0; i < numClients; i++)
{
proc[i].Kill(KErrNone);
proc[i].Close();
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
// We have no idea what state the clients will be in so there is no point in
// checking. This test passes if we don't crash the ETel server!
return;
}
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data, 15);
User::WaitForAnyRequest();
// Wait for any clients given a timeout
User::After(5 * 1000000);
for (TInt i = 0; i < numClients; i++)
{
TRequestStatus status = req[i];
TExitType exit = proc[i].ExitType();
TInt reason = proc[i].ExitReason();
// Kill/Close the clients before doing assert
proc[i].Kill(KErrNone);
proc[i].Close();
const TBool checkRequestStatus = status.Int() == aClientTestData[i].iReqStatus;
const TBool checkExitType = exit == aClientTestData[i].iExitType;
TBool checkExitReason = ETrue;
if (aClientTestData[i].iExitType == EExitKill)
{
checkExitReason = reason == aClientTestData[i].iExitReason;
}
if (!checkRequestStatus || !checkExitType || !checkExitReason)
{
// Some useful output in case of a failed test
INFO_PRINTF2(_L("Client[%d] returned unexpected results:"),i);
if (!checkRequestStatus)
INFO_PRINTF3(_L(" [RequestStatus] Expected: %d , Actual: %d"),aClientTestData[i].iReqStatus,status.Int());
if (!checkExitType)
INFO_PRINTF3(_L(" [ExitType] Expected: %d , Actual: %d"),aClientTestData[i].iExitType,exit);
if (!checkExitReason)
INFO_PRINTF3(_L(" [ExitReason] Expected: %d , Actual: %d"),aClientTestData[i].iExitReason,reason);
for (TInt c=i+1; c<numClients; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
ASSERT_TRUE(checkRequestStatus);
ASSERT_TRUE(checkExitType);
ASSERT_TRUE(checkExitReason);
}
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority client accepts dialogue
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0001L()
{
RArray<TUssdClientTestData> data1;
data1.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone)); //Priority
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone));
TestReceiveMessageWithTestClientL(data1);
data1.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0006
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority client takes too long before accepting/rejecting dialogue. Next standard client to accept will get the dialogue
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0002L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A -T 2"), KErrTimedOut, EExitKill, KErrTimedOut)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone )); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone ));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0007
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority client rejects the dialogue. Next standard client to accept will get the dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0003L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R"), KErrNone, EExitKill, KErrNone)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0008
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority client rejects the dialogue. Standard client takes too long before accepting/rejecting the dialogue. Default client accepts the dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0004L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R"), KErrNone, EExitKill, KErrNone )); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone )); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 3"), KErrTimedOut, EExitKill, KErrTimedOut));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0009
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority client rejects the dialogue. Standard client rejects the dialogue. Default client accepts the dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0005L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R"), KErrNone, EExitKill, KErrNone)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R"), KErrNone, EExitKill, KErrNone));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0010
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority doesn't time out where others would.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0006L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A -T 0.2"), KErrNone, EExitKill, KErrNone)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0011
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority times out. Normal clients time out with same length priority won in previous test case. Default client accepts the dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0007L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A -T 0.5"), KErrTimedOut, EExitKill, KErrTimedOut)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0012
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority times out. Normal client with small timeout should get the dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0008L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A -T 0.5"), KErrTimedOut, EExitKill, KErrTimedOut)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.05"), KErrNone, EExitKill, KErrNone));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0013
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Priority and all normal clients reject or timeout the incoming dialogue. Default client accepts the dialogue.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0009L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -T 0.5"), KErrTimedOut, EExitKill, KErrTimedOut)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R"), KErrNone, EExitKill, KErrNone));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -T 0.2"), KErrNone, EExitKill, KErrNone)); //Rejecting the request after the session is over will lead to KErrNone
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R"), KErrNone, EExitKill, KErrNone));
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A -T 0.2"), KErrTimedOut, EExitKill, KErrTimedOut));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0014
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. No normal clients, only priority and default. Dialogue accepted by priority client.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0010L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A"), KErrNone, EExitKill, KErrNone)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-00015
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::ReceiveMessage with varying interest categories
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. No normal clients, only priority and default. Priority times out. Dialogue accepted by default client.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0011L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A -T 1.5"), KErrTimedOut, EExitKill, KErrTimedOut)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone)); //Default
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0015
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Testing multiple priority clients. The second Priority client should not be treated as such, should be added to the list of standard clients.
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Four clients: 2 priority, 1 default and 1 standard client. The first Priority client should be offered the dialogue, not the second.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0013L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A"), KErrNone, EExitKill, KErrNone)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Priority. Gets added to standard client list as already have a priority client
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0015
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Testing multiple default clients. The second default client should not be treated as such, should be added to the list of standard clients.
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::ReceiveMessage. Four clients: 1 priority, 2 default and 1 standard client. The second default client added should act like a standard client and be offered the dialogue before the first default client.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0014L()
{
RArray<TUssdClientTestData> data;
data.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R"), KErrNone, EExitKill, KErrNone)); //Priority
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone)); //Default
data.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone)); //Default. Gets added to standard client list as already have a default client
data.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KRequestPending, EExitPending, KErrNone));
TestReceiveMessageWithTestClientL(data);
data.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-URM-0020
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test ReceiveMessage with multiple clients.
@SYMTestPriority High
@SYMTestActions Two clients, both call ReceiveMessage. A message is received. First client offered message. Both clients call Close.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0016L()
{
RArray<TUssdClientTestData> data1;
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -A"), KErrNone, EExitKill, KErrNone));
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-R -RTimeout"), KRequestPending, EExitKill, KRequestPending));
TestReceiveMessageWithTestClientL(data1);
data1.Close();
}
/*
@SYMTestCaseID BA-CTSY-USSDM-URM-0021
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test ReceiveMessage with multiple clients.
@SYMTestPriority High
@SYMTestActions Two clients, both call ReceiveMessage. A message is received. First client offered message. Both clients call Close.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestReceiveMessageWithTestClient0017L()
{
RArray<TUssdClientTestData> data1;
data1.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"), _L("-Random"), KErrNone, EExitKill, KErrNone));
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-Random"), KErrNone, EExitKill, KErrNone));
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-Random"), KErrNone, EExitKill, KErrNone));
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"), _L("-Random"), KErrNone, EExitKill, KErrNone));
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-Random"), KErrNone, EExitKill, KErrNone));
TestReceiveMessageWithTestClientL(data1, ETrue);
data1.Close();
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UARM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test calling accept and reject before a session has been created
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::AcceptIncomingDialogue and RMobileUssdMessaging::RejectIncomingDialogue
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestAcceptRejectMisuse0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TInt status = ussdMessaging.AcceptIncomingDialogue();
ASSERT_EQUALS(KErrNotReady , status);
status = ussdMessaging.RejectIncomingDialogue();
ASSERT_EQUALS(KErrNotReady , status);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-UARM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test calling accept and reject after a session has ended
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::AcceptIncomingDialogue and RMobileUssdMessaging::RejectIncomingDialogue
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestAcceptRejectMisuse0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
//-------------------------------------------------------------------------
// Setup: This block is taken from TestReceiveMessage0001L. All we want to
// do is to initiate a dialogue and then end it. Once the dialogue has ended
// then we can call Accept and Reject.
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ret = requestStatus.Int();
ASSERT_EQUALS(KErrNone, ret);
ussdMessaging.AcceptIncomingDialogue();
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// Release the dialogue
//-------------------------------------------------------------------------
RMobilePhone::TMobilePhoneSendSSRequestV3 sendV3;
TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3> pckgSendV3(sendV3);
iMockLTSY.ExpectL(EMobileUssdMessagingSendRelease);
ussdMessaging.SendRelease(requestStatus, pckgSendV3);
RMobilePhone::TMobilePhoneSendSSRequestV3 completeSendV3;
TUint8 opCode = 100;
_LIT(KAdditionalInfo1, "additionalInfo1");
completeSendV3.iOpCode = opCode;
completeSendV3.iAdditionalInfo = KAdditionalInfo1;
TMockLtsyData1< RMobilePhone::TMobilePhoneSendSSRequestV3 > mockData1(completeSendV3);
mockData1.SerialiseL(data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendRelease, KErrNone, data, 1);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST A: Call Accept and Reject once the dialogue is over.
//-------------------------------------------------------------------------
TInt status = ussdMessaging.AcceptIncomingDialogue();
ASSERT_EQUALS(KErrTimedOut, status);
status = ussdMessaging.RejectIncomingDialogue();
ASSERT_EQUALS(KErrNone, status);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-MIUM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc BA-CTSY-USSDM-MIUM-0001
@SYMTestPriority High
@SYMTestActions Client calls ReceiveMessage. First USSD message arrives and is offered to client.
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestMultipleIncomingUssdMessages0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging::TGsmUssdMessageData name;
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name1");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(completeName, completeAttributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST : Multiple incoming "network" USSD messages are received.
// This is handled without problem in Etel.
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// Second incoming USSD message
ussdMessaging.AcceptIncomingDialogue();
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data);
User::After(5 * 1000000);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this); // data, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMDH-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY client requests to RMobileUssdMessaging::SendMessage with default handler
@SYMTestPriority High
@SYMTestActions Invokes request to RMobileUssdMessaging::SendMessage with EMobileUssdMessagingSendMessage with DefaultHandler option
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageDefaultHandlerWithTestClient0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RArray<TUssdClientTestData> data1;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
RBuf8 data2;
CleanupClosePushL(data2);
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name2");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData3(completeName, completeAttributes);
mockData3.SerialiseL(data2);
//-------------------------------------------------------------------------
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -M"), KErrNone, EExitKill, KErrNone)); //Default
const TInt numClients = data1.Count();
RProcess* proc = new RProcess[numClients];
TRequestStatus* req = new TRequestStatus[numClients];
for (TInt i=0; i<numClients; ++i)
{
TInt err = proc[i].Create(data1[i].iExe, data1[i].iClientParams);
// If a client isn't created properly, we need to clean up previously created ones here
if (err != KErrNone)
{
for (TInt c=0; c<i-1; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
}
// Fail the test if any client has not been created properly
ASSERT_EQUALS(err, KErrNone);
}
// All processes created successfully, start their execution
for (TInt i = 0; i < numClients; i++)
{
proc[i].Logon(req[i]);
proc[i].Resume();
// Pause here so that clients register in the order specified (i.e. As ordered in the array)
// Resolves timing issues in WDP/SMP.
User::After(500000);
}
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//---------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data2, 15);
User::After(5 * 1000000);
for (TInt i = 0; i < numClients; i++)
{
TRequestStatus status = req[i];
TExitType exit = proc[i].ExitType();
TInt reason = proc[i].ExitReason();
// Kill/Close the clients before doing assert
proc[i].Kill(KErrNone);
proc[i].Close();
const TBool checkRequestStatus = status.Int() == data1[i].iReqStatus;
const TBool checkExitType = exit == data1[i].iExitType;
TBool checkExitReason = ETrue;
if (data1[i].iExitType == EExitKill)
{
checkExitReason = reason == data1[i].iExitReason;
}
if (!checkRequestStatus || !checkExitType || !checkExitReason)
{
// Some useful output in case of a failed test
INFO_PRINTF2(_L("Client[%d] returned unexpected results:"),i);
if (!checkRequestStatus)
INFO_PRINTF3(_L(" [RequestStatus] Expected: %d , Actual: %d"),data1[i].iReqStatus,status.Int());
if (!checkExitType)
INFO_PRINTF3(_L(" [ExitType] Expected: %d , Actual: %d"),data1[i].iExitType,exit);
if (!checkExitReason)
INFO_PRINTF3(_L(" [ExitReason] Expected: %d , Actual: %d"),data1[i].iExitReason,reason);
for (TInt c=i+1; c<numClients; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
ASSERT_TRUE(checkRequestStatus);
ASSERT_TRUE(checkExitType);
ASSERT_TRUE(checkExitReason);
}
}
//---------------------------------------------------------------------------
data1.Close();
CleanupStack::PopAndDestroy(4, this); // data, data2, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMDH-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY client requests to RMobileUssdMessaging::SendMessage with two default clients
@SYMTestPriority High
@SYMTestActions Invokes request to RMobileUssdMessaging::SendMessage with EMobileUssdMessagingSendMessage with DefaultHandler option
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageDefaultHandlerWithTestClient0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RArray<TUssdClientTestData> data1;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
RBuf8 data2;
CleanupClosePushL(data2);
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name2");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData3(completeName, completeAttributes);
mockData3.SerialiseL(data2);
//-------------------------------------------------------------------------
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -M"), KErrNone, EExitKill, KErrNone)); //Default
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"),_L("-R -M"), KRequestPending, EExitPending, KErrNone)); //Second default client
const TInt numClients = data1.Count();
RProcess* proc = new RProcess[numClients];
TRequestStatus* req = new TRequestStatus[numClients];
for (TInt i=0; i<numClients; ++i)
{
TInt err = proc[i].Create(data1[i].iExe, data1[i].iClientParams);
// If a client isn't created properly, we need to clean up previously created ones here
if (err != KErrNone)
{
for (TInt c=0; c<i-1; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
}
// Fail the test if any client has not been created properly
ASSERT_EQUALS(err, KErrNone);
}
// All processes created successfully, start their execution
for (TInt i = 0; i < numClients; i++)
{
proc[i].Logon(req[i]);
proc[i].Resume();
// Pause here so that clients register in the order specified (i.e. As ordered in the array)
// Resolves timing issues in WDP/SMP.
User::After(500000);
}
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//---------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data2, 15);
User::After(5 * 1000000);
for (TInt i = 0; i < numClients; i++)
{
TRequestStatus status = req[i];
TExitType exit = proc[i].ExitType();
TInt reason = proc[i].ExitReason();
// Kill/Close the clients before doing assert
proc[i].Kill(KErrNone);
proc[i].Close();
const TBool checkRequestStatus = status.Int() == data1[i].iReqStatus;
const TBool checkExitType = exit == data1[i].iExitType;
TBool checkExitReason = ETrue;
if (data1[i].iExitType == EExitKill)
{
checkExitReason = reason == data1[i].iExitReason;
}
if (!checkRequestStatus || !checkExitType || !checkExitReason)
{
// Some useful output in case of a failed test
INFO_PRINTF2(_L("Client[%d] returned unexpected results:"),i);
if (!checkRequestStatus)
INFO_PRINTF3(_L(" [RequestStatus] Expected: %d , Actual: %d"),data1[i].iReqStatus,status.Int());
if (!checkExitType)
INFO_PRINTF3(_L(" [ExitType] Expected: %d , Actual: %d"),data1[i].iExitType,exit);
if (!checkExitReason)
INFO_PRINTF3(_L(" [ExitReason] Expected: %d , Actual: %d"),data1[i].iExitReason,reason);
for (TInt c=i+1; c<numClients; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
ASSERT_TRUE(checkRequestStatus);
ASSERT_TRUE(checkExitType);
ASSERT_TRUE(checkExitReason);
}
}
//---------------------------------------------------------------------------
data1.Close();
CleanupStack::PopAndDestroy(4, this); // data, data2, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMDH-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY client requests to RMobileUssdMessaging::SendMessage with default and priority clients
@SYMTestPriority High
@SYMTestActions Invokes request to RMobileUssdMessaging::SendMessage with EMobileUssdMessagingSendMessage with DefaultHandler option
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageDefaultHandlerWithTestClient0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RArray<TUssdClientTestData> data1;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
RBuf8 data2;
CleanupClosePushL(data2);
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name2");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData3(completeName, completeAttributes);
mockData3.SerialiseL(data2);
//-------------------------------------------------------------------------
data1.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -M"), KRequestPending, EExitPending, KErrNone)); //Priority
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -M"), KErrNone, EExitKill, KErrNone)); //Default
const TInt numClients = data1.Count();
RProcess* proc = new RProcess[numClients];
TRequestStatus* req = new TRequestStatus[numClients];
for (TInt i=0; i<numClients; ++i)
{
TInt err = proc[i].Create(data1[i].iExe, data1[i].iClientParams);
// If a client isn't created properly, we need to clean up previously created ones here
if (err != KErrNone)
{
for (TInt c=0; c<i-1; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
}
// Fail the test if any client has not been created properly
ASSERT_EQUALS(err, KErrNone);
}
// All processes created successfully, start their execution
for (TInt i = 0; i < numClients; i++)
{
proc[i].Logon(req[i]);
proc[i].Resume();
// Pause here so that clients register in the order specified (i.e. As ordered in the array)
// Resolves timing issues in WDP/SMP.
User::After(500000);
}
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//---------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data2, 15);
User::After(5 * 1000000);
for (TInt i = 0; i < numClients; i++)
{
TRequestStatus status = req[i];
TExitType exit = proc[i].ExitType();
TInt reason = proc[i].ExitReason();
// Kill/Close the clients before doing assert
proc[i].Kill(KErrNone);
proc[i].Close();
const TBool checkRequestStatus = status.Int() == data1[i].iReqStatus;
const TBool checkExitType = exit == data1[i].iExitType;
TBool checkExitReason = ETrue;
if (data1[i].iExitType == EExitKill)
{
checkExitReason = reason == data1[i].iExitReason;
}
if (!checkRequestStatus || !checkExitType || !checkExitReason)
{
// Some useful output in case of a failed test
INFO_PRINTF2(_L("Client[%d] returned unexpected results:"),i);
if (!checkRequestStatus)
INFO_PRINTF3(_L(" [RequestStatus] Expected: %d , Actual: %d"),data1[i].iReqStatus,status.Int());
if (!checkExitType)
INFO_PRINTF3(_L(" [ExitType] Expected: %d , Actual: %d"),data1[i].iExitType,exit);
if (!checkExitReason)
INFO_PRINTF3(_L(" [ExitReason] Expected: %d , Actual: %d"),data1[i].iExitReason,reason);
for (TInt c=i+1; c<numClients; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
ASSERT_TRUE(checkRequestStatus);
ASSERT_TRUE(checkExitType);
ASSERT_TRUE(checkExitReason);
}
}
//---------------------------------------------------------------------------
data1.Close();
CleanupStack::PopAndDestroy(4, this); // data, data2, this, ussdMessaging
}
/**
@SYMTestCaseID BA-CTSY-USSDM-USMDH-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY client requests to RMobileUssdMessaging::SendMessage with default, normal and priority clients
@SYMTestPriority High
@SYMTestActions Invokes request to RMobileUssdMessaging::SendMessage with EMobileUssdMessagingSendMessage with DefaultHandler option
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyUssdMessagingFU::TestSendMessageDefaultHandlerWithTestClient0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RArray<TUssdClientTestData> data1;
RMobileUssdMessaging ussdMessaging;
TInt ret = ussdMessaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(ussdMessaging);
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
//-------------------------------------------------------------------------
// function parameters
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
//-------------------------------------------------------------------------
TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData2(name, attributes);
mockData2.SerialiseL(data);
//-------------------------------------------------------------------------
RBuf8 data2;
CleanupClosePushL(data2);
//-------------------------------------------------------------------------
RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;
completeAttributes.iFlags = flags;
completeAttributes.iFormat = format;
completeAttributes.iType = type;
completeAttributes.iDcs = dcs;
TBuf8<KMaxName> completeName = _L8("Name2");
TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1>
mockData3(completeName, completeAttributes);
mockData3.SerialiseL(data2);
//-------------------------------------------------------------------------
data1.Append(TUssdClientTestData(_L("ussdtestclient_priority.exe"),_L("-R -M"), KRequestPending, EExitPending, KErrNone)); //Priority
data1.Append(TUssdClientTestData(_L("ussdtestclient_normal.exe"),_L("-R -M"), KRequestPending, EExitPending, KErrNone)); //Normal
data1.Append(TUssdClientTestData(_L("ussdtestclient_default.exe"), _L("-R -M"), KErrNone, EExitKill, KErrNone)); //Default
const TInt numClients = data1.Count();
RProcess* proc = new RProcess[numClients];
TRequestStatus* req = new TRequestStatus[numClients];
for (TInt i=0; i<numClients; ++i)
{
TInt err = proc[i].Create(data1[i].iExe, data1[i].iClientParams);
// If a client isn't created properly, we need to clean up previously created ones here
if (err != KErrNone)
{
for (TInt c=0; c<i-1; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
}
// Fail the test if any client has not been created properly
ASSERT_EQUALS(err, KErrNone);
}
// All processes created successfully, start their execution
for (TInt i = 0; i < numClients; i++)
{
proc[i].Logon(req[i]);
proc[i].Resume();
// Pause here so that clients register in the order specified (i.e. As ordered in the array)
// Resolves timing issues in WDP/SMP.
User::After(500000);
}
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);
iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes, RMobileUssdMessaging::ETransferToDefaultHandler);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//---------------------------------------------------------------------------
iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data2, 15);
User::After(5 * 1000000);
for (TInt i = 0; i < numClients; i++)
{
TRequestStatus status = req[i];
TExitType exit = proc[i].ExitType();
TInt reason = proc[i].ExitReason();
// Kill/Close the clients before doing assert
proc[i].Kill(KErrNone);
proc[i].Close();
const TBool checkRequestStatus = status.Int() == data1[i].iReqStatus;
const TBool checkExitType = exit == data1[i].iExitType;
TBool checkExitReason = ETrue;
if (data1[i].iExitType == EExitKill)
{
checkExitReason = reason == data1[i].iExitReason;
}
if (!checkRequestStatus || !checkExitType || !checkExitReason)
{
// Some useful output in case of a failed test
INFO_PRINTF2(_L("Client[%d] returned unexpected results:"),i);
if (!checkRequestStatus)
INFO_PRINTF3(_L(" [RequestStatus] Expected: %d , Actual: %d"),data1[i].iReqStatus,status.Int());
if (!checkExitType)
INFO_PRINTF3(_L(" [ExitType] Expected: %d , Actual: %d"),data1[i].iExitType,exit);
if (!checkExitReason)
INFO_PRINTF3(_L(" [ExitReason] Expected: %d , Actual: %d"),data1[i].iExitReason,reason);
for (TInt c=i+1; c<numClients; ++c)
{
proc[c].Kill(KErrNone);
proc[c].Close();
}
ASSERT_TRUE(checkRequestStatus);
ASSERT_TRUE(checkExitType);
ASSERT_TRUE(checkExitReason);
}
}
//---------------------------------------------------------------------------
data1.Close();
CleanupStack::PopAndDestroy(4, this); // data, data2, this, ussdMessaging
}