diff -r 4ca382093dae -r 493058e57c8c buildverification/smoketest/messaging/Src/TestMessBase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/buildverification/smoketest/messaging/Src/TestMessBase.cpp	Wed Sep 01 12:30:50 2010 +0100
@@ -0,0 +1,1519 @@
+// Copyright (c) 2002-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:
+// This contains CTestCase which is the base class for all the TestCase DLLs
+// 
+//
+
+#include "Configuration.cfg"
+
+#include "TestMessBase.h"
+#include "TestMessProcessor.h"
+#include "TestMessTimer.h"
+#include "TestMessPrintEntryUtil.h"
+
+// EPOC includes
+#include <smtpset.h>
+#include <pop3set.h>
+#include <imapset.h>
+#include <txtrich.h>
+#include <f32file.h>
+#include <msvids.h>
+#include <fbs.h>
+#include <emsuserpromptie.h>
+#ifdef __MESSAGING_API_V2__
+#include <smut.h>
+#include <miutset.h>
+#include <cemailaccounts.h>
+#include <csmsaccount.h>
+#endif
+/**
+ * @name Constant Literals used.
+ */
+/*@{*/
+_LIT(KDepth,					"depth");
+_LIT(KFolder,					"folder%d");
+
+// Default value for depth of the count
+#define KDefaultDepthCount		1
+
+// Default value for depth of the count
+#define KDefaultDepthCount		1
+
+_LIT(KDefault,					"default");
+
+_LIT(KScheduled,				"scheduled");
+_LIT(KProgress,					"progress");
+
+//_LIT(KIap,						"iap");
+//_LIT(KIapName,					"iapname");
+
+_LIT(KElements,					"elements");
+_LIT(KStartPosition,			"StartPosition%d");
+_LIT(KFile,						"File%d");
+_LIT(KType,						"Type%d");
+_LIT(KTypeFormat,				"Format");
+_LIT(KTypeSound,				"Sound");
+_LIT(KTypePreDefSound,			"PreDefSound");
+_LIT(KTypeAnimation,			"Animation");
+_LIT(KTypePreDefAnimation,		"PreDefAnimation");
+_LIT(KTypePicture,				"Picture");
+_LIT(KTypeUserPrompt,			"UserPrompt");
+_LIT(KFormatLength,				"FormatLength%d");
+_LIT(KBold,						"Bold%d");
+_LIT(KItalic,					"Italic%d");
+_LIT(KUnderline,				"Underline%d");
+_LIT(KStrikethrough,			"Strikethrough%d");
+_LIT(KAlignment,				"Alignment%d");
+_LIT(KFontSize,					"FontSize%d");
+
+_LIT(KLeftAlign,				"LeftAlign");
+_LIT(KRightAlign,				"RightAlign");
+_LIT(KCenterAlign,				"CenterAlign");
+_LIT(KLangDepend,				"LangDepend");
+
+_LIT(KNormal,					"Normal");
+_LIT(KLarge,					"Large");
+_LIT(KSmall,					"Small");
+_LIT(KVariable,					"Variable");
+_LIT(KReserved,					"Reserved");
+
+_LIT(KEmsPreDef,				"emspredef%d");
+
+_LIT(KEmsAnimTypeFlirty,		"a0");
+_LIT(KEmsAnimTypeGlad,			"a1");
+_LIT(KEmsAnimTypeSceptic,		"a2");
+_LIT(KEmsAnimTypeSad,			"a3");
+_LIT(KEmsAnimTypeWow,			"a4");
+_LIT(KEmsAnimTypeCrying,		"a5");
+_LIT(KEmsAnimTypeWinking,		"a6");
+_LIT(KEmsAnimTypeLaughing,		"a7");
+_LIT(KEmsAnimTypeIndifferent,	"a8");
+_LIT(KEmsAnimTypeKissing,		"a9");
+_LIT(KEmsAnimTypeConfused,		"a10");
+_LIT(KEmsAnimTypeTongueOut,		"a11");
+_LIT(KEmsAnimTypeAngry,			"a12");
+_LIT(KEmsAnimTypeGlasses,		"a13");
+_LIT(KEmsAnimTypeDevil,			"a14");
+
+_LIT(KEmsSoundTypeChimesHigh,	"s0");
+_LIT(KEmsSoundTypeChimesLow,	"s1");
+_LIT(KEmsSoundTypeDing,			"s2");
+_LIT(KEmsSoundTypeTaDa,			"s3");
+_LIT(KEmsSoundTypeNotify,		"s4");
+_LIT(KEmsSoundTypeDrum,			"s5");
+_LIT(KEmsSoundTypeClaps,		"s6");
+_LIT(KEmsSoundTypeFanFar,		"s7");
+_LIT(KEmsSoundTypeChordHigh,	"s8");
+_LIT(KEmsSoundTypeChordLow,		"s9");
+
+/*
+_LIT(KBioIAP,					"IAP");
+_LIT(KBioEmailNotification,		"EmailNotification");
+_LIT(KBioBusinessCard,			"BusinessCard");
+_LIT(KBioWAPAccessPoint,		"WAPAccessPoint");
+_LIT(KBioVCalendar,				"VCalendar");
+_LIT(KBioVCard,					"VCard");
+_LIT(KBioRingingTones,			"RingingTones");
+_LIT(KBioOperatorLogo,			"OperatorLogo");
+_LIT(KBioWPRV,					"WPRV");
+_LIT(KBioCLILogo,				"CLILogo");
+*/
+_LIT(KObjectSize,				"ObjectSize%d");
+_LIT(KBody,						"body");
+/*@}*/
+
+const TInt KSmallObject		= 0;
+const TInt KLargeObject		= 1;
+const TInt KVariableObject	= 2;
+
+const TInt KDefaultStartPos	= 1;
+
+/**
+ * Constructor.
+ * @return - None
+ * 
+*/	
+CTestMessBase::CTestMessBase(TBool aSetDirectory)
+:	CTestStepSmokeTest()
+,	iSession(NULL)
+,	iMessageProcessor(NULL)
+,   iParaFormatLayer(NULL)
+,   iCharFormatLayer(NULL)
+,   iBodyText(NULL)
+,	iBodyAvailable(EFalse)
+,	iSetDirectory(aSetDirectory)
+,	iMessageTimer(NULL)
+,	iSchedular(NULL)
+,	iEntry(NULL)
+,	iOrder(KMsvGroupByType|KMsvGroupByStandardFolders, EMsvSortById, ETrue)
+	{
+	}
+
+CTestMessBase::~CTestMessBase()
+	{
+	delete iEntry;
+	iEntry=NULL;
+	delete iMessageTimer;
+	iMessageTimer=NULL;
+	delete iMessageProcessor;
+	iMessageProcessor=NULL;
+	delete iSession;
+	iSession=NULL;
+	delete iSchedular;
+	iSchedular=NULL;
+	delete iBodyText;
+	iBodyText=NULL;
+	delete iCharFormatLayer;
+	iCharFormatLayer=NULL;
+	delete iParaFormatLayer;
+	iParaFormatLayer=NULL;
+	}
+
+enum TVerdict CTestMessBase::doTestStepPreambleL()
+	{
+	TVerdict	ret=CTestStepSmokeTest::doTestStepPreambleL();
+
+	// Printing to the console and log file
+	const TDesC&	stepName=TestStepName();
+	INFO_PRINTF2(_L("%S"), &stepName);
+
+	iSchedular=new (ELeave) CActiveScheduler();
+	CActiveScheduler::Install(iSchedular);
+	iSession=CMsvSession::OpenSyncL(*this);
+
+	//	Get progress
+	TInt	progress=0;
+	TBool	hasProgress=GetIntFromConfig(ConfigSection(), KProgress, progress);
+	if ( !hasProgress )
+		{
+		hasProgress=GetIntFromConfig(KDefault, KProgress, progress);
+		}
+
+	iMessageProcessor=CTestMessProcessor::NewL(*this, *iSession);
+	if ( hasProgress )
+		{
+		iMessageTimer=CTestMessTimer::NewL(progress*KOneSecond, *iMessageProcessor);
+		}
+
+	if ( iSetDirectory )
+		{
+		TInt	depth=KDefaultDepthCount;
+		TBool	returnValue=GetIntFromConfig(ConfigSection(), KDepth, depth);
+		if ( !returnValue )
+			{
+			depth=KDefaultDepthCount;
+			}
+		INFO_PRINTF2(_L("Depth = %d"), depth);
+
+		//	Searce for the entry
+		TRAPD(error,SetEntryL(KMsvRootIndexEntryId));
+		if( error != KErrNone)
+			{
+			INFO_PRINTF2(_L("Set Entry failed, Error %D"),error);
+			SetTestStepError(error);
+			ret=EFail;
+			}
+		else
+			{
+
+			TBuf<KMaxTestExecuteCommandLength>	tempStore;
+			TBool								found=ETrue;
+			for (TInt entry=0; entry<depth && found;)
+				{
+				TPtrC	subject;
+				tempStore.Format(KFolder(), ++entry);
+				returnValue =GetStringFromConfig(ConfigSection(), tempStore, subject);
+				if ( !returnValue )
+					{
+					INFO_PRINTF1(_L("Null Folder"));
+					}
+				INFO_PRINTF2(_L("Folder = %S"), &subject);
+
+				CMsvEntrySelection*	selection=EntryL().ChildrenL();
+				CleanupStack::PushL(selection);
+				TInt				count=selection->Count();
+		
+				found=EFalse;
+				for (TInt i=count; i>0 && !found; )
+					{
+					TMsvId	childId=selection->At(--i);
+
+					SetEntryL(childId);
+					INFO_PRINTF2(_L("Entry Detail : %S"), &(EntryL().Entry().iDetails));
+					INFO_PRINTF2(_L("Entry Description: %S"), &(EntryL().Entry().iDescription));
+					if ( subject.Compare(EntryL().Entry().iDetails) == 0 ||
+						 subject.Compare(EntryL().Entry().iDescription) == 0 )
+						{
+						found=ETrue;
+						}
+					}
+				CleanupStack::PopAndDestroy(selection);
+				}
+
+			if ( !found )
+				{
+				ERR_PRINTF1(_L("Folder not found"));
+				ret=EFail;
+				}
+			}
+		}
+	if (TestStepResult() == EPass)
+		{
+		//Get body(file path) from ini file and read respective file. Store it into CRichText format.
+		iParaFormatLayer=CParaFormatLayer::NewL();
+		iCharFormatLayer=CCharFormatLayer::NewL(); 
+		iBodyText=CRichText::NewL(iParaFormatLayer, iCharFormatLayer);
+		iBodyAvailable=EFalse;
+	
+		TPtrC	body;
+		if(GetStringFromConfig(ConfigSection(), KBody, body))
+			{
+			INFO_PRINTF2(_L("Body = %S"), &body);
+			iBodyAvailable=ETrue;
+			}
+		else
+			{
+			INFO_PRINTF1(_L("No Body"));
+			}
+
+		if ( iBodyAvailable )
+			{
+			// open the file
+			RFile	file;
+	
+			TInt anError = file.Open(iSession->FileSession(), body, EFileShareAny);
+			if(anError == KErrNone)
+				{
+				TBool		reading=ETrue;
+				TInt		pos=0;
+				TBuf8<1>	charIn;
+				while (reading)
+					{
+					file.Read(charIn, 1);
+					if(charIn.Length())
+						{
+						switch ( charIn[0] )
+							{
+						case '\r':
+							iBodyText->InsertL(pos++, CEditableText::ELineBreak);
+						case '\n':
+							break;
+						default:
+							iBodyText->InsertL(pos++, TChar(charIn[0]));
+							}
+						}
+					else
+						{
+						reading = EFalse;	// stop at the end of the file
+						}
+					}
+				iBodyAvailable=ETrue;
+				file.Close();
+				}
+			else
+			{
+			INFO_PRINTF2(_L("Cannot open file = %S"), &body);
+			iBodyAvailable=EFalse;
+			}
+		}//End of read file.
+	}
+
+	SetTestStepResult(ret);
+	return ret;
+	}
+
+enum TVerdict CTestMessBase::doTestStepPostambleL()
+	{
+	delete iEntry;
+	iEntry=NULL;
+	delete iMessageTimer;
+	iMessageTimer=NULL;
+	delete iMessageProcessor;
+	iMessageProcessor=NULL;
+	delete iSession;
+	iSession=NULL;
+	delete iSchedular;
+	iSchedular=NULL;
+	CActiveScheduler::Install(NULL);
+	return CTestStepSmokeTest::doTestStepPostambleL();
+	}
+
+void CTestMessBase::SetEntryL(TMsvId aId)
+	{
+	delete iEntry;
+	iEntry=NULL;
+	iEntry=iSession->GetEntryL(aId);
+	}
+
+CMsvEntry& CTestMessBase::EntryL()
+	{
+	if ( iEntry == NULL )
+		{
+		User::Leave(KErrGeneral);
+		}
+
+	return *iEntry;
+	}
+
+
+HBufC8* CTestMessBase::CopyToBuf8LC(const TDesC& aDesC)
+//
+// @return - HBufC8*
+// Converts TDesC to HBufC8*.
+//
+	{
+	HBufC8*	itemBuff8 = HBufC8::NewLC(aDesC.Length());
+	itemBuff8->Des().Copy(aDesC);
+
+	return itemBuff8;
+	}
+
+HBufC* CTestMessBase::CopyToBufLC(const TDesC8& aDesC)
+//
+// @return - HBufC8*
+// Converts TDesC to HBufC8*.
+//
+	{
+	HBufC*	itemBuff = HBufC::NewLC(aDesC.Length());
+	itemBuff->Des().Copy(aDesC);
+
+	return itemBuff;
+	}
+
+
+#ifndef __MESSAGING_API_V2__
+void CTestMessBase::SetDefaultServiceL(TUid aMtm, TMsvId aService) const
+	{
+	// --- Now restore the default services from the root store ---
+	CMsvEntry*				rootEntry=iSession->GetEntryL(KMsvRootIndexEntryIdValue);
+	CleanupStack::PushL(rootEntry);
+	CMsvStore*				store = rootEntry->EditStoreL();
+	CleanupStack::PushL(store);
+	CMsvDefaultServices*	services = new(ELeave)CMsvDefaultServices;
+	CleanupStack::PushL(services);
+	services->RestoreL(*store);
+
+	// --- And now re-set the default service for the MTM to the one given ---
+	TMsvDefaultService	defaultService;
+	defaultService.iMtm=aMtm;
+	defaultService.iService=aService;
+	services->ChangeDefaultServiceL(defaultService);
+	services->StoreL(*store);
+	store->CommitL();
+	CleanupStack::PopAndDestroy(3, rootEntry);
+	}
+
+TInt CTestMessBase::DefaultServiceL(TUid aMtm, TMsvId& aService) const
+	{
+	// --- Now restore the default services from the root store ---
+	CMsvEntry*				rootEntry=iSession->GetEntryL(KMsvRootIndexEntryIdValue);
+	CleanupStack::PushL(rootEntry);
+	CMsvStore*				store=rootEntry->ReadStoreL();
+	CleanupStack::PushL(store);
+	CMsvDefaultServices*	services=new(ELeave)CMsvDefaultServices;
+	CleanupStack::PushL(services);
+	services->RestoreL(*store);
+
+	TInt					ret=services->DefaultService(aMtm, aService);
+
+	CleanupStack::PopAndDestroy(3, rootEntry);
+
+	return ret;
+	}
+#endif
+
+void CTestMessBase::PrintTreeL(TMsvId aRoot)
+	{
+	INFO_PRINTF1(_L("PrintTreeL In"));
+	CMsvEntry*			entry=iSession->GetEntryL(aRoot);
+	CleanupStack::PushL(entry);
+	entry->SetSortTypeL(SelectionOrdering());
+	CMsvEntrySelection*	selection=entry->ChildrenL();
+	CleanupStack::PushL(selection);
+
+	PrintEntryL(*entry);
+	for (TInt i=0; i<selection->Count(); )
+		{
+		PrintTreeL(selection->At(i++));
+		}
+
+	CleanupStack::PopAndDestroy(2, entry);
+	INFO_PRINTF1(_L("PrintTreeL Out"));
+	}
+
+void CTestMessBase::PrintEntryL(CMsvEntry& aEntry)
+	{
+	TMsvEntry	entry=aEntry.Entry();
+
+	INFO_PRINTF2(_L("Entry Detail : %S"), &(entry.iDetails));
+	INFO_PRINTF2(_L("  Description: %S"), &(entry.iDescription));
+	INFO_PRINTF2(_L("  Id         : %x"), entry.Id());
+	INFO_PRINTF2(_L("  Parent Id  : %x"), entry.Parent());
+	INFO_PRINTF2(_L("  Service Id : %x"), entry.iServiceId);
+	if ( entry.iRelatedId != 0 )
+		{
+		INFO_PRINTF2(_L("  Related Id : %x"), entry.iRelatedId);
+		}
+	INFO_PRINTF2(_L("  Type       : %x"), entry.iType);
+	INFO_PRINTF2(_L("  Mtm        : %x"), entry.iMtm);
+
+
+	if ( entry.iSize != 0 )
+		{
+		INFO_PRINTF2(_L("  Size       : %x"), entry.iSize);
+		}
+	if ( entry.iError != 0 )
+		{
+		INFO_PRINTF2(_L("  Error      : %d"), entry.iError);
+		}
+	if ( entry.iBioType != 0 )
+		{
+		INFO_PRINTF2(_L("  BioType    : %x"), entry.iBioType);
+		}
+	if ( entry.MtmData1() != 0 )
+		{
+		INFO_PRINTF2(_L("  MtmData1   : %x"), entry.MtmData1());
+		}
+	if ( entry.MtmData2() != 0 )
+		{
+		INFO_PRINTF2(_L("  MtmData2   : %x"), entry.MtmData2());
+		}
+	if ( entry.MtmData3() != 0 )
+		{
+		INFO_PRINTF2(_L("  MtmData3   : %x"), entry.MtmData3());
+		}
+	if ( entry.Attachment() != 0 )
+		{
+		INFO_PRINTF2(_L("  Attachment : %x"), entry.Attachment());
+		}
+	if ( entry.Complete() != 0 )
+		{
+		INFO_PRINTF2(_L("  Complete   : %x"), entry.Complete());
+		}
+	if ( entry.Connected() != 0 )
+		{
+		INFO_PRINTF2(_L("  Connected  : %x"), entry.Connected());
+		}
+	if ( entry.Deleted() != 0 )
+		{
+		INFO_PRINTF2(_L("  Deleted    : %x"), entry.Deleted());
+		}
+	if ( entry.Failed() != 0 )
+		{
+		INFO_PRINTF2(_L("  Failed     : %x"), entry.Failed());
+		}
+	if ( entry.InPreparation() != 0 )
+		{
+		INFO_PRINTF2(_L("  InPrep     : %x"), entry.InPreparation());
+		}
+	if ( entry.MultipleRecipients() != 0 )
+		{
+		INFO_PRINTF2(_L("  MultiRecip : %x"), entry.MultipleRecipients());
+		}
+	if ( entry.OffPeak() != 0 )
+		{
+		INFO_PRINTF2(_L("  OffPeak    : %x"), entry.OffPeak());
+		}
+	if ( entry.Operation() != 0 )
+		{
+		INFO_PRINTF2(_L("  Operation  : %x"), entry.Operation());
+		}
+	if ( entry.Owner() != 0 )
+		{
+		INFO_PRINTF2(_L("  Owner      : %x"), entry.Owner());
+		}
+	if ( entry.PcSyncCount() != 0 )
+		{
+		INFO_PRINTF2(_L("  PcSyncCount: %x"), entry.PcSyncCount());
+		}
+	if ( entry.Priority() != 0 )
+		{
+		INFO_PRINTF2(_L("  Priority   : %x"), entry.Priority());
+		}
+	if ( entry.ReadOnly() != 0 )
+		{
+		INFO_PRINTF2(_L("  ReadOnly   : %x"), entry.ReadOnly());
+		}
+	if ( entry.Scheduled() != 0 )
+		{
+		INFO_PRINTF2(_L("  Scheduled  : %x"), entry.Scheduled());
+		}
+	if ( entry.SendingState() != 0 )
+		{
+		INFO_PRINTF2(_L("  Send State : %x"), entry.SendingState());
+		}
+	if ( entry.StandardFolder() != 0 )
+		{
+		INFO_PRINTF2(_L("  StdFolder  : %x"), entry.StandardFolder());
+		}
+	if ( entry.Unread() != 0 )
+		{
+		INFO_PRINTF2(_L("  Unread     : %x"), entry.Unread());
+		}
+	if ( entry.Visible() != 0 )
+		{
+		INFO_PRINTF2(_L("  Visible    : %x"), entry.Visible());
+		}
+
+#if (!defined CDMA_API_ENABLED)
+	if ( aEntry.HasStoreL() )
+		{
+		PrintStoreL(aEntry);
+		}
+#endif
+	}
+
+void CTestMessBase::PrintStoreL(CMsvEntry& aEntry)
+	{
+	TMsvEntry					entry=aEntry.Entry();
+	CTestMessPrintEntryUtil*	printUtil=new (ELeave) CTestMessPrintEntryUtil(*this);
+	CleanupStack::PushL(printUtil);
+
+	printUtil->ProcessEntryL(entry.Id());
+	CleanupStack::PopAndDestroy(printUtil);
+
+	if ( entry.iMtm==KUidMsgTypeSMTP )
+		{
+		PrintStoreSmtpL(aEntry);
+		}
+	else if ( entry.iMtm == KUidMsgTypePOP3 )
+		{
+		PrintStorePop3L(aEntry);
+		}
+	else if ( entry.iMtm == KUidMsgTypeIMAP4 )
+		{
+		PrintStoreImap4L(aEntry);
+		}
+	else if ( entry.iMtm == KUidMsgTypeSMS )
+		{
+		PrintStoreSmsL(aEntry);
+		}
+	}
+
+void CTestMessBase::PrintStoreSmtpL(CMsvEntry& aEntry)
+	{
+	TMsvEntry	entry=aEntry.Entry();
+	CMsvStore*	store=aEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+
+	TPtrC	ptrTemp;
+	if ( entry.iType == KUidMsvServiceEntry )
+		{
+		CImSmtpSettings*	settings = new(ELeave) CImSmtpSettings();
+		CleanupStack::PushL(settings);
+#ifdef __MESSAGING_API_V2__
+		CEmailAccounts*		accounts = CEmailAccounts::NewLC();
+		TSmtpAccount smtpAccountId;
+		accounts->GetSmtpAccountL(aEntry.EntryId(), smtpAccountId);
+		TRAPD(err, accounts->LoadSmtpSettingsL(smtpAccountId, *settings));
+		CleanupStack::PopAndDestroy(accounts);
+#else
+		TRAPD(err, settings->RestoreL(*store));
+#endif
+		if ( err == KErrNone )
+			{
+			ptrTemp.Set(settings->ServerAddress());
+			INFO_PRINTF2(_L("  ServerAddress                : %S"), &ptrTemp);
+#ifndef __MESSAGING_API_V2__
+			ptrTemp.Set(settings->UserAddress());
+			INFO_PRINTF2(_L("  UserAddress                  : %S"), &ptrTemp);
+			INFO_PRINTF2(_L("  Version                      : %x"), (TUint)settings->Version());
+#endif
+			INFO_PRINTF2(_L("  Port                         : %x"), settings->Port());
+			INFO_PRINTF2(_L("  SecureSockets                : %x"), (TUint)settings->SecureSockets());
+			ptrTemp.Set(settings->EmailAlias());
+			INFO_PRINTF2(_L("  EmailAlias                   : %S"), &ptrTemp);
+			ptrTemp.Set(settings->EmailAddress());
+			INFO_PRINTF2(_L("  EmailAddress                 : %S"), &ptrTemp);
+			ptrTemp.Set(settings->ReplyToAddress());
+			INFO_PRINTF2(_L("  ReplyToAddress               : %S"), &ptrTemp);
+			ptrTemp.Set(settings->ReceiptAddress());
+			INFO_PRINTF2(_L("  ReceiptAddress               : %S"), &ptrTemp);
+			if ( settings->RequestReceipts() != 0 )
+				{
+				INFO_PRINTF2(_L("  RequestReceipts              : %x"), (TUint)settings->RequestReceipts());
+				}
+			if ( settings->SendCopyToSelf() != 0 )
+				{
+				INFO_PRINTF2(_L("  SendCopyToSelf               : %x"), (TUint)settings->SendCopyToSelf());
+				}
+			INFO_PRINTF2(_L("  SendMessageOption            : %x"), (TUint)settings->SendMessageOption());
+			}
+		CleanupStack::PopAndDestroy(settings);
+		}
+
+	CleanupStack::PopAndDestroy(store);
+	}
+
+void CTestMessBase::PrintStorePop3L(CMsvEntry& aEntry)
+	{
+	TMsvEntry	entry=aEntry.Entry();
+	CMsvStore*	store=aEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+
+	TPtrC	ptrTemp;
+	if ( entry.iType == KUidMsvServiceEntry )
+		{
+		CImPop3Settings*	settings = new(ELeave) CImPop3Settings();
+		CleanupStack::PushL(settings);
+
+#ifdef __MESSAGING_API_V2__
+		CEmailAccounts*		accounts = CEmailAccounts::NewLC();
+		TPopAccount popAccountId;
+		accounts->GetPopAccountL(aEntry.EntryId(), popAccountId);
+		TRAPD(err, accounts->LoadPopSettingsL(popAccountId, *settings));
+		CleanupStack::PopAndDestroy(accounts);
+#else
+		TRAPD(err, settings->RestoreL(*store));
+#endif
+		if ( err == KErrNone )
+			{
+			ptrTemp.Set(settings->ServerAddress());
+			INFO_PRINTF2(_L("  ServerAddress                : %S"), &ptrTemp);
+#ifndef __MESSAGING_API_V2__
+			ptrTemp.Set(settings->UserAddress());
+			INFO_PRINTF2(_L("  UserAddress                  : %S"), &ptrTemp);
+			INFO_PRINTF2(_L("  Version                      : %x"), (TUint)settings->Version());
+#endif
+			INFO_PRINTF2(_L("  Port                         : %x"), settings->Port());
+			INFO_PRINTF2(_L("  SecureSockets                : %x"), (TUint)settings->SecureSockets());
+			HBufC*	loginName=CopyToBufLC(settings->LoginName());
+			INFO_PRINTF2(_L("  LoginName                    : %S"), loginName);
+			CleanupStack::PopAndDestroy(loginName);
+			if ( settings->AutoSendOnConnect() != 0 )
+				{
+				INFO_PRINTF2(_L("  AutoSendOnConnect            : %x"), (TUint)settings->AutoSendOnConnect());
+				}
+			if ( settings->Apop() != 0 )
+				{
+				INFO_PRINTF2(_L("  Apop                         : %x"), (TUint)settings->Apop());
+				}
+			if ( settings->DisconnectedUserMode() != 0 )
+				{
+				INFO_PRINTF2(_L("  DisconnectedUserMode         : %x"), (TUint)settings->DisconnectedUserMode());
+				}
+			if ( settings->DeleteEmailsWhenDisconnecting() != 0 )
+				{
+				INFO_PRINTF2(_L("  DeleteEmailsWhenDisconnecting: %x"), (TUint)settings->DeleteEmailsWhenDisconnecting());
+				}
+			if ( settings->AcknowledgeReceipts() != 0 )
+				{
+				INFO_PRINTF2(_L("  AcknowledgeReceipts          : %x"), (TUint)settings->AcknowledgeReceipts());
+				}
+			if ( settings->MaxEmailSize() != 0 )
+				{
+				INFO_PRINTF2(_L("  MaxEmailSize                 : %x"), (TUint)settings->MaxEmailSize());
+				}
+			if ( settings->GetMailOptions() != 0 )
+				{
+				INFO_PRINTF2(_L("  GetMailOptions               : %x"), (TUint)settings->GetMailOptions());
+				}
+			if ( settings->InboxSynchronisationLimit() != 0 )
+				{
+				INFO_PRINTF2(_L("  InboxSynchronisationLimit    : %x"), (TUint)settings->InboxSynchronisationLimit());
+				}
+			}
+		CleanupStack::PopAndDestroy(settings);
+		}
+
+	CleanupStack::PopAndDestroy(store);
+	}
+
+void CTestMessBase::PrintStoreImap4L(CMsvEntry& aEntry)
+	{
+	TMsvEntry	entry=aEntry.Entry();
+	CMsvStore*	store=aEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+
+	TPtrC	ptrTemp;
+	if ( entry.iType == KUidMsvServiceEntry )
+		{
+		CImImap4Settings*	settings = new(ELeave) CImImap4Settings();
+		CleanupStack::PushL(settings);
+
+#ifdef __MESSAGING_API_V2__
+		CEmailAccounts*		accounts = CEmailAccounts::NewLC();
+		TImapAccount imapAccountId;
+		accounts->GetImapAccountL(aEntry.EntryId(), imapAccountId);
+		TRAPD(err, accounts->LoadImapSettingsL(imapAccountId, *settings));
+		CleanupStack::PopAndDestroy(accounts);
+#else
+		TRAPD(err, settings->RestoreL(*store));
+#endif
+		if ( err == KErrNone )
+			{
+			ptrTemp.Set(settings->ServerAddress());
+			INFO_PRINTF2(_L("  ServerAddress                : %S"), &ptrTemp);
+#ifndef __MESSAGING_API_V2__
+			ptrTemp.Set(settings->UserAddress());
+			INFO_PRINTF2(_L("  UserAddress                  : %S"), &ptrTemp);
+			INFO_PRINTF2(_L("  Version                      : %x"), (TUint)settings->Version());
+#endif
+			INFO_PRINTF2(_L("  Port                         : %x"), settings->Port());
+			INFO_PRINTF2(_L("  SecureSockets                : %x"), (TUint)settings->SecureSockets());
+
+			HBufC*	loginName=CopyToBufLC(settings->LoginName());
+			INFO_PRINTF2(_L("  LoginName                    : %S"), loginName);
+			HBufC*	folderPath=CopyToBufLC(settings->FolderPath());
+			INFO_PRINTF2(_L("  FolderPath                   : %S"), folderPath);
+			CleanupStack::PopAndDestroy(2, loginName);
+			if ( settings->PathSeparator() != 0 )
+				{
+				INFO_PRINTF2(_L("  PathSeparator                : %c"), (TText)settings->PathSeparator());
+				}
+			if ( settings->DisconnectedUserMode() != 0 )
+				{
+				INFO_PRINTF2(_L("  DisconnectedUserMode         : %x"), (TUint)settings->DisconnectedUserMode());
+				}
+			if ( settings->Synchronise() != 0 )
+				{
+				INFO_PRINTF2(_L("  Synchronise                  : %x"), (TUint)settings->Synchronise());
+				}
+			if ( settings->Subscribe() != 0 )
+				{
+				INFO_PRINTF2(_L("  Subscribe                    : %x"), (TUint)settings->Subscribe());
+				}
+			if ( settings->AutoSendOnConnect() != 0 )
+				{
+				INFO_PRINTF2(_L("  AutoSendOnConnect            : %x"), (TUint)settings->AutoSendOnConnect());
+				}
+			if ( settings->MaxEmailSize() != 0 )
+				{
+				INFO_PRINTF2(_L("  MaxEmailSize                 : %x"), (TUint)settings->MaxEmailSize());
+				}
+			if ( settings->DeleteEmailsWhenDisconnecting() != 0 )
+				{
+				INFO_PRINTF2(_L("  DeleteEmailsWhenDisconnecting: %x"), (TUint)settings->DeleteEmailsWhenDisconnecting());
+				}
+			if ( settings->AcknowledgeReceipts() != 0 )
+				{
+				INFO_PRINTF2(_L("  AcknowledgeReceipts          : %x"), (TUint)settings->AcknowledgeReceipts());
+				}
+			if ( settings->GetMailOptions() != 0 )
+				{
+				INFO_PRINTF2(_L("  GetMailOptions               : %x"), (TUint)settings->GetMailOptions());
+				}
+			if ( settings->InboxSynchronisationLimit() != 0 )
+				{
+				INFO_PRINTF2(_L("  InboxSynchronisationLimit    : %x"), (TUint)settings->InboxSynchronisationLimit());
+				}
+			if ( settings->MailboxSynchronisationLimit() != 0 )
+				{
+				INFO_PRINTF2(_L("  MailboxSynchronisationLimit  : %x"), (TUint)settings->MailboxSynchronisationLimit());
+				}
+			}
+		CleanupStack::PopAndDestroy(settings);
+		}
+
+	CleanupStack::PopAndDestroy(store);
+	}
+
+void CTestMessBase::PrintStoreSmsL(CMsvEntry& aEntry)
+	{
+	TMsvEntry	entry=aEntry.Entry();
+	CMsvStore*	store=aEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+
+	TPtrC	ptrTemp;
+	if ( entry.iType == KUidMsvServiceEntry )
+		{
+		CSmsSettings*	settings = CSmsSettings::NewL();
+		CleanupStack::PushL(settings);
+
+#ifdef __MESSAGING_API_V2__
+		CSmsAccount*		smsAccount = CSmsAccount::NewLC();
+		TRAPD(err, smsAccount->LoadSettingsL(*settings));
+		CleanupStack::PopAndDestroy(smsAccount);
+#else
+		TRAPD(err, settings->RestoreL(*store));
+#endif
+		if ( err == KErrNone )
+			{
+			TSmsDelivery	delivery(settings->Delivery());
+			INFO_PRINTF2(_L("  Delivery                     : %d"), delivery);
+			CSmsSettings::TSmsReportHandling	reportHandling(settings->StatusReportHandling());
+			INFO_PRINTF2(_L("  StatusReportHandling         : %d"), reportHandling);
+			CSmsSettings::TSmsReportHandling	specialMsgHandling(settings->SpecialMessageHandling());
+			INFO_PRINTF2(_L("  SpecialMessageHandling       : %d"), specialMsgHandling);
+			INFO_PRINTF2(_L("  ReplyQuoted                  : %d"), settings->ReplyQuoted());
+#ifdef __MESSAGING_API_V2__
+			const TInt	numSCAddr = settings->ServiceCenterCount();
+#else
+			const TInt	numSCAddr = settings->NumSCAddresses();
+#endif
+			for( TInt index=0;index<numSCAddr;index++ )
+				{
+#ifdef __MESSAGING_API_V2__
+				CSmsServiceCenter&	scAddr = settings->GetServiceCenter(index);
+#else
+				CSmsNumber&			scAddr = settings->SCAddress(index);
+#endif
+				ptrTemp.Set(scAddr.Name());
+				INFO_PRINTF2(_L("  SC Name                      : %S"), &ptrTemp);
+				ptrTemp.Set(scAddr.Address());
+				INFO_PRINTF2(_L("  SC Address                   : %S"), &ptrTemp);
+				}
+			CSmsSettings::TSmsSettingsCommDbAction	commDbAction(settings->SmsBearerAction());
+			INFO_PRINTF2(_L("  SmsBearerAction              : %d"), commDbAction);
+
+			CSmsSettings::TMobileSmsBearer	smsBearer(settings->SmsBearer());
+			INFO_PRINTF2(_L("  SmsBearer                    : %d"), smsBearer);
+			}
+		CleanupStack::PopAndDestroy(settings);
+		}
+
+	CleanupStack::PopAndDestroy(store);
+	}
+
+void CTestMessBase::IssueTimerRequest()
+	{
+	if (iMessageTimer!= NULL)
+		{
+		iMessageTimer->IssueRequest();
+		}
+	}
+
+void CTestMessBase::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny*, TAny*)
+/**
+ Handler for the Session Event
+ @param aEvent - TMsvSessionEvent object
+ @param aArg1 - TAny object pointer, used to store the argument for the event
+ @leave - System wide error codes
+*/
+	{
+	TBool	printSelection=EFalse;
+
+	switch (aEvent)
+		{
+	case EMsvEntriesCreated:
+		INFO_PRINTF1(_L("EMsvEntriesCreated"));
+		printSelection=ETrue;
+		break;
+	case EMsvEntriesChanged:
+		INFO_PRINTF1(_L("EMsvEntriesChanged"));
+		printSelection=ETrue;
+		break;
+	case EMsvEntriesDeleted:
+		INFO_PRINTF1(_L("EMsvEntriesDeleted"));
+		break;
+	case EMsvEntriesMoved:
+		INFO_PRINTF1(_L("EMsvEntriesMoved"));
+		printSelection=ETrue;
+		break;
+	case EMsvMtmGroupInstalled:
+		INFO_PRINTF1(_L("EMsvMtmGroupInstalled"));
+		break;
+	case EMsvMtmGroupDeInstalled:
+		INFO_PRINTF1(_L("EMsvMtmGroupDeInstalled"));
+		break;
+	case EMsvGeneralError:
+		INFO_PRINTF1(_L("EMsvGeneralError"));
+		break;
+	case EMsvCloseSession:
+		INFO_PRINTF1(_L("EMsvCloseSession"));
+		break;
+	case EMsvServerReady:
+		INFO_PRINTF1(_L("EMsvServerReady"));
+		break;
+	case EMsvServerFailedToStart:
+		INFO_PRINTF1(_L("EMsvServerFailedToStart"));
+		break;
+	case EMsvCorruptedIndexRebuilt:
+		INFO_PRINTF1(_L("EMsvCorruptedIndexRebuilt"));
+		break;
+	case EMsvServerTerminated:
+		INFO_PRINTF1(_L("EMsvServerTerminated"));
+		break;
+	case EMsvMediaChanged:
+		INFO_PRINTF1(_L("EMsvMediaChanged"));
+		break;
+	case EMsvMediaUnavailable:
+		INFO_PRINTF1(_L("EMsvMediaUnavailable"));
+		break;
+	case EMsvMediaAvailable:
+		INFO_PRINTF1(_L("EMsvMediaAvailable"));
+		break;
+	case EMsvMediaIncorrect:
+		INFO_PRINTF1(_L("EMsvMediaIncorrect"));
+		break;
+	case EMsvCorruptedIndexRebuilding:
+		INFO_PRINTF1(_L("EMsvCorruptedIndexRebuilding"));
+		break;
+	default:
+		INFO_PRINTF2(_L("EMsv Unknown event:%d"), aEvent);
+		break;
+	}
+
+	if ( printSelection )
+		{
+		CMsvEntrySelection*	selection=STATIC_CAST(CMsvEntrySelection*, aArg1);
+		CMsvEntry*			entry=NULL;
+		for ( int i=0; i<selection->Count(); )
+			{
+			entry=iSession->GetEntryL(selection->At(i++));
+			CleanupStack::PushL(entry);
+			PrintEntryL(*entry);
+			CleanupStack::PopAndDestroy(entry);
+			}
+		}
+	}
+
+
+void CTestMessBase::PrepareSmsHeaderFromIniFileL(CSmsHeader& aSmsHeader)
+	{
+	// Starts the Bitmap server
+	FbsStartup();
+	// start the server
+	RFbsSession::Connect();
+
+	// Add the Fromating required for EMS if required
+	TInt	emsElements=0;
+	if ( !GetIntFromConfig(ConfigSection(), KElements, emsElements) )
+		{
+		ERR_PRINTF1(_L("Elements not set"));
+		SetTestStepResult(EFail);
+		}
+
+// Macro usage for CDMA mtm
+#if (defined CDMA_API_ENABLED)
+	TMsvMessageSms&	message=aSmsHeader.SmsMessage();
+#else
+	CSmsMessage&	message=aSmsHeader.Message(); 
+#endif
+
+	TBuf<KMaxTestExecuteCommandLength>	tempStore;
+	for ( TInt element=0; element<emsElements && TestStepResult()==EPass;)
+		{
+		++element;
+		INFO_PRINTF2(_L("==== PROCESSING ELEMENT %d ===="), element);
+		//	Start position
+		tempStore.Format(KStartPosition, element);
+		TInt	startPosition=KDefaultStartPos;
+		if ( GetIntFromConfig(ConfigSection(), tempStore, startPosition) )
+			{
+			INFO_PRINTF2(_L("Start position %d"), startPosition);
+			}
+
+		//	File
+		tempStore.Format(KFile, element);
+		TPtrC	file;
+		TParse	fileName;
+		TBool	hasFile=GetStringFromConfig(ConfigSection(), tempStore, file);
+		if ( hasFile )
+			{
+			INFO_PRINTF2(_L("File %S"), &file);
+			fileName.Set(file,NULL,NULL);
+			}
+
+		tempStore.Format(KType, element);
+		TPtrC	type;
+		if ( GetStringFromConfig(ConfigSection(), tempStore, type) )
+			{
+			if ( type.Compare(KTypeFormat) == 0 )
+				{
+				//	=== Process text formating Information Element ===
+				CEmsFormatIE*	newElement=CEmsFormatIE::NewL();
+				CleanupStack::PushL(newElement);
+				newElement->SetStartPosition(startPosition);
+
+				TInt			intTemp;
+				TBool			boolTemp;
+				TPtrC			alignment;
+				TPtrC			fontSize;
+
+				// Set the Format length and other information
+				tempStore.Format(KFormatLength, element);
+				if ( GetIntFromConfig(ConfigSection(), tempStore, intTemp) )
+					{
+					INFO_PRINTF2(_L("Format Length %d"), intTemp);
+					newElement->SetFormatLength(intTemp);
+					}
+				tempStore.Format(KBold, element);
+				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )
+					{
+					INFO_PRINTF2(_L("Bold %d"), boolTemp);
+					newElement->SetBold(boolTemp);
+					}
+				tempStore.Format(KItalic, element);
+				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )
+					{
+					INFO_PRINTF2(_L("Italic %d"), boolTemp);
+				    newElement->SetItalic(boolTemp);
+					}
+				tempStore.Format(KUnderline, element);
+				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )
+					{
+					INFO_PRINTF2(_L("Underline %d"), boolTemp);
+					newElement->SetUnderline(boolTemp);
+					}
+				tempStore.Format(KStrikethrough, element);
+				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )
+					{
+					INFO_PRINTF2(_L("Strikethrough %d"), boolTemp);
+					newElement->SetStrikethrough(boolTemp);
+					}
+				tempStore.Format(KAlignment,element);
+				if(GetStringFromConfig(ConfigSection(),tempStore,alignment))
+					{
+					SetAlignmentFormat(*newElement, alignment);
+					}
+				
+				tempStore.Format(KFontSize,element);
+				if(GetStringFromConfig(ConfigSection(),tempStore,fontSize))
+					{
+					//
+					SetFontSizeFormat(*newElement, fontSize);
+					}
+			    message.AddEMSInformationElementL(*newElement); 
+				CleanupStack::PopAndDestroy(newElement);
+				}
+			else if ( type.Compare(KTypeSound) == 0 )
+				{
+				//	=== Process sound Information Element ===
+				if ( hasFile )
+					{
+					HBufC8*			buffFile=CopyToBuf8LC(fileName.FullName());
+					CEmsSoundIE*	newElement=CEmsSoundIE::NewL(buffFile->Des());
+					CleanupStack::PushL(newElement);
+					newElement->SetStartPosition(startPosition); 
+				    message.AddEMSInformationElementL(*newElement); 
+					CleanupStack::PopAndDestroy(2, buffFile);
+					}
+				else
+					{
+					ERR_PRINTF1(_L("No Sound file name"));
+					SetTestStepResult(EFail);
+					}
+				}
+			else if ( type.Compare(KTypePreDefSound) == 0 )
+				{
+				//	=== Process predefined sound Information Element ===
+				TPtrC	preDefSound;
+				tempStore.Format(KEmsPreDef, element);
+				if ( !GetStringFromConfig(ConfigSection(),tempStore, preDefSound))
+					{
+					ERR_PRINTF1(_L("Predefined sound not present"));
+					SetTestStepResult(EFail);
+					}
+				else
+					{
+					INFO_PRINTF2(_L("Predefined sound %S"), &preDefSound);
+					CEmsPreDefSoundIE*	newElement=NewPreDefSoundL(preDefSound);
+
+					if ( newElement != NULL )
+						{
+						//Assign the predef animation element to newElement
+						CleanupStack::PushL(newElement);
+						newElement->SetStartPosition(startPosition);
+					    message.AddEMSInformationElementL(*newElement); 
+						CleanupStack::PopAndDestroy(newElement);
+						}
+					else
+						{
+						ERR_PRINTF1(_L("Unable to create predefined sound"));
+						SetTestStepResult(EFail);
+						}
+					}
+				}
+			else if ( type.Compare(KTypeAnimation) == 0 )
+				{
+				//	=== Process animation Information Element ===
+				if ( hasFile )
+					{
+					TPtrC	objectSize;
+
+					tempStore.Format(KObjectSize, element);
+					if ( !GetStringFromConfig(ConfigSection(),tempStore,objectSize) )
+						{
+						ERR_PRINTF1(_L("No size provided"));
+						SetTestStepResult(EFail);
+						}
+					else
+						{
+						CFbsBitmap*	bmp=NewBitmapL(fileName, objectSize);
+						if ( bmp == NULL )
+							{
+							ERR_PRINTF1(_L("Failed to Load Animation File. Error %d"));
+							SetTestStepResult(EFail);
+							}
+						else
+							{
+							CleanupStack::PushL(bmp);
+							CEmsAnimationIE*	newElement=CEmsAnimationIE::NewL(*bmp);
+							CleanupStack::PushL(newElement);
+							newElement->SetStartPosition(startPosition);
+						    message.AddEMSInformationElementL(*newElement); 
+							CleanupStack::PopAndDestroy(2, bmp);
+							}
+						}
+					}
+				else
+					{
+					ERR_PRINTF1(_L("No Animation file name"));
+					SetTestStepResult(EFail);
+					}
+				}
+			else if ( type.Compare(KTypePreDefAnimation) == 0 )
+				{
+				//	=== Process predefined animation Information Element ===
+				TPtrC	preDefAnim;
+				tempStore.Format(KEmsPreDef, element);
+				if ( !GetStringFromConfig(ConfigSection(),tempStore, preDefAnim) )
+					{
+					ERR_PRINTF1(_L("Predefined animations not present"));
+					SetTestStepResult(EFail);
+					}
+				else
+					{
+					INFO_PRINTF2(_L("Predefined animation %S"), &preDefAnim);
+					CEmsPreDefAnimationIE*	newElement=NewPreDefAnimationL(preDefAnim);
+
+					if ( newElement != NULL )
+						{
+						//Assign the predef animation element to newElement
+						CleanupStack::PushL(newElement);
+						newElement->SetStartPosition(startPosition);
+					    message.AddEMSInformationElementL(*newElement); 
+						CleanupStack::PopAndDestroy(newElement);
+						}
+					else
+						{
+						ERR_PRINTF1(_L("Unable to create predefined animation"));
+						SetTestStepResult(EFail);
+						}
+					}
+				}
+			else if ( type.Compare(KTypePicture) == 0 )
+				{
+				//	=== Process picture Information Element ===
+				if ( hasFile )
+					{
+					TPtrC	objectSize;
+
+					tempStore.Format(KObjectSize, element);
+					if ( !GetStringFromConfig(ConfigSection(),tempStore,objectSize) )
+						{
+						ERR_PRINTF1(_L("No size provided"));
+						SetTestStepResult(EFail);
+						}
+					else
+						{
+						CFbsBitmap*	bmp=NewBitmapL(fileName, objectSize);
+						if ( bmp == NULL )
+							{
+							ERR_PRINTF1(_L("Failed to Load Animation File. Error %d"));
+							SetTestStepResult(EFail);
+							}
+						else
+							{
+							CleanupStack::PushL(bmp);
+							CEmsPictureIE*	newElement=CEmsPictureIE::NewL(*bmp);
+							CleanupStack::PushL(newElement);
+							newElement->SetStartPosition(startPosition);
+						    message.AddEMSInformationElementL(*newElement); 
+							CleanupStack::PopAndDestroy(2, bmp);
+							}
+						}
+					}
+				else
+					{
+					ERR_PRINTF1(_L("No Picture file name"));
+					SetTestStepResult(EFail);
+					}
+				}
+			else if ( type.Compare(KTypeUserPrompt) == 0 )
+				{
+				//	=== Process user prompt Information Element ===
+				CEmsUserPrompt*	newElement=CEmsUserPrompt::NewL(2);
+				CleanupStack::PushL(newElement);
+				newElement->SetStartPosition(startPosition);
+			    message.AddEMSInformationElementL(*newElement); 
+				CleanupStack::PopAndDestroy(newElement);
+				}
+			else
+				{
+				ERR_PRINTF2(_L("Unknown element type %S"), &type);
+				SetTestStepResult(EFail);
+				}
+			}
+		else
+			{
+			ERR_PRINTF1(_L("No type given"));
+			SetTestStepResult(EFail);
+			}
+		}
+
+	RFbsSession::Disconnect(); 
+	}
+
+/**
+ This function reads the schedule time from ini file
+ @return - returns the schedule time read from the ini file
+*/
+TTimeIntervalMinutes CTestMessBase::ReadScheduleTime()
+	{
+	// Read  the schedule time from ini file. Add this schedule time to current time.
+	// This time will be set as the scheduled time for sending the SMS message from task scheduler
+	// By default schedule time will be 1 min
+	TInt	scheduled=0;
+	GetIntFromConfig(ConfigSection(), KScheduled, scheduled);
+	INFO_PRINTF2(_L("Scheduled Time in minutes is %d"), scheduled);
+	return TTimeIntervalMinutes(scheduled);
+	}
+
+void CTestMessBase::SetAlignmentFormat(CEmsFormatIE& aEmsFormatIE, const TDesC& aAlignment)
+	{
+	//Sets the alignment to the text
+	INFO_PRINTF2(_L("Alignment %S"), &aAlignment);
+	if( aAlignment.Compare(KLeftAlign)== 0 )
+		{
+		aEmsFormatIE.SetAlignment(CEmsFormatIE::ELeft);
+		}
+	else if( aAlignment.Compare(KRightAlign)== 0 )
+		{
+		aEmsFormatIE.SetAlignment(CEmsFormatIE::ERight);
+		}
+	else if( aAlignment.Compare(KCenterAlign)== 0 )
+		{
+		aEmsFormatIE.SetAlignment(CEmsFormatIE::ECenter);
+		}
+	else if( aAlignment.Compare(KLangDepend)== 0 )
+		{
+		aEmsFormatIE.SetAlignment(CEmsFormatIE::ELangDepend);
+		}
+	else
+		{
+		ERR_PRINTF1(_L("Illegal alignment value"));
+		SetTestStepResult(EFail);
+		}
+	}
+
+void CTestMessBase::SetFontSizeFormat(CEmsFormatIE& aEmsFormatIE, const TDesC& aFontSize)
+	{
+	//Sets the specified font to the text 
+	INFO_PRINTF2(_L("FontSize %S"), &aFontSize);
+	if( aFontSize.Compare(KNormal)== 0 )
+		{
+		aEmsFormatIE.SetFontSize(CEmsFormatIE::ENormal);
+		}
+	else if( aFontSize.Compare(KLarge)== 0 )
+		{
+		aEmsFormatIE.SetFontSize(CEmsFormatIE::ELarge);
+		}
+	else if( aFontSize.Compare(KSmall)== 0 )
+		{
+		aEmsFormatIE.SetFontSize(CEmsFormatIE::ESmall);
+		}
+	else if( aFontSize.Compare(KReserved)== 0 )
+		{
+		aEmsFormatIE.SetFontSize(CEmsFormatIE::EReserved);
+		}
+	else
+		{
+		ERR_PRINTF1(_L("Illegal fonst size value"));
+		SetTestStepResult(EFail);
+		}
+	}
+
+CEmsPreDefAnimationIE* CTestMessBase::NewPreDefAnimationL(const TDesC& aPreDefType) 
+//
+// Attaches the required predef animation. 
+// Arguments - aString - holds the TAnim type to be attached 
+// Return Value - Returns a Pointer of CEmsPreDefAnimationIE 
+//
+	{
+	//Initialize emsPreDef to NULL
+	CEmsPreDefAnimationIE::TAnimType	animType=CEmsPreDefAnimationIE::EFlirty;
+	TBool								validType=ETrue;
+
+	//Set a value for emsPreDef 
+	if ( aPreDefType.Compare(KEmsAnimTypeFlirty) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EFlirty;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeGlad) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EGlad;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeSceptic) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::ESceptic;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeSad) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::ESad;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeWow) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EWow;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeCrying) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::ECrying;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeWinking) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EWinking;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeLaughing) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::ELaughing;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeIndifferent) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EIndifferent;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeKissing) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EKissing;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeConfused) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EConfused;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeTongueOut) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::ETongueOut;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeAngry) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EAngry;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeGlasses) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EGlasses;
+		}
+	else if ( aPreDefType.Compare(KEmsAnimTypeDevil) == 0 )
+		{
+		animType = CEmsPreDefAnimationIE::EDevil;
+		}
+	else
+		{
+		validType=EFalse;
+		}
+
+	CEmsPreDefAnimationIE*	emsPreDef=NULL;
+	if ( validType )
+		{
+		emsPreDef=CEmsPreDefAnimationIE::NewL(animType);
+		}
+
+	return emsPreDef;
+	}
+
+CEmsPreDefSoundIE* CTestMessBase::NewPreDefSoundL(const TDesC& aPreDefType) 
+//
+// Attaches the required predef animation. 
+// Arguments - aString - holds the TAnim type to be attached 
+// Return Value - Returns a Pointer of CEmsPreDefAnimationIE 
+//
+	{
+	//Initialize emsPreDef to NULL
+	CEmsPreDefSoundIE::TPredefinedSound	soundType=CEmsPreDefSoundIE::EChimesHigh;
+	TBool								validType=ETrue;
+
+	//Set a value for emsPreDef 
+	if ( aPreDefType.Compare(KEmsSoundTypeChimesHigh) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EChimesHigh;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeChimesLow) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EChimesLow;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeDing) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EDing;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeTaDa) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::ETaDa;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeNotify) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::ENotify;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeDrum) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EDrum;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeClaps) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EClaps;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeFanFar) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EFanFar;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeChordHigh) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EChordHigh;
+		}
+	else if ( aPreDefType.Compare(KEmsSoundTypeChordLow) == 0 )
+		{
+		soundType = CEmsPreDefSoundIE::EChordLow;
+		}
+	else
+		{
+		validType=EFalse;
+		}
+
+	CEmsPreDefSoundIE*	emsPreDef=NULL;
+	if ( validType )
+		{
+		emsPreDef=CEmsPreDefSoundIE::NewL(soundType);
+		}
+
+	return emsPreDef;
+	}
+
+CFbsBitmap* CTestMessBase::NewBitmapL(const TParse& aFileName, const TDesC& aObjectSize)
+	{
+	TInt	bitmapType=KSmallObject;
+	TBool	validType=ETrue;
+	if( aObjectSize.Compare(KSmall) == 0 )
+		{
+		bitmapType=KSmallObject;
+		}
+	else if ( aObjectSize.Compare(KLarge) == 0 )
+		{
+		bitmapType=KLargeObject;
+		}
+	else if ( aObjectSize.Compare(KVariable) == 0 )
+		{
+		bitmapType=KVariableObject;
+		}
+	else
+		{
+		ERR_PRINTF2(_L("Invalid bitmap type %S"), &aObjectSize);
+		validType=EFalse;
+		}
+
+	CFbsBitmap*	bmp = NULL;
+	if ( validType )
+		{
+		bmp = new (ELeave) CFbsBitmap();
+
+		TInt	error = bmp->Load(aFileName.FullName(), bitmapType, EFalse);
+		INFO_PRINTF2(_L("Bimap load %d"), error);
+		if ( error != KErrNone)
+			{
+			delete bmp;
+			bmp=NULL;
+			}
+		}
+
+	return bmp;
+	}
+