--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgtest/testutils/sms/src/SmsTestUtils.cpp	Mon Jan 18 20:36:02 2010 +0200
@@ -0,0 +1,1323 @@
+// Copyright (c) 1999-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:
+//
+
+#include "smstestutils.h"
+#include <e32test.h>
+#include <f32fsys.h>
+#include <s32file.h>
+#include <e32uid.h>
+#include <txtrich.h>
+#include <txtfmlyr.h>
+#include <msvids.h>
+#include <msvuids.h>
+#include <e32std.h>
+#include <smuthdr.h>
+#include <msvsysagentaction.h>
+#include <smscmds.h>
+#include <smsclnt.h>
+#include <smutset.h>
+#include <msgtestscripts.h>
+#include <biouids.h>
+#include <msvschedulesettings.h>
+#include <commsdattypesv1_1.h>
+#include <commsdat.h>
+#include <etelmm.h>
+#include <logsmspdudata.h>
+
+using namespace CommsDat;
+
+#include "EmsMsgTestUtils.h"
+#include "emstestutils.h"
+#include <csmsaccount.h>
+#include <msvoffpeaktime.h>
+
+#include "CAsyncWaiter.h"
+
+#include <mmsvattachmentmanager.h>
+#include <cmsvattachment.h>
+
+#include <e32property.h>
+
+// Constants
+//
+const TInt KUidNetworkBarsCmtValue=0x100052DB;
+const TInt KUidCmtPowerValue=0x100052D9;
+
+/**
+	@enum	TSANetworkBarsCmt
+	Enum defining the system agent network commands
+	@since	6.1
+*/
+enum TSANetworkBarsCmt
+	{
+	ENBars_0,		//<
+	ENBars_1,		//<
+	ENBars_2,		//<
+	ENBars_3,		//<
+	ENBars_4,		//<
+	ECmtPowerOn,	//< Specifies that the power is on
+	ECmtPowerOff	//< Specifies that the power is off
+	};
+
+/**
+	@enum	TSACmtPower
+	Enum defining the system agent commands for power
+	@since	6.1
+*/
+enum TSACmtPower
+	{	
+	ECmtOn,		//< Specifies that the power is on
+	ECmtOff		//< Specifies that the power is off
+	};
+
+
+
+EXPORT_C CSmsTestUtils::~CSmsTestUtils()
+	{
+	Reset();
+	delete iServiceSettings;
+	delete iRichText;
+	delete iCharFormat;
+	delete iParaFormat;
+
+	iRTest.Printf(_L("Waiting 3 seconds for the msg server to close...\n"));
+	User::After(3000000);
+	}
+
+EXPORT_C void CSmsTestUtils::AddSystemAgentConditionsL()
+	{
+	CMsvSysAgentActions* actions = new (ELeave) CMsvSysAgentActions();
+	CleanupStack::PushL(actions);
+
+	CMsvScheduleSettings* schSettings = CMsvScheduleSettings::NewL();
+	CleanupStack::PushL(schSettings);
+
+	CMsvOffPeakTimes* offPeakTimes = new (ELeave) CMsvOffPeakTimes();
+	CleanupStack::PushL(offPeakTimes);
+
+	CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL();
+	CleanupStack::PushL(errorActions);
+
+	CSmsAccount* account = CSmsAccount::NewLC();
+	account->LoadSettingsL(*schSettings, *offPeakTimes, *errorActions, *actions);
+
+	actions->iDefault.iAction = ESendActionRetryImmediately;
+	actions->iDefault.iRetries = ESendRetriesFixed;
+	actions->iDefault.iRetrySpacing = ESendRetrySpacingStatic;
+	actions->iDefault.SetMaxRetries(1);
+
+	TMsvSysAgentConditionAction condAction;
+
+	condAction.iUseDefaultSysAgentAction = ETrue;
+
+	condAction.iCondition.iVariable = KMsvTestUidPhonePwr;
+	condAction.iCondition.iState = EMsvTestPhoneOn;
+	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;
+
+	actions->AppendL(condAction);
+
+	condAction.iCondition.iVariable = KMsvTestUidSIMStatus;
+	condAction.iCondition.iState = EMsvTestSimOk;
+	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;
+	
+	actions->AppendL(condAction);
+
+	condAction.iCondition.iVariable = KMsvTestUidNetworkStatus;
+	condAction.iCondition.iState = EMsvTestNetworkAvailable;
+	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;
+	
+	actions->AppendL(condAction);
+
+//	TMsvSendErrorAction action;
+//	TBool condMet = actions->ConditionsMetL(action);
+
+	account->SaveSettingsL(*schSettings, *offPeakTimes, *errorActions, *actions);
+	CleanupStack::PopAndDestroy(4, account);    	
+	}
+
+/**
+	@fn				NotifySaPhoneOnL()
+	Intended Usage	:	To notify the system agent that the phone is on.
+	@since			6.1
+	@pre 			None
+	@post			System agent has been notified.
+ */
+EXPORT_C void CSmsTestUtils::NotifySaPhoneOnL()
+	{
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOn));
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidCmtPowerValue, ECmtOn));
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidNetworkBarsCmtValue, ECmtPowerOn));
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, 0x100052E7, 8));
+	}
+
+/**
+	@fn				NotifySaPhoneOffL()
+	Intended Usage	:	To notify the system agent that the phone is off.
+	@since			6.2
+	@pre 			None
+	@post			System agent has been notified.
+ */
+EXPORT_C void CSmsTestUtils::NotifySaPhoneOffL()
+	{
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOff));
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidCmtPowerValue, ECmtOff));
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidNetworkBarsCmtValue, ECmtPowerOff));
+	User::LeaveIfError(RProperty::Set(KUidSystemCategory, 0x100052E7, 8));
+	}
+
+EXPORT_C void CSmsTestUtils::WaitForInitializeL()
+/**
+	Initialize the phone for the tsy. This will prevent message sends from completing with KErrNotReady
+*/
+	{
+
+	TName tsy;
+	
+	CMDBSession* dbSession = CMDBSession::NewL(CMDBSession::LatestVersion());
+	CleanupStack::PushL(dbSession);
+	
+	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);
+	TRAPD(err, globalSettingsRecord.LoadL(*dbSession));
+	if(err != KErrNone)
+		{
+		User::Leave(KErrNotFound);				
+		}
+		
+	CCDModemBearerRecord *modemRecord = static_cast<CCDModemBearerRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));		
+	CleanupStack::PushL(modemRecord);	
+	modemRecord->SetRecordId(((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iModemForPhoneServicesAndSMS); 
+	modemRecord->LoadL(*dbSession);
+	tsy = modemRecord->iTsyName;	
+	CleanupStack::PopAndDestroy(2); //dbSession, modemRecord
+
+	RTelServer server;
+	User::LeaveIfError(server.Connect());
+	CleanupClosePushL(server);
+	User::LeaveIfError(server.LoadPhoneModule(tsy));
+
+	// Find the phone corresponding to this TSY and open a number of handles on it
+	TInt numPhones;
+	User::LeaveIfError(server.EnumeratePhones(numPhones));
+	RPhone phone;
+
+	while (numPhones--)
+		{
+		TName phoneTsy;
+		User::LeaveIfError(server.GetTsyName(numPhones,phoneTsy));
+		if (phoneTsy.CompareF(tsy)==KErrNone)
+			{
+			RTelServer::TPhoneInfo info;
+			User::LeaveIfError(server.GetPhoneInfo(numPhones,info));
+			User::LeaveIfError(phone.Open(server,info.iName));
+			CleanupClosePushL(phone);
+			const TInt err = phone.Initialise();
+			User::LeaveIfError(err);
+			CleanupStack::PopAndDestroy(&phone);
+			break;
+			}
+		}
+
+	CleanupStack::PopAndDestroy(&server);
+	}
+
+EXPORT_C CSmsTestUtils* CSmsTestUtils::NewL(RTest& aRTest, TUint aCreationFlags)
+	{
+	CSmsTestUtils* self = NewLC(aRTest, aCreationFlags);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CSmsTestUtils* CSmsTestUtils::NewLC(RTest& aRTest, TUint aCreationFlags)
+	{
+	CSmsTestUtils* self = new(ELeave) CSmsTestUtils(aRTest);
+	CleanupStack::PushL(self);
+	self->ConstructL(aCreationFlags);
+	return self;
+	}
+
+void CSmsTestUtils::Reset()
+	{
+	if (iSmsClientMtm)
+		{
+		delete iSmsClientMtm;
+		iSmsClientMtm=NULL;
+//		iMsvEntry=NULL;
+		}
+
+	CMsvTestUtils::Reset();
+	}
+
+//
+// Register a Sms Mtm server DLL
+//
+EXPORT_C void CSmsTestUtils::CreateSmsServerMtmRegL()
+	{
+	CreateServerMtmRegL(KUidMsgTypeSMS, _L("SMS"), KSmsServerMtmFileName(), KSmsClientMtmFileName(), TMsvTestDllInfo(KSmsUiMtmFileFileName,2), TMsvTestDllInfo(KSmsUiMtmFileFileName,1), KUidMsgTypeSMS, KSmsDataComponentFileName);
+	}
+
+EXPORT_C TMsvId CSmsTestUtils::CreateSmsServiceL()
+	{
+	// create service in root
+	TInt err = KErrNone;
+	iSmsServiceId = 0;
+	TRAP(err, ServiceIdL(KUidMsgTypeSMS, iSmsServiceId));
+
+	if (err)
+		{
+		if (!iServiceSettings)
+			{
+			iServiceSettings = CSmsSettings::NewL();
+			}
+	
+		CSmsAccount* account = CSmsAccount::NewLC();
+		account->InitialiseDefaultSettingsL(*iServiceSettings);
+		ServiceIdL(KUidMsgTypeSMS, iSmsServiceId);
+			
+		iServiceSettings->SetValidityPeriod(ESmsVPWeek);	// week
+		iServiceSettings->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger); //relative
+		iServiceSettings->AddServiceCenterL(_L("Vodafone"), _L("+4477850016005"));
+		iServiceSettings->AddServiceCenterL(_L("Sonera"), _L("+358405202000"));
+		iServiceSettings->SetDefaultServiceCenter(1);
+		iServiceSettings->SetReplyQuoted(EFalse);
+		iServiceSettings->SetRejectDuplicate(ETrue);
+		iServiceSettings->SetDelivery(ESmsDeliveryImmediately);
+		iServiceSettings->SetDeliveryReport(ETrue);
+		iServiceSettings->SetReplyPath(EFalse);
+		iServiceSettings->SetMessageConversion(ESmsConvPIDNone);
+		iServiceSettings->SetCanConcatenate(ETrue);
+
+		account->SaveSettingsL(*iServiceSettings);
+		
+		CMsvScheduleSettings* schSettings = CMsvScheduleSettings::NewL();
+		CleanupStack::PushL(schSettings);
+
+		CMsvOffPeakTimes* offPeakTimes = new (ELeave) CMsvOffPeakTimes();
+		CleanupStack::PushL(offPeakTimes);
+
+		CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL();
+		CleanupStack::PushL(errorActions);
+
+		CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions();
+		CleanupStack::PushL(sysAgentActions);
+		
+		account->LoadSettingsL(*schSettings, *offPeakTimes, *errorActions, *sysAgentActions);
+
+		schSettings->SetLongInterval(30);
+		schSettings->SetShortInterval(10);
+
+		account->SaveSettingsL(*schSettings, *offPeakTimes, *errorActions, *sysAgentActions);
+
+		CleanupStack::PopAndDestroy(5, account);    	
+		}
+	else
+		{
+		User::Leave(KErrAlreadyExists);
+		}
+
+	return iSmsServiceId;
+	}
+
+
+EXPORT_C void CSmsTestUtils::InstallSmsMtmGroupL()
+	{
+	InstallMtmGroupL(KSmsDataComponentFileName);
+	}
+
+EXPORT_C void CSmsTestUtils::InstantiateSmsClientMtmL()
+	{
+	__ASSERT_ALWAYS(iSmsServiceId, Panic(KSmsTestUtilsPanicSmsServiceIdNotSet));
+	delete iSmsClientMtm;
+	iSmsClientMtm = NULL;
+	iSmsClientMtm = (CSmsClientMtm*) InstantiateClientMtmL(KUidMsgTypeSMS, iSmsServiceId);
+	}
+
+EXPORT_C CSmsTestUtils::CSmsTestUtils(RTest& aRTest)
+: CMsvTestUtils(aRTest), iSmsServiceId(KMsvNullIndexEntryId), iSmokeTest(EFalse)
+	{
+	}
+
+EXPORT_C void CSmsTestUtils::ConstructL(TUint aFlags)
+	{
+	CMsvTestUtils::ConstructL(aFlags);
+
+
+	iParaFormat = CParaFormatLayer::NewL();
+	iCharFormat = CCharFormatLayer::NewL();
+	iRichText = CRichText::NewL(iParaFormat, iCharFormat);
+	}
+
+EXPORT_C void CSmsTestUtils::SaveBodyToFileL(TMsvId aId)
+	{
+	SetEntryL(aId);
+
+	CMsvStore* store = ReadStoreL();
+	CleanupStack::PushL(store);
+		
+	iRichText->Reset();
+	store->RestoreBodyTextL(*iRichText);
+
+	CleanupStack::PopAndDestroy(store);
+
+	const TInt length = iRichText->DocumentLength();
+		
+	HBufC* buf = HBufC::NewLC(length);
+	HBufC8* buf8 = HBufC8::NewLC(length);
+
+	TPtr bufPtr(buf->Des());
+
+	iRichText->Extract(bufPtr);
+	buf8->Des().Copy(*buf);
+	TFileName path;
+
+
+	TInt bioType = Entry().iBioType;
+	path.AppendNum((TUint)Entry().Id());
+	path.Append(_L("-"));
+	path.AppendNum(bioType);
+	path.Append(_L(".body"));
+	
+	// Remove any attachments with the same name
+	if (iClientServer == EClientSide)
+		{
+		store = iMsvEntry->EditStoreL();
+		}
+	else if (iClientServer == EServerSide)
+		{
+		store = iServerEntry->EditStoreL();
+		}
+	else
+		{
+		User::Leave(KErrNotSupported);
+		}
+	CleanupStack::PushL(store);
+	
+	CAsyncWaiter* waiter = CAsyncWaiter::NewL();
+	CleanupStack::PushL(waiter);
+	MMsvAttachmentManager& manager = store->AttachmentManagerL();
+	for(TInt ii=0; ii<manager.AttachmentCount(); ++ii )
+		{
+		
+
+		CMsvAttachment* attachment = manager.GetAttachmentInfoL(ii);
+		CleanupStack::PushL(attachment);
+		if( attachment->AttachmentName().CompareF(path) == 0 )
+			{
+			CTestActive* testActive = new (ELeave) CTestActive();
+			CleanupStack::PushL(testActive);
+			
+			// found a matching attachment, remove it
+			manager.RemoveAttachmentL(ii, waiter->iStatus);
+			waiter->StartAndWait();
+			User::LeaveIfError(waiter->Result());			
+			}
+		CleanupStack::PopAndDestroy(attachment);
+		
+		}
+	
+	// create a new attachment file
+	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
+	CleanupStack::PushL(attachment);
+	attachment->SetSize(buf->Length());
+	attachment->SetAttachmentNameL(path);
+	RFile file;
+	manager.CreateAttachmentL(path, file, attachment, waiter->iStatus);
+	CleanupStack::Pop(attachment); // ownership passed
+	waiter->StartAndWait();
+	User::LeaveIfError(waiter->Result());		
+
+	CleanupClosePushL(file);
+
+	file.Write(*buf8);
+	file.Flush();
+
+	CleanupStack::PopAndDestroy(5, buf); // file, waiter, store, buf8, buf
+	}
+
+
+
+void CSmsTestUtils::DisplayChildDetailsL(const TMsvEntry& aEntry)
+	{
+	iRTest.Printf(KMsvTestUtilsNewLine);
+	DisplayChildL(aEntry);
+	iRTest.Printf(KMsvTestUtilsNewLine);
+
+	if ((aEntry.iMtm != KUidMsgTypeSMS && aEntry.iMtm != KUidBIOMessageTypeMtm) || aEntry.iType != KUidMsvMessageEntry)
+		return;
+
+	CMsvEntry* cEntry = iMsvSession->GetEntryL(aEntry.Id());
+	CleanupStack::PushL(cEntry);
+
+	CSmsHeader* header = DoGetHeaderLC(*cEntry);
+
+	TBuf<256> temp;
+	temp.Append(_L("\tType: SMS "));
+
+	switch (header->Type())
+		{
+		case CSmsPDU::ESmsDeliver:
+			temp.Append(_L("Deliver\n"));
+			break;
+		case CSmsPDU::ESmsSubmit:
+			temp.Append(_L("Submit\n"));
+			break;
+		case CSmsPDU::ESmsDeliverReport:
+			temp.Append(_L("Deliver Report\n"));
+			break;
+		case CSmsPDU::ESmsSubmitReport:
+			temp.Append(_L("Submit Report\n"));
+			break;
+		default:
+			temp.Append(_L("Other\n"));
+			break;
+		}
+
+	iRTest.Printf(temp);
+	temp.Zero();
+
+	iRTest.Printf(_L("\tBio Type UID: %d\n"), aEntry.iBioType);
+	iRTest.Printf(_L("\tSending State: %d\n"), aEntry.SendingState());
+
+	if (header->Type() == CSmsPDU::ESmsDeliver)
+		{
+ 		CSmsDeliver& pdu = header->Deliver();
+
+		TBool found = EFalse;
+		TInt destination, originator, is16Bit;
+		destination = originator = is16Bit = 0;
+		if (pdu.UserDataPresent())
+			{
+			const CSmsUserData& userData = pdu.UserData();
+			TInt count = userData.NumInformationElements();
+			iRTest.Printf(_L("\tPdu contains %d information elements\n"), count);
+			while (!found && count--)
+				{
+				CSmsInformationElement& nextIE=userData.InformationElement(count);
+				switch(nextIE.Identifier())
+					{
+					case CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit:
+					case CSmsInformationElement::ESmsIEIApplicationPortAddressing16Bit:
+						{
+						pdu.ApplicationPortAddressing(destination, originator, &is16Bit);
+						found = ETrue;
+						break;
+						}
+					default:
+						break;
+					}
+				}
+			}
+		if (found)
+			iRTest.Printf(_L("\tApplication Port Addressing: Dest %d, Origin %d, is16Bit %d\n"), destination, originator, is16Bit);
+		else
+			iRTest.Printf(_L("\tApplication Port Addressing: Not Found\n"));
+		}
+
+	CleanupStack::PopAndDestroy(header);
+	CleanupStack::PopAndDestroy(cEntry);
+
+	iRTest.Printf(_L("\n'S'ave or any other key...\n"));
+	TChar key = iRTest.Getch();
+
+	if (key == 's' || key == 'S')
+		{
+		TRAPD(err, SaveBodyToFileL(aEntry.Id()));
+
+		if (!err)
+			iRTest.Printf(_L("\nMessage body saved OK\n"));
+		else
+			iRTest.Printf(_L("\nSave ERROR %d\n"), err);
+
+		iRTest.Getch();
+		}
+	}
+
+EXPORT_C void CSmsTestUtils::DisplayMessagesL(const CMsvEntrySelection& aSelection)
+	{
+	TInt count = aSelection.Count();
+	
+	for (TInt i = 0; i < count; i++)
+		{
+		DisplayMessageL(aSelection[i]);
+		}
+	}
+
+EXPORT_C void CSmsTestUtils::DisplayMessageL(TMsvId aId)
+	{
+	SetEntryL(aId);
+	CSmsHeader* header = GetHeaderLC(aId);
+
+	HBufC* buf = HBufC::NewLC(100 + Entry().iDetails.Length() + Entry().iDescription.Length());
+	TPtr temp(buf->Des());
+
+	temp.AppendNum((TInt) aId);
+	temp.Append(_L(" Type: "));
+
+	switch (header->Type())
+		{
+		case CSmsPDU::ESmsDeliver:
+			temp.Append(_L("Deliver"));
+			break;
+		case CSmsPDU::ESmsSubmit:
+			temp.Append(_L("Submit "));
+			break;
+		case CSmsPDU::ESmsSubmitReport:
+			temp.Append(_L("SubRprt"));
+			break;
+		case CSmsPDU::ESmsDeliverReport:
+			temp.Append(_L("DelRprt"));
+			break;
+		default:
+			temp.Append(_L("Other  "));
+			break;
+		}
+
+	temp.Append(_L(" Rcpts: "));
+	temp.AppendNum(header->Recipients().Count());
+	temp.Append(_L(" Det: \""));
+	temp.Append(Entry().iDetails);
+	temp.Append(_L("\" Desc: \""));
+	temp.Append(Entry().iDescription);
+	temp.Append(_L("\"\n"));
+	Printf(*buf);
+
+	CleanupStack::PopAndDestroy(buf);
+	CleanupStack::PopAndDestroy(header);	
+	}
+
+EXPORT_C TBool CSmsTestUtils::ReadScriptL(const TDesC& aFile, TMsvId aDestFolder, CMsvEntrySelection& aSelection, const TTime& aDate)
+	{
+	TParse fileOut;
+
+	User::LeaveIfError(ResolveFile(KSmsComponent, aFile, fileOut));
+
+	return DoReadScriptL(fileOut.FullName(), aDestFolder, aSelection, aDate);
+	}
+
+TBool CSmsTestUtils::DoReadScriptL(const TDesC& aFile, TMsvId aDestFolder, CMsvEntrySelection& aSelection, const TTime& aDate)
+	{
+	CScriptFile* scriptFile = CScriptFile::NewLC(*this, KSmsComponent, aFile);
+	TBool retVal = CreateMessagesL(aDestFolder, *scriptFile, aSelection, aDate);
+	CleanupStack::PopAndDestroy(scriptFile);
+	return retVal;
+	}
+
+TBool CSmsTestUtils::CreateMessagesL(TMsvId aDestFolder, CScriptFile& rFile, CMsvEntrySelection& rSelection, const TTime& aDate)
+	{
+	CArrayPtrFlat<CScriptSection>& sections = rFile.Sections();
+
+	TBool retVal = EFalse;
+
+	if (!sections.Count())
+		return EFalse;
+
+	const TInt secCount = sections.Count();
+	TInt count = secCount;
+	TInt all = KErrNotFound;
+	CScriptSection* section = NULL;
+
+	while (count--)
+		{
+		section = sections[count];
+		if (section->SectionName().CompareF(_L("All")) == 0)
+			{
+			all = count;
+			break;
+			}
+		}
+
+	count = secCount;
+
+	for(TInt item = 0; item < count; item++)
+		{
+		section = sections[item];
+
+		if (item == all)
+			{
+			continue;
+			}
+
+		TPtrC typePtr(section->ItemValue(KScriptItemMessageType, KScriptItemSubmit));  //  CJCW
+		TPtrC classPtr(section->ItemValue(KScriptItemMessageClass, KScriptItemClassDefault));  //  CJCW
+		TPtrC scPtr(section->ItemValue(KScriptItemSC, KScriptItemSCDef));
+		TPtrC rcptsPtr(section->ItemValue(KScriptItemRecipients, KScriptItemRecipientsDef));
+		TInt bioId(section->ItemValue(KScriptItemBioUid, KScriptItemBioUidDef));
+		TInt encoding(section->ItemValue(KScriptItemEncoding, KScriptItemEncodingDef));
+		TPtrC drPtr(section->ItemValue(KScriptItemDeliveryReport, KScriptItemDeliveryReportDef));
+		TPtrC bearerPtr(section->ItemValue(KScriptItemBearer, KScriptItemBearerDef));
+		TPtrC msgPtr(section->ItemValue(KScriptItemMessage, KNullDesC));
+		TPtrC filePtr(section->ItemValue(KScriptItemFile, KNullDesC));
+
+		TBioMsgIdType bearer = EBioMsgIdNbs;
+
+		if (bearerPtr.CompareF(_L("wap")) == 0)
+			{
+			bearer = EBioMsgIdWap;
+			}
+		else if (bearerPtr.CompareF(_L("wapsecure")) == 0)
+			{
+			bearer = EBioMsgIdWapSecure;
+			}
+
+		TSmsDataCodingScheme::TSmsAlphabet alpha = TSmsDataCodingScheme::ESmsAlphabet7Bit;
+
+		switch (encoding)
+			{
+			case 7:
+				alpha = TSmsDataCodingScheme::ESmsAlphabet7Bit;
+				break;
+			case 8:
+				alpha = TSmsDataCodingScheme::ESmsAlphabet8Bit;
+				break;
+			case 16:
+				alpha = TSmsDataCodingScheme::ESmsAlphabetUCS2;
+				break;
+			default:
+				alpha = TSmsDataCodingScheme::ESmsAlphabet7Bit;
+				break;
+			}
+
+		TBool changeDR = ETrue;
+		TBool deliveryReport = EFalse;
+
+		if (drPtr.CompareF(_L("NO")) == 0)
+			{
+			deliveryReport = EFalse;
+			}
+		else if (drPtr.CompareF(_L("YES")) == 0)
+			{
+			deliveryReport = ETrue;
+			}
+		else
+			{
+			changeDR = EFalse;
+			}
+
+		if (filePtr.Length())
+			{
+			HBufC8* tempMsg = NULL;
+			TRAPD(resErr, tempMsg = ReadFileLC(filePtr));
+
+			if (resErr)
+				{
+				TParse fileOut;
+				resErr = ResolveFile(KSmsComponent, filePtr, fileOut);
+
+				if (resErr)
+					{
+					Printf(_L("Cannot resolve file %S\n"), &filePtr);
+					User::Leave(resErr);
+					}
+
+				tempMsg = ReadFileLC(fileOut.FullName());
+				}
+
+			HBufC* msgVal = HBufC::NewLC(tempMsg->Length());
+			msgVal->Des().Copy(*tempMsg);
+			section->ReplaceItemL(KScriptItemMessage, *msgVal);
+			CleanupStack::PopAndDestroy(2); //tempMsg, msgVal
+			msgPtr.Set(section->ItemValue(KScriptItemMessage, KNullDesC));
+			}
+
+		if (msgPtr.Length())
+			{
+			//Replace LF with CRLF for vCards and vCals only
+			if (bioId == KVCardBioUid.iUid || bioId == KVCalBioUid.iUid || msgPtr.Left(5) == _L("//SCK"))
+				{
+				CScriptSectionItem* sectionItem = section->Item(KScriptItemMessage);
+
+				__ASSERT_ALWAYS(sectionItem, Panic(KErrNotFound));
+
+				CScriptFile::ReplaceL(KScriptCRLF, KScriptLF, sectionItem->iValue);
+				CScriptFile::ReplaceL(KScriptLF, KScriptCRLF, sectionItem->iValue);
+				TInt valLen = sectionItem->Value().Length();
+				sectionItem->iValue = sectionItem->iValue->ReAllocL(valLen + 2);
+				sectionItem->iValue->Des().Append(KScriptCRLF);
+				}
+
+			TLex input(rcptsPtr);
+			TPtrC rcpt;
+			TInt curRcpt = 0;
+			TMsvEntry entry;
+			
+			while (CScriptFile::GetNextWord(input, '|', rcpt) == KErrNone)
+				{
+				if (rcpt.CompareF(KDefault1) == 0 || rcpt.CompareF(KDefault2) == 0)
+					{
+					CScriptSection* defaults = section->Defaults();
+					if (defaults != NULL)
+						{
+						rcpt.Set(defaults->ItemValue(KScriptItemRecipients, KScriptItemRecipientsDef));
+						}
+					}
+
+				retVal = ETrue;
+
+				if (!curRcpt)
+					{
+					entry = TMsvEntry();
+					entry.iBioType = bioId;
+					entry.SetSendingState(KMsvSendStateUponRequest);
+
+					CSmsPDU::TSmsPDUType type=CSmsPDU::ESmsSubmit;
+					if (typePtr.CompareF(KScriptItemSubmit) == 0)  //  CJCW
+						type=CSmsPDU::ESmsSubmit;
+					else if (typePtr.CompareF(KScriptItemDeliver) == 0)
+						type=CSmsPDU::ESmsDeliver;
+					else if (typePtr.CompareF(KScriptItemStatusReport) == 0)
+						type=CSmsPDU::ESmsStatusReport;
+					else if (typePtr.CompareF(KScriptItemSubmit) == 0)
+						type=CSmsPDU::ESmsCommand;
+					else
+						User::Leave(KErrNotSupported);
+
+					CSmsHeader* header = CSmsHeader::NewL(type, *iRichText);  //  CJCW
+					CleanupStack::PushL(header);
+
+					iRichText->Reset();
+					if (msgPtr.Length())
+						{
+						if (type==CSmsPDU::ESmsStatusReport)
+							{
+							CSmsStatusReport& statusreport=header->StatusReport();
+							statusreport.SetParameterIndicatorPresent(ETrue);
+							statusreport.SetDataCodingSchemePresent(ETrue);
+							statusreport.SetUserDataPresent(ETrue);
+							}
+						iRichText->InsertL(0, msgPtr);
+						}
+
+					__ASSERT_ALWAYS(iServiceSettings, Panic(KSmsTestUtilsPanicSettingsNotConstructed));
+
+					header->SetSmsSettingsL(*iServiceSettings);
+
+					if (type==CSmsPDU::ESmsSubmit || type==CSmsPDU::ESmsDeliver)
+						{
+						CSmsPDU& pdu=header->Message().SmsPDU();
+						if (classPtr.CompareF(KScriptItemClassDefault)==0)
+							pdu.SetClass(EFalse,TSmsDataCodingScheme::ESmsClass0);
+						else if (classPtr.CompareF(KScriptItemClass0)==0)
+							pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass0);
+						else if (classPtr.CompareF(KScriptItemClass1)==0)
+							pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass1);
+						else if (classPtr.CompareF(KScriptItemClass2)==0)
+							pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass2);
+						else if (classPtr.CompareF(KScriptItemClass3)==0)
+							pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass3);
+						}
+
+					if (changeDR)
+						{
+						switch (header->Type())
+							{
+							case CSmsPDU::ESmsSubmit:
+								{
+								header->Submit().SetStatusReportRequest(deliveryReport);
+								break;
+								}
+							case CSmsPDU::ESmsCommand:
+								{
+								header->Command().SetStatusReportRequest(deliveryReport);
+								break;
+								}
+							default:
+								User::Leave(KErrNotSupported);
+							};
+						}
+
+					header->SetBioMsgIdType(bearer);
+
+					if (scPtr.CompareF(KScriptItemSCUseDefault) == 0)
+						{
+						header->Message().SetServiceCenterAddressL(TPtrC());
+						}
+					else
+						{
+						header->Message().SetServiceCenterAddressL(scPtr);
+						}
+
+					// Extract the EMS objects
+					CEmsExtractor* ems = CEmsExtractor::NewLC(*section);
+					ems->AddToMessageL(header->Message());
+					CleanupStack::PopAndDestroy(ems);
+
+					CSmsPDU& pdu=header->Message().SmsPDU();
+					if (pdu.DataCodingSchemePresent())
+						pdu.SetAlphabet(alpha);
+					
+					TMsvId destfolder=aDestFolder;
+					if (destfolder==KMsvNullIndexEntryId)
+						destfolder=(type==CSmsPDU::ESmsSubmit) || (type==CSmsPDU::ESmsCommand)? KMsvGlobalOutBoxIndexEntryId: KMsvGlobalInBoxIndexEntryId;
+
+					CreateMessageL(destfolder, entry, *header, *iRichText, aDate);
+					CleanupStack::PopAndDestroy(); //header
+
+					AddRecipientL(entry.Id(), rcpt);
+
+					rSelection.AppendL(entry.Id());
+					}
+				else
+					{
+					AddRecipientL(entry.Id(), rcpt);
+					}
+
+				curRcpt++;
+				}
+			}
+		}
+
+	return retVal;
+	}
+
+EXPORT_C TMsvId CSmsTestUtils::CreateDummyMessageToSendL()
+	{
+	TMsvEntry entry;
+	entry.SetSendingState(KMsvSendStateUponRequest);
+	entry.iDate.HomeTime();
+
+	iRichText->Reset();
+	iRichText->InsertL(0,_L("This is a send test.\näöå\n Cheers, Mico\n"));
+
+	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText);
+	CleanupStack::PushL(header);
+
+	header->SetSmsSettingsL(*iServiceSettings);
+	
+	CSmsNumber* recipient=CSmsNumber::NewL();
+	CleanupStack::PushL(recipient);
+	recipient->SetAddressL(KScriptItemRecipientsDef);
+	recipient->SetNameL(_L("Anthony"));
+	header->Recipients().AppendL(recipient);
+	CleanupStack::Pop(); //recipients
+
+	CSmsNumber* recipient2=CSmsNumber::NewL();
+	CleanupStack::PushL(recipient2);
+	recipient2->SetAddressL(KScriptItemRecipients2Def);
+	recipient2->SetNameL(_L("Julia"));
+	header->Recipients().AppendL(recipient2);
+	CleanupStack::Pop(); //recipients
+
+	TTime now;
+	now.HomeTime();
+
+	CreateMessageL(KMsvGlobalOutBoxIndexEntryId, entry, *header, *iRichText, now);
+//	Printf(_L("Test Create Message (%d) To Send\n"), entry.Id());
+
+	CleanupStack::PopAndDestroy(1); //header
+
+	return entry.Id();
+	}
+
+EXPORT_C TMsvId CSmsTestUtils::CreateDummyMessageToReceiveL()
+	{
+	TMsvEntry entry;
+	entry.iType=KUidMsvMessageEntry;
+	entry.SetSendingState(KMsvSendStateNotApplicable);
+
+	iRichText->Reset();
+	iRichText->InsertL(0,_L("Hiphei"));
+
+	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iRichText);
+	CleanupStack::PushL(header);
+
+	header->SetFromAddressL(KScriptItemRecipientsDef);
+	header->Message().SetServiceCenterAddressL(KScriptItemSCDef);
+
+	TTime now;
+	now.HomeTime();
+
+	CreateMessageL(KMsvGlobalInBoxIndexEntryId, entry, *header, *iRichText, now);
+	entry.SetReadOnly(ETrue);
+	ChangeEntryL(entry);
+
+//	Printf(_L("Create Message (%d) To Receive\n"), entry.Id());
+
+	CleanupStack::PopAndDestroy(1); //header
+	return entry.Id();
+	}
+
+EXPORT_C void CSmsTestUtils::CreateMessageL(TMsvId aDestFolder, TMsvEntry& aEntry, CSmsHeader& aHeader, CRichText& aBody, const TTime& aDate)
+	{
+	TSmsUtilities::PopulateMsgEntry(aEntry, aHeader.Message(), iSmsServiceId);
+	TBuf<KSmsDescriptionLength> desc;
+
+	TSmsUtilities::GetDescription(aHeader.Message(), desc);
+	aEntry.iDescription.Set(desc);
+
+	aEntry.iDate = aDate;
+
+	SetEntryL(aDestFolder);
+
+	CreateEntryL(aEntry);
+
+	if (iClientServer == EClientSide)
+		iMsvSession->CleanupEntryPushL(aEntry.Id());
+
+	SetEntryL(aEntry.Id());
+
+	CMsvStore* store = EditStoreL();
+	CleanupStack::PushL(store);
+
+	aHeader.StoreL(*store);
+
+	store->StoreBodyTextL(aBody);
+
+	store->CommitL();
+
+	aEntry.iSize = store->SizeL();
+	ChangeEntryL(aEntry);
+
+	CleanupStack::PopAndDestroy(store);
+
+	if (iClientServer == EClientSide)
+		iMsvSession->CleanupEntryPop();
+	}
+
+EXPORT_C void CSmsTestUtils::AddRecipientL(TMsvId aId, const TDesC& aNumber)
+	{
+	CSmsHeader* header = GetHeaderLC(aId);
+
+	SetEntryL(aId);
+	CMsvStore* store = EditStoreL();
+	CleanupStack::PushL(store);
+
+	CSmsNumber* rcpt = CSmsNumber::NewL();
+	CleanupStack::PushL(rcpt);
+	rcpt->SetAddressL(aNumber);
+
+	TBuf<KSmsDetailsLength> details;
+
+	if (TSmsUtilities::GetDetails(iFs, aNumber, details) == KErrNone)
+		{
+		rcpt->SetNameL(details);
+		TMsvEntry entry(Entry());
+		entry.iDetails.Set(details);
+		ChangeEntryL(entry);
+		}
+
+	header->Recipients().AppendL(rcpt);
+	CleanupStack::Pop(); //rcpt;
+
+	header->StoreL(*store);
+
+	store->CommitL();
+
+	CleanupStack::PopAndDestroy(store);
+	CleanupStack::PopAndDestroy(header);
+	}
+
+EXPORT_C void CSmsTestUtils::Panic(TSmsTestUtilsPanic aPanic)
+	{
+	Panic((TInt) aPanic);
+	}
+
+EXPORT_C void CSmsTestUtils::Panic(TInt aPanic)
+	{
+	User::Panic(SMSTEST_PANIC, aPanic);
+	}
+
+EXPORT_C void CSmsTestUtils::InstantiateSmsServerMtmL()
+	{
+	InstantiateServerMtmL(KUidMsgTypeSMS, iSmsServiceId);
+	}
+
+EXPORT_C void CSmsTestUtils::DeleteSmsServiceL()
+	{
+	DeleteServiceL(KUidMsgTypeSMS);
+	}
+
+EXPORT_C TMsvId CSmsTestUtils::FindExistingSmsServiceL()
+	{
+	TMsvId firstId = 0;
+	ServiceIdL(KUidMsgTypeSMS, firstId);
+	return firstId;
+	}
+
+EXPORT_C void CSmsTestUtils::FindExistingServicesL()
+	{
+	iSmsServiceId = 0;
+	TRAPD(err, iSmsServiceId = FindExistingSmsServiceL());
+
+	if (err)
+		Printf(_L("No existing SMS services found!\n"));
+	}
+
+EXPORT_C void CSmsTestUtils::DeleteSmsMessagesL(TMsvId aFolder)
+	{
+	SetEntryL(aFolder);
+	CMsvEntrySelection* sel = ChildrenWithMtmLC(KUidMsgTypeSMS);
+
+	TInt count = sel->Count();
+
+	while (count--)
+		{
+		DeleteEntryL(sel->At(count));
+		}
+
+	CleanupStack::PopAndDestroy(); //sel
+	}
+
+EXPORT_C TBool CSmsTestUtils::AreMessagesSameTextL(TMsvId aSentId, TMsvId aRecvId, TBool aPrintIfMismatch)
+	{
+	__ASSERT_ALWAYS(aSentId != aRecvId, Panic(KSmsTestUtilsPanicCannotCompareSameIds));
+
+	CSmsHeader* sentHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iRichText);
+	CleanupStack::PushL(sentHeader);
+	CSmsHeader* rcvdHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iRichText);
+	CleanupStack::PushL(rcvdHeader);
+	
+	// extract the sent message
+	SetEntryL(aSentId);
+	CMsvStore* store = ReadStoreL();
+	CleanupStack::PushL(store);
+	sentHeader->RestoreL(*store);
+	CleanupStack::PopAndDestroy(); //store
+
+	// do the same for the rx message
+	SetEntryL(aRecvId);
+	store = ReadStoreL();
+	CleanupStack::PushL(store);
+	rcvdHeader->RestoreL(*store);
+	CleanupStack::PopAndDestroy(); //store
+
+	// compare the text and the EMS objects
+	TBool retVal = EmsTestUtils::CompareEmsMsgL(sentHeader->Message(), rcvdHeader->Message());
+	if (!retVal && aPrintIfMismatch)
+		{
+		Printf(_L("Message mismatch...\n"));
+		}
+
+	CleanupStack::PopAndDestroy(rcvdHeader);
+	CleanupStack::PopAndDestroy(sentHeader);
+
+	return retVal;
+	}
+
+void CSmsTestUtils::DisplayLogEventData(const CLogEvent& aEvent)
+	{
+	if (aEvent.EventType() == KLogShortMessageEventTypeUid)
+		{
+		TLogSmsPduData data;
+		TPckg<TLogSmsPduData> packeddata(data);
+		packeddata.Copy(aEvent.Data());
+
+		TBuf<256> output;
+		output.Append(_L("\t"));
+
+		switch (data.iType)
+			{
+			case CSmsPDU::ESmsSubmit:
+				output.Append(_L("Submit"));
+				break;
+			case CSmsPDU::ESmsDeliver:
+				output.Append(_L("Deliver"));
+				break;
+			case CSmsPDU::ESmsStatusReport:
+				output.Append(_L("Status Report"));
+				break;
+			case CSmsPDU::ESmsSubmitReport:
+				output.Append(_L("Submit Report"));
+				break;
+			case CSmsPDU::ESmsDeliverReport:
+				output.Append(_L("Deliver Report"));
+				break;
+			default:
+				output.Append(_L("Command"));
+				break;
+			}
+
+		output.Append(_L(" Tot %d Sent %d Deliver %d Fail %d Recvd %d\n"));
+		Printf(output, data.iTotal, data.iSent, data.iDelivered, data.iFailed, data.iReceived);
+		}
+	}
+
+EXPORT_C void CSmsTestUtils::SetCommDbServiceCenterFromScriptL(const TDesC& aScriptFile)
+	{
+	//Update the service settings with the Service Centre address read from the script
+	Printf(_L("Setting Comm DB Service Center from Script\n"));
+	
+	TTime now;
+	now.HomeTime();
+
+	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();
+	CleanupStack::PushL(sel);
+
+	ReadScriptL(aScriptFile, KMsvGlobalOutBoxIndexEntryId, *sel, now);
+
+	Printf(_L("\t%d msgs read from %S\n"), sel->Count(), &aScriptFile);
+
+	if (!sel->Count())
+		User::Leave(KErrNotFound);
+
+	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iRichText);
+	CleanupStack::PushL(header);
+
+	SetEntryL(sel->At(0));
+	CMsvStore* store = ReadStoreL();
+	CleanupStack::PushL(store);
+	header->RestoreL(*store);
+	CleanupStack::PopAndDestroy(store);
+
+	CSmsAccount* account = CSmsAccount::NewLC();
+	account->LoadSettingsL(*iServiceSettings);
+	
+	iServiceSettings->SetCommDbAction(CSmsSettings::EStoreToCommDb);
+
+	TInt count = iServiceSettings->ServiceCenterCount();
+	while (count--)
+		{
+		iServiceSettings->RemoveServiceCenter(count);
+		}
+
+	TPtrC sc(header->Message().ServiceCenterAddress());
+	Printf(_L("\tUsing service center %S\n"), &sc);
+	iServiceSettings->AddServiceCenterL(_L("Unknown"), sc);
+
+	account->SaveSettingsL(*iServiceSettings);
+	CleanupStack::PopAndDestroy(account);    		
+
+	count = sel->Count();
+	while (count--)
+		{
+		TMsvId id = sel->At(count);
+		SetEntryL(id);
+		SetEntryL(Entry().Parent());
+		DeleteEntryL(id);
+		}
+
+	CleanupStack::PopAndDestroy(header);
+	CleanupStack::PopAndDestroy(sel);
+	Printf(_L("\tComplete: Setting Comm DB Service Center from Script\n"));
+	}
+
+EXPORT_C TBool CSmsTestUtils::SendingCompleteL(const CMsvEntrySelection& aSelection, TInt& rError)
+	{
+	TBool sent = ETrue;
+	const TInt msgCount = aSelection.Count();
+	TInt err = KErrNone;
+
+	for (TInt msg = 0; msg < msgCount; msg++)
+		{
+		TRAP(err, SetEntryL(aSelection[msg]));
+
+		if (err == KErrNone)
+			{
+			TMsvEntry entry = Entry();
+			
+			TRAP(err, SetEntryL(KMsvGlobalOutBoxIndexEntryId)); //ignore error
+
+			switch (entry.SendingState())
+				{
+				case KMsvSendStateSending:
+				case KMsvSendStateResend:
+				case KMsvSendStateScheduled:
+				case KMsvSendStateWaiting:
+					sent = EFalse;
+					break;
+				case KMsvSendStateFailed:
+					if (entry.iError)
+						rError = entry.iError;
+					else
+						rError = KErrGeneral;
+					break;
+				default:
+					break;
+					//nothing
+				}
+			}
+		}
+
+	return sent;
+	}
+
+EXPORT_C void CSmsTestUtils::DisplaySendingStatesL(const CMsvEntrySelection& aSelection)
+	{
+	TInt err = KErrNone;
+	TInt msgCount = aSelection.Count();
+
+	for (TInt msg = 0; msg < msgCount; msg++)
+		{
+		TRAP(err, SetEntryL(aSelection[msg]));
+
+		if (!err)
+			{
+			TMsvEntry entry = Entry();
+			TRAP(err, SetEntryL(KMsvGlobalOutBoxIndexEntryId)); //ignore error
+
+				TBuf<0x100> output;
+				TBuf<0x50>  nowBuf;
+
+				switch (entry.SendingState())
+					{
+					case KMsvSendStateSending:
+						output.AppendFormat(_L("Message %d Sending with error %d\n"), entry.Id(), entry.iError);
+						break;
+					case KMsvSendStateResend:
+						output.AppendFormat(_L("Message %d Resend with error %d at:\n"), entry.Id(), entry.iError);
+						err = AppendScheduleTimeL(entry.Id(), output);
+						if (err)
+							{
+							entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B"));
+							output.Append(nowBuf);
+							output.Append(_L("\n"));
+							}
+						break;
+					case KMsvSendStateScheduled:
+						output.AppendFormat(_L("Message %d Scheduled with error %d at:\n"), entry.Id(), entry.iError);
+						err = AppendScheduleTimeL(entry.Id(), output);
+						break;
+					case KMsvSendStateFailed:
+						output.AppendFormat(_L("Message %d Failed with error %d\n"), entry.Id(), entry.iError);
+						break;
+					case KMsvSendStateWaiting:
+						output.AppendFormat(_L("Message %d Waiting with error %d\n"), entry.Id(), entry.iError);
+						break;
+					case KMsvSendStateSent:
+						output.AppendFormat(_L("Message %d Sent\n"), entry.Id());
+						break;
+					case KMsvSendStateSuspended:
+						output.AppendFormat(_L("Message %d Suspended\n"), entry.Id());
+						break;
+					default:
+						output.AppendFormat(_L("Message %d Other Sending State with error %d and failed %d\n"), entry.Id(), entry.iError, entry.Failed());
+						break;
+						//nothing
+					} //end switch
+				Printf(output);
+			} //end if
+		} //end for
+	}
+
+CSmsHeader* CSmsTestUtils::DoGetHeaderLC(CMsvEntry& aEntry)
+	{
+	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iRichText);
+	CleanupStack::PushL(header);
+
+	CMsvStore* store = aEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+
+	header->RestoreL(*store);
+	iRichText->Reset();
+	store->RestoreBodyTextL(*iRichText);
+
+	CleanupStack::PopAndDestroy(store);
+
+	return header;
+	}
+
+EXPORT_C CSmsHeader* CSmsTestUtils::GetHeaderLC(TMsvId aId)
+	{
+	iMsvEntry->SetEntryL(aId);
+	return DoGetHeaderLC(*iMsvEntry);
+	}