// Copyright (c) 2000-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:

// Contains tests for RMobileSmsMessaging API

// 

//

#include <e32test.h>

#include "TE_EtelMMTestStepBase.h"

#include "TE_mmsms.h"

#include "testdef.h"

CTestSmsMessaging::CTestSmsMessaging()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("TestSmsMessaging"));

	}

enum TVerdict CTestSmsMessaging::doTestStepL()

//

// Test SMS Messaging Functions

//

    {

	iTestCount=1;

	INFO_PRINTF1(_L(""));

	INFO_PRINTF1(_L("Test Mobile SMS Messaging Functionality"));

//	LOGTEXT(_L8("Test Mobile SMS Messaging Functionality"));

	RMobilePhone mmPhone;

	TInt ret=mmPhone.Open(iTelServer,DMMTSY_PHONE_NAME);

	TEST(ret==KErrNone);

	RMobileSmsMessaging smsMessaging;

	ret=smsMessaging.Open(mmPhone);

    TEST(ret==KErrNone);

	TRequestStatus reqStatus;

	// Get SMS messaging caps

	RMobileSmsMessaging::TMobileSmsCapsV1 smsCaps;

	RMobileSmsMessaging::TMobileSmsCapsV1Pckg smsCapsPckg(smsCaps);

	TEST(smsMessaging.GetCaps(smsCapsPckg)==KErrNone);

	TEST(smsCaps.iSmsMode==DMMTSY_SMS_MESSAGING_MODE_CAPS);

	TEST(smsCaps.iSmsControl==DMMTSY_SMS_MESSAGING_CONTROL_CAPS);

	INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::GetCaps (sync) passed"), iTestCount++);

//	test.Next(_L("OK: RMobileSmsMessaging's Get SMS caps"));

	// Receive Mode

	RMobileSmsMessaging::TMobileSmsReceiveMode receiveMode;

	TEST(smsMessaging.GetReceiveMode(receiveMode)==KErrNone);

	TEST(receiveMode==DMMTSY_SMS_MESSAGING_RECEIVE_MODE1);

	INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::GetReceiveMode (sync) passed"), iTestCount++);

	smsMessaging.SetReceiveMode(reqStatus, receiveMode);	

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	smsMessaging.SetReceiveMode(reqStatus, receiveMode);	

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingSetReceiveMode);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SetReceiveMode (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SetReceiveMode (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	smsMessaging.NotifyReceiveModeChange(reqStatus, receiveMode);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	TEST(receiveMode==DMMTSY_SMS_MESSAGING_RECEIVE_MODE2);

	smsMessaging.NotifyReceiveModeChange(reqStatus, receiveMode);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingNotifyReceiveModeChange);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NotifyReceiveModeChange (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		{

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NotifyReceiveModeChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

//	test.Next(_L("OK: RMobileSmsMessaging's SMS Receive Mode"));

	// Receive Incoming Message

	RMobileSmsMessaging::TMobileSmsGsmTpdu gsmMsg;

	RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 recAtt;

	RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg recAttPckg(recAtt);

	smsMessaging.ReceiveMessage(reqStatus, gsmMsg, recAttPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	ValidateReceivedSmsMessage(gsmMsg, recAtt);

	smsMessaging.ReceiveMessage(reqStatus, gsmMsg, recAttPckg);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingReceiveMessage);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::ReceiveMessage (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		{

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::ReceiveMessage (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

//	test.Next(_L("OK: RMobileSmsMessaging's Receive Message"));

	// AckSmsStored - test no PDU supplied first

	TPtrC8 emptyPdu(NULL,0);

	smsMessaging.AckSmsStored(reqStatus, emptyPdu, DMMTSY_SMS_MESSAGE_FULL);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// AckSmsStored - test PDU supplied second

	TPtrC8 pdu(DMMTSY_SMS_MESSAGE_PDU1);

	smsMessaging.AckSmsStored(reqStatus, pdu, DMMTSY_SMS_MESSAGE_FULL);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// asynchronous & cancel

	smsMessaging.AckSmsStored(reqStatus, pdu, DMMTSY_SMS_MESSAGE_FULL);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingAckSmsStored);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::AckSmsStored (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::AckSmsStored (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Test NackSmsStored

	// asynchronous

	smsMessaging.NackSmsStored(reqStatus, pdu, DMMTSY_SMS_MESSAGE_NACK_CAUSE);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// asynchronous & cancel

	smsMessaging.NackSmsStored(reqStatus, pdu, DMMTSY_SMS_MESSAGE_NACK_CAUSE);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingNackSmsStored);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NackSmsStored (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NackSmsStored (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Test Resume Sms Reception

	smsMessaging.ResumeSmsReception(reqStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int() == KErrNone);

	smsMessaging.ResumeSmsReception(reqStatus);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingResumeSmsReception);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::ResumeSmsReception (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::ResumeSmsReception (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Test Get/Set SMS Bearer

	RMobileSmsMessaging::TMobileSmsBearer bearer;

	TEST(smsMessaging.GetMoSmsBearer(bearer)==KErrNone);

	TEST(bearer==DMMTSY_SMS_MESSAGING_BEARER1);

	INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::GetMoSmsBearer (sync) passed"), iTestCount++);

	smsMessaging.SetMoSmsBearer(reqStatus, bearer);	

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	smsMessaging.SetMoSmsBearer(reqStatus, bearer);	

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingSetMoSmsBearer);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SetMoSmsBearer (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SetMoSmsBearer (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	smsMessaging.NotifyMoSmsBearerChange(reqStatus, bearer);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	TEST(bearer==DMMTSY_SMS_MESSAGING_BEARER2);

	smsMessaging.NotifyMoSmsBearerChange(reqStatus, bearer);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingNotifyMoSmsBearerChange);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NotifyMoSmsBearerChange (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		{

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NotifyMoSmsBearerChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

//	test.Next(_L("OK: RMobileSmsMessaging's Get/Set SMS Bearer"));

	// Test SendMessage

	// asynchronous

	RMobileSmsMessaging::TMobileSmsSendAttributesV1 atts;

	RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg attsPckg(atts);

	atts.iFlags = DMMTSY_SMS_MESSAGE_FLAGS2;

	atts.iDataFormat = DMMTSY_SMS_MESSAGE_FORMAT1;

	atts.iDestination.iTelNumber=DMMTSY_PHONE_TEL_NUMBER;

	atts.iMore = DMMTSY_SMS_MESSAGE_MORE;

	TBuf8<32> pduBuf(DMMTSY_SMS_MESSAGE_PDU1);

	smsMessaging.SendMessage(reqStatus, pduBuf, attsPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	TEST(atts.iMsgRef==DMMTSY_SMS_MESSAGE_MSGREF);

	TEST(atts.iSubmitReport==DMMTSY_SMS_MESSAGE_PDU2);

	// asynchronous & cancel

	smsMessaging.SendMessage(reqStatus, pduBuf, attsPckg);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingSendMessage);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SendMessage (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		{

		TEST(atts.iMsgRef==DMMTSY_SMS_MESSAGE_MSGREF);

		TEST(atts.iSubmitReport==DMMTSY_SMS_MESSAGE_PDU2);

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SendMessage (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

	// Test SendMessage - CDMA

	// asynchronous

	RMobileSmsMessaging::TMobileSmsCdmaSendAttributesV4 attsV4;

	RMobileSmsMessaging::TMobileSmsCdmaSendAttributesV4Pckg attsV4Pckg(attsV4);

	attsV4.iFlags = DMMTSY_SMS_MESSAGE_CDMA_FLAGS;

	attsV4.iDataFormat = DMMTSY_SMS_MESSAGE_CDMA_FORMAT;

	attsV4.iCdmaTeleservice = DMMTSY_SMS_MESSAGE_CDMA_TELESERVICE;

	attsV4.iCdmaServiceCategory = DMMTSY_SMS_MESSAGE_CDMA_SERVICE_CATEGORY;

	attsV4.iMore = DMMTSY_SMS_MESSAGE_MORE;

	attsV4.iDestination.iTypeOfNumber = DMMTSY_SMS_MESSAGE_TON;

	attsV4.iDestination.iNumberPlan = DMMTSY_SMS_MESSAGE_NP;

	attsV4.iDestination.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

	attsV4.iAddressAuthentication = DMMTSY_SMS_MESSAGE_ADDRESS_AUTHENTICATION;

	smsMessaging.SendMessage(reqStatus, pduBuf, attsV4Pckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int() == KErrNone);

	TEST(attsV4.iMsgRef == DMMTSY_SMS_MESSAGE_MSGREF);

	TEST(attsV4.iTLAck == DMMTSY_SMS_MESSAGE_TLACK);

//	test.Next(_L("OK: RMobileSmsMessaging's Send Message"));

	// Test SendMessageNoFdnCheck

	// asynchronous

	atts.iFlags = DMMTSY_SMS_MESSAGE_FLAGS2;

	atts.iDataFormat = DMMTSY_SMS_MESSAGE_FORMAT1;

	atts.iDestination.iTelNumber=DMMTSY_PHONE_TEL_NUMBER;

	atts.iMore = DMMTSY_SMS_MESSAGE_MORE;

	smsMessaging.SendMessageNoFdnCheck(reqStatus, pduBuf, attsPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	TEST(atts.iMsgRef==DMMTSY_SMS_MESSAGE_MSGREF);

	TEST(atts.iSubmitReport==DMMTSY_SMS_MESSAGE_PDU2);

	// asynchronous & cancel

	smsMessaging.SendMessageNoFdnCheck(reqStatus, pduBuf, attsPckg);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingSendMessageNoFdnCheck);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SendMessageNoFdnCheck (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		{

		TEST(atts.iMsgRef==DMMTSY_SMS_MESSAGE_MSGREF);

		TEST(atts.iSubmitReport==DMMTSY_SMS_MESSAGE_PDU2);

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::SendMessageNoFdnCheck (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

//	test.Next(_L("OK: RMobileSmsMessaging's Send Message with No Fdn Check"));

	// Test Enumerate Message Stores

	TInt count=0;

	TEST(smsMessaging.EnumerateMessageStores(count)==KErrNone);

	TEST(count==DMMTSY_PHONE_MESSAGE_STORE_COUNT);

	INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::EnumerateMessageStores (sync) passed"), iTestCount++);

	// Get Message Store Info

	// asynchronous

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 asyncInfo;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg asyncInfoPckg(asyncInfo);

	smsMessaging.GetMessageStoreInfo(reqStatus, DMMTSY_SMS_STORE_INDEX1, asyncInfoPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	ValidateGetSmsMessageStoreInfo(asyncInfo);

	// asynchronous & cancel

	smsMessaging.GetMessageStoreInfo(reqStatus, DMMTSY_SMS_STORE_INDEX1, asyncInfoPckg);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingGetMessageStoreInfo);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::GetMessageStoreInfo (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		{

		ValidateGetSmsMessageStoreInfo(asyncInfo);

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::GetMessageStoreInfo (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

//	test.Next(_L("OK: RMobileSmsMessaging's Get Message Store Info"));

	//Test deletion of list object whilst async request in progress

 	CRetrieveMobilePhoneSmspList* retrieve=CRetrieveMobilePhoneSmspList::NewL(smsMessaging);

 	retrieve->Start(reqStatus);

 	delete retrieve;

 	retrieve = NULL;

 	User::WaitForRequest(reqStatus);

 	TEST(reqStatus == KErrCancel);

	// Get SMSP list using asynchronous AO version

	CTestGetSmspList* getSmspList=CTestGetSmspList::NewLC(smsMessaging, this);

    getSmspList->Start();

    CActiveScheduler::Start();

	// Lets ensure that the same ao can be used to retrieve more than one list.

	getSmspList->Start();

    CActiveScheduler::Start();

	// I only need to delete the retrieval object because the destructor

	// of this will also delete the list object.

    CleanupStack::PopAndDestroy();  // getSmspList

	// Now test the cancelling

	getSmspList=CTestGetSmspList::NewLC(smsMessaging, this);

    getSmspList->Start();

	CTestCanceller* cancelGetSmspList = getSmspList->RetrieveCancelPtr();

	cancelGetSmspList->Call();

    CActiveScheduler::Start();

	TBool cancelled = (getSmspList->iStatus == KErrCancel);

	// Finally, lets just ensure that the object can be resused even after it has been cancelled

	getSmspList->Start();

    CActiveScheduler::Start();

	if (cancelled)

		INFO_PRINTF2(_L("Test %d - Test CRetrieveMobilePhoneSmspList (async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - Test CRetrieveMobilePhoneSmspList (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

    CleanupStack::PopAndDestroy();  // getSmspList

//	test.Next(_L("OK: RMobileSmsMessaging's Read SMSP List"));

	// Storing a new version of the list

	RMobileSmsMessaging::TMobileSmspEntryV1 storeEntry;

	CMobilePhoneSmspList* smspList = CMobilePhoneSmspList::NewL();

	CleanupStack::PushL(smspList);

	InitSmspEntry(storeEntry);

	storeEntry.iIndex = DMMTSY_SMSP_STORE_INDEX1;

	smspList->AddEntryL(storeEntry);

	storeEntry.iIndex = DMMTSY_SMSP_STORE_INDEX2;

	smspList->AddEntryL(storeEntry);

	// asynchronous

	smsMessaging.StoreSmspListL(reqStatus, smspList);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// aynchronous & cancel

	smsMessaging.StoreSmspListL(reqStatus, smspList);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingStoreSmspList);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	cancelled = (reqStatus.Int()==KErrCancel);

	// Ensure that list can be stored after previous store attempt was cancelled.

	smsMessaging.StoreSmspListL(reqStatus, smspList);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	if (cancelled)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::StoreSmspListL (sync & async & cancel (Cancelled Request)) passed"), iTestCount++);

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::StoreSmspListL (sync & async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	CleanupStack::PopAndDestroy(); // smspList

//	test.Next(_L("OK: RMobileSmsMessaging's Store SMSP List"));

	// Test NotifySmspListChange

	smsMessaging.NotifySmspListChange(reqStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// asynchronous & cancel

	smsMessaging.NotifySmspListChange(reqStatus);

	smsMessaging.CancelAsyncRequest(EMobileSmsMessagingNotifySmspListChange);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NotifySmspListChange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

	else

		INFO_PRINTF2(_L("Test %d - RMobileSmsMessaging::NotifySmspListChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	smsMessaging.Close();

	mmPhone.Close();

	INFO_PRINTF1(_L(""));

	return TestStepResult();

	}

void CTestSmsMessaging::ValidateReceivedSmsMessage(RMobileSmsMessaging::TMobileSmsGsmTpdu& aMsg, RMobileSmsMessaging::TMobileSmsReceiveAttributesV1& aAtt)

	{

	TEST(aMsg==DMMTSY_SMS_MESSAGE_PDU1);

	TEST(aAtt.iFlags==DMMTSY_SMS_MESSAGE_FLAGS1);

	TEST(aAtt.iGsmServiceCentre.iTelNumber.Compare(DMMTSY_SMS_MESSAGE_SC1)==0);

	TEST(aAtt.iDataFormat==DMMTSY_SMS_MESSAGE_FORMAT1);

	TEST(aAtt.iOriginator.iTelNumber.Compare(DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER1)==0);

	TEST(aAtt.iStatus==DMMTSY_SMS_MESSAGE_STATUS1);

	TEST(aAtt.iStore.Compare(DMMTSY_MESSAGE_STORE_NAME)==0);

	TEST(aAtt.iStoreIndex==DMMTSY_SMS_STORE_INDEX1);

	}

void CTestSmsMessaging::ValidateGetSmsMessageStoreInfo(const RMobilePhoneStore::TMobilePhoneStoreInfoV1 &aSyncInfo)

	{

	TEST(aSyncInfo.iName.Compare(DMMTSY_MESSAGE_STORE_NAME)==0);

	TEST(aSyncInfo.iType==DMMTSY_MESSAGE_STORE_TYPE);

	TEST(aSyncInfo.iTotalEntries==DMMTSY_MESSAGE_STORE_TOTAL_ENTRIES);

	TEST(aSyncInfo.iUsedEntries==DMMTSY_MESSAGE_STORE_USED_ENTRIES);

	TEST(aSyncInfo.iCaps==DMMTSY_MESSAGE_STORE_CAPS);

	}

void CTestSmsMessaging::ValidateSmspEntry(const RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)

	{

	TEST(aEntry.iText.Compare(DMMTSY_SMSP_STORE_TEXT1)==0);

	TEST(aEntry.iValidParams==DMMTSY_SMSP_STORE_VALID_PARAMS1);

	TEST(aEntry.iDestination.iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER)==0);

	TEST(aEntry.iValidityPeriod==DMMTSY_SMSP_STORE_VALIDITY1);

	TEST(aEntry.iServiceCentre.iTelNumber.Compare(DMMTSY_SMSP_STORE_SCA)==0);

	TEST(aEntry.iProtocolId==DMMTSY_SMSP_STORE_PID1);

	TEST(aEntry.iDcs==DMMTSY_SMSP_STORE_DCS1);

	}

void CTestSmsMessaging::InitSmspEntry(RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)

	{

	aEntry.iText = DMMTSY_SMSP_STORE_TEXT1;

	aEntry.iValidParams = DMMTSY_SMSP_STORE_VALID_PARAMS1;

	aEntry.iDestination.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

	aEntry.iValidityPeriod = DMMTSY_SMSP_STORE_VALIDITY1;

	aEntry.iServiceCentre.iTelNumber = DMMTSY_SMSP_STORE_SCA;

	aEntry.iProtocolId = DMMTSY_SMSP_STORE_PID1;

	aEntry.iDcs = DMMTSY_SMSP_STORE_DCS1;

	}

/**************************************************************/

//

// Testing asynchronous retrieve of SMSP list

//

/**************************************************************/

CTestSmsMessaging::CTestGetSmspList* CTestSmsMessaging::CTestGetSmspList::NewLC(RMobileSmsMessaging& aMessaging, CTestSmsMessaging* aTestSmsMessaging)

	{

    CTestGetSmspList* r=new(ELeave) CTestGetSmspList(aMessaging, aTestSmsMessaging);

    CleanupStack::PushL(r);

    r->ConstructL();

    return r;

    }

CTestSmsMessaging::CTestGetSmspList::CTestGetSmspList(RMobileSmsMessaging& aMessaging, CTestSmsMessaging* aTestSmsMessaging)

    : CActive(EPriorityNormal), iMessaging(aMessaging), iTestSmsMessaging(aTestSmsMessaging)

    {}