1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This contains CTestCase which is the base class for all the TestCase DLLs

    15 // 

    16 //

    17 

    18 #include "TestMessBase.h"

    19 #include "TestMessProcessor.h"

    20 #include "TestMessTimer.h"

    21 #include "TestMessPrintEntryUtil.h"

    22 

    23 // EPOC includes

    24 #include <smtpset.h>

    25 #include <pop3set.h>

    26 #include <imapset.h>

    27 #include <txtrich.h>

    28 #include <f32file.h>

    29 #include <msvids.h>

    30 #include <fbs.h>

    31 #include <emsuserpromptie.h>

    32 #ifdef __MESSAGING_API_V2__

    33 #include <smut.h>

    34 #include <miutset.h>

    35 #include <cemailaccounts.h>

    36 #include <csmsaccount.h>

    37 #endif

    38 /**

    39  * @name Constant Literals used.

    40  */

    41 /*@{*/

    42 _LIT(KDepth,					"depth");

    43 _LIT(KFolder,					"folder%d");

    44 

    45 // Default value for depth of the count

    46 #define KDefaultDepthCount		1

    47 

    48 // Default value for depth of the count

    49 #define KDefaultDepthCount		1

    50 

    51 _LIT(KDefault,					"default");

    52 

    53 _LIT(KScheduled,				"scheduled");

    54 _LIT(KProgress,					"progress");

    55 

    56 //_LIT(KIap,						"iap");

    57 //_LIT(KIapName,					"iapname");

    58 

    59 _LIT(KElements,					"elements");

    60 _LIT(KStartPosition,			"StartPosition%d");

    61 _LIT(KFile,						"File%d");

    62 _LIT(KType,						"Type%d");

    63 _LIT(KTypeFormat,				"Format");

    64 _LIT(KTypeSound,				"Sound");

    65 _LIT(KTypePreDefSound,			"PreDefSound");

    66 _LIT(KTypeAnimation,			"Animation");

    67 _LIT(KTypePreDefAnimation,		"PreDefAnimation");

    68 _LIT(KTypePicture,				"Picture");

    69 _LIT(KTypeUserPrompt,			"UserPrompt");

    70 _LIT(KFormatLength,				"FormatLength%d");

    71 _LIT(KBold,						"Bold%d");

    72 _LIT(KItalic,					"Italic%d");

    73 _LIT(KUnderline,				"Underline%d");

    74 _LIT(KStrikethrough,			"Strikethrough%d");

    75 _LIT(KAlignment,				"Alignment%d");

    76 _LIT(KFontSize,					"FontSize%d");

    77 

    78 _LIT(KLeftAlign,				"LeftAlign");

    79 _LIT(KRightAlign,				"RightAlign");

    80 _LIT(KCenterAlign,				"CenterAlign");

    81 _LIT(KLangDepend,				"LangDepend");

    82 

    83 _LIT(KNormal,					"Normal");

    84 _LIT(KLarge,					"Large");

    85 _LIT(KSmall,					"Small");

    86 _LIT(KVariable,					"Variable");

    87 _LIT(KReserved,					"Reserved");

    88 

    89 _LIT(KEmsPreDef,				"emspredef%d");

    90 

    91 _LIT(KEmsAnimTypeFlirty,		"a0");

    92 _LIT(KEmsAnimTypeGlad,			"a1");

    93 _LIT(KEmsAnimTypeSceptic,		"a2");

    94 _LIT(KEmsAnimTypeSad,			"a3");

    95 _LIT(KEmsAnimTypeWow,			"a4");

    96 _LIT(KEmsAnimTypeCrying,		"a5");

    97 _LIT(KEmsAnimTypeWinking,		"a6");

    98 _LIT(KEmsAnimTypeLaughing,		"a7");

    99 _LIT(KEmsAnimTypeIndifferent,	"a8");

   100 _LIT(KEmsAnimTypeKissing,		"a9");

   101 _LIT(KEmsAnimTypeConfused,		"a10");

   102 _LIT(KEmsAnimTypeTongueOut,		"a11");

   103 _LIT(KEmsAnimTypeAngry,			"a12");

   104 _LIT(KEmsAnimTypeGlasses,		"a13");

   105 _LIT(KEmsAnimTypeDevil,			"a14");

   106 

   107 _LIT(KEmsSoundTypeChimesHigh,	"s0");

   108 _LIT(KEmsSoundTypeChimesLow,	"s1");

   109 _LIT(KEmsSoundTypeDing,			"s2");

   110 _LIT(KEmsSoundTypeTaDa,			"s3");

   111 _LIT(KEmsSoundTypeNotify,		"s4");

   112 _LIT(KEmsSoundTypeDrum,			"s5");

   113 _LIT(KEmsSoundTypeClaps,		"s6");

   114 _LIT(KEmsSoundTypeFanFar,		"s7");

   115 _LIT(KEmsSoundTypeChordHigh,	"s8");

   116 _LIT(KEmsSoundTypeChordLow,		"s9");

   117 

   118 /*

   119 _LIT(KBioIAP,					"IAP");

   120 _LIT(KBioEmailNotification,		"EmailNotification");

   121 _LIT(KBioBusinessCard,			"BusinessCard");

   122 _LIT(KBioWAPAccessPoint,		"WAPAccessPoint");

   123 _LIT(KBioVCalendar,				"VCalendar");

   124 _LIT(KBioVCard,					"VCard");

   125 _LIT(KBioRingingTones,			"RingingTones");

   126 _LIT(KBioOperatorLogo,			"OperatorLogo");

   127 _LIT(KBioWPRV,					"WPRV");

   128 _LIT(KBioCLILogo,				"CLILogo");

   129 */

   130 _LIT(KObjectSize,				"ObjectSize%d");

   131 _LIT(KBody,						"body");

   132 /*@}*/

   133 

   134 const TInt KSmallObject		= 0;

   135 const TInt KLargeObject		= 1;

   136 const TInt KVariableObject	= 2;

   137 

   138 const TInt KDefaultStartPos	= 1;

   139 

   140 /**

   141  * Constructor.

   142  * @return - None

   143  * 

   144 */	

   145 CTestMessBase::CTestMessBase(TBool aSetDirectory)

   146 :	CTestStepSmokeTest()

   147 ,	iSession(NULL)

   148 ,	iMessageProcessor(NULL)

   149 ,   iParaFormatLayer(NULL)

   150 ,   iCharFormatLayer(NULL)

   151 ,   iBodyText(NULL)

   152 ,	iBodyAvailable(EFalse)

   153 ,	iSetDirectory(aSetDirectory)

   154 ,	iMessageTimer(NULL)

   155 ,	iSchedular(NULL)

   156 ,	iEntry(NULL)

   157 ,	iOrder(KMsvGroupByType|KMsvGroupByStandardFolders, EMsvSortById, ETrue)

   158 	{

   159 	}

   160 

   161 CTestMessBase::~CTestMessBase()

   162 	{

   163 	delete iEntry;

   164 	iEntry=NULL;

   165 	delete iMessageTimer;

   166 	iMessageTimer=NULL;

   167 	delete iMessageProcessor;

   168 	iMessageProcessor=NULL;

   169 	delete iSession;

   170 	iSession=NULL;

   171 	delete iSchedular;

   172 	iSchedular=NULL;

   173 	delete iBodyText;

   174 	iBodyText=NULL;

   175 	delete iCharFormatLayer;

   176 	iCharFormatLayer=NULL;

   177 	delete iParaFormatLayer;

   178 	iParaFormatLayer=NULL;

   179 	}

   180 

   181 enum TVerdict CTestMessBase::doTestStepPreambleL()

   182 	{

   183 	TVerdict	ret=CTestStepSmokeTest::doTestStepPreambleL();

   184 

   185 	// Printing to the console and log file

   186 	const TDesC&	stepName=TestStepName();

   187 	INFO_PRINTF2(_L("%S"), &stepName);

   188 

   189 	iSchedular=new (ELeave) CActiveScheduler();

   190 	CActiveScheduler::Install(iSchedular);

   191 	iSession=CMsvSession::OpenSyncL(*this);

   192 

   193 	//	Get progress

   194 	TInt	progress=0;

   195 	TBool	hasProgress=GetIntFromConfig(ConfigSection(), KProgress, progress);

   196 	if ( !hasProgress )

   197 		{

   198 		hasProgress=GetIntFromConfig(KDefault, KProgress, progress);

   199 		}

   200 

   201 	iMessageProcessor=CTestMessProcessor::NewL(*this, *iSession);

   202 	if ( hasProgress )

   203 		{

   204 		iMessageTimer=CTestMessTimer::NewL(progress*KOneSecond, *iMessageProcessor);

   205 		}

   206 

   207 	if ( iSetDirectory )

   208 		{

   209 		TInt	depth=KDefaultDepthCount;

   210 		TBool	returnValue=GetIntFromConfig(ConfigSection(), KDepth, depth);

   211 		if ( !returnValue )

   212 			{

   213 			depth=KDefaultDepthCount;

   214 			}

   215 		INFO_PRINTF2(_L("Depth = %d"), depth);

   216 

   217 		//	Searce for the entry

   218 		TRAPD(error,SetEntryL(KMsvRootIndexEntryId));

   219 		if( error != KErrNone)

   220 			{

   221 			INFO_PRINTF2(_L("Set Entry failed, Error %D"),error);

   222 			SetTestStepError(error);

   223 			ret=EFail;

   224 			}

   225 		else

   226 			{

   227 

   228 			TBuf<KMaxTestExecuteCommandLength>	tempStore;

   229 			TBool								found=ETrue;

   230 			for (TInt entry=0; entry<depth && found;)

   231 				{

   232 				TPtrC	subject;

   233 				tempStore.Format(KFolder(), ++entry);

   234 				returnValue =GetStringFromConfig(ConfigSection(), tempStore, subject);

   235 				if ( !returnValue )

   236 					{

   237 					INFO_PRINTF1(_L("Null Folder"));

   238 					}

   239 				INFO_PRINTF2(_L("Folder = %S"), &subject);

   240 

   241 				CMsvEntrySelection*	selection=EntryL().ChildrenL();

   242 				CleanupStack::PushL(selection);

   243 				TInt				count=selection->Count();

   244 		

   245 				found=EFalse;

   246 				for (TInt i=count; i>0 && !found; )

   247 					{

   248 					TMsvId	childId=selection->At(--i);

   249 

   250 					SetEntryL(childId);

   251 					INFO_PRINTF2(_L("Entry Detail : %S"), &(EntryL().Entry().iDetails));

   252 					INFO_PRINTF2(_L("Entry Description: %S"), &(EntryL().Entry().iDescription));

   253 					if ( subject.Compare(EntryL().Entry().iDetails) == 0 ||

   254 						 subject.Compare(EntryL().Entry().iDescription) == 0 )

   255 						{

   256 						found=ETrue;

   257 						}

   258 					}

   259 				CleanupStack::PopAndDestroy(selection);

   260 				}

   261 

   262 			if ( !found )

   263 				{

   264 				ERR_PRINTF1(_L("Folder not found"));

   265 				ret=EFail;

   266 				}

   267 			}

   268 		}

   269 	if (TestStepResult() == EPass)

   270 		{

   271 		//Get body(file path) from ini file and read respective file. Store it into CRichText format.

   272 		iParaFormatLayer=CParaFormatLayer::NewL();

   273 		iCharFormatLayer=CCharFormatLayer::NewL(); 

   274 		iBodyText=CRichText::NewL(iParaFormatLayer, iCharFormatLayer);

   275 		iBodyAvailable=EFalse;

   276 	

   277 		TPtrC	body;

   278 		if(GetStringFromConfig(ConfigSection(), KBody, body))

   279 			{

   280 			INFO_PRINTF2(_L("Body = %S"), &body);

   281 			iBodyAvailable=ETrue;

   282 			}

   283 		else

   284 			{

   285 			INFO_PRINTF1(_L("No Body"));

   286 			}

   287 

   288 		if ( iBodyAvailable )

   289 			{

   290 			// open the file

   291 			RFile	file;

   292 	

   293 			TInt anError = file.Open(iSession->FileSession(), body, EFileShareAny);

   294 			if(anError == KErrNone)

   295 				{

   296 				TBool		reading=ETrue;

   297 				TInt		pos=0;

   298 				TBuf8<1>	charIn;

   299 				while (reading)

   300 					{

   301 					file.Read(charIn, 1);

   302 					if(charIn.Length())

   303 						{

   304 						switch ( charIn[0] )

   305 							{

   306 						case '\r':

   307 							iBodyText->InsertL(pos++, CEditableText::ELineBreak);

   308 						case '\n':

   309 							break;

   310 						default:

   311 							iBodyText->InsertL(pos++, TChar(charIn[0]));

   312 							}

   313 						}

   314 					else

   315 						{

   316 						reading = EFalse;	// stop at the end of the file

   317 						}

   318 					}

   319 				iBodyAvailable=ETrue;

   320 				file.Close();

   321 				}

   322 			else

   323 			{

   324 			INFO_PRINTF2(_L("Cannot open file = %S"), &body);

   325 			iBodyAvailable=EFalse;

   326 			}

   327 		}//End of read file.

   328 	}

   329 

   330 	SetTestStepResult(ret);

   331 	return ret;

   332 	}

   333 

   334 enum TVerdict CTestMessBase::doTestStepPostambleL()

   335 	{

   336 	delete iEntry;

   337 	iEntry=NULL;

   338 	delete iMessageTimer;

   339 	iMessageTimer=NULL;

   340 	delete iMessageProcessor;

   341 	iMessageProcessor=NULL;

   342 	delete iSession;

   343 	iSession=NULL;

   344 	delete iSchedular;

   345 	iSchedular=NULL;

   346 	CActiveScheduler::Install(NULL);

   347 	return CTestStepSmokeTest::doTestStepPostambleL();

   348 	}

   349 

   350 void CTestMessBase::SetEntryL(TMsvId aId)

   351 	{

   352 	delete iEntry;

   353 	iEntry=NULL;

   354 	iEntry=iSession->GetEntryL(aId);

   355 	}

   356 

   357 CMsvEntry& CTestMessBase::EntryL()

   358 	{

   359 	if ( iEntry == NULL )

   360 		{

   361 		User::Leave(KErrGeneral);

   362 		}

   363 

   364 	return *iEntry;

   365 	}

   366 

   367 

   368 HBufC8* CTestMessBase::CopyToBuf8LC(const TDesC& aDesC)

   369 //

   370 // @return - HBufC8*

   371 // Converts TDesC to HBufC8*.

   372 //

   373 	{

   374 	HBufC8*	itemBuff8 = HBufC8::NewLC(aDesC.Length());

   375 	itemBuff8->Des().Copy(aDesC);

   376 

   377 	return itemBuff8;

   378 	}

   379 

   380 HBufC* CTestMessBase::CopyToBufLC(const TDesC8& aDesC)

   381 //

   382 // @return - HBufC8*

   383 // Converts TDesC to HBufC8*.

   384 //

   385 	{

   386 	HBufC*	itemBuff = HBufC::NewLC(aDesC.Length());

   387 	itemBuff->Des().Copy(aDesC);

   388 

   389 	return itemBuff;

   390 	}

   391 

   392 

   393 #ifndef __MESSAGING_API_V2__

   394 void CTestMessBase::SetDefaultServiceL(TUid aMtm, TMsvId aService) const

   395 	{

   396 	// --- Now restore the default services from the root store ---

   397 	CMsvEntry*				rootEntry=iSession->GetEntryL(KMsvRootIndexEntryIdValue);

   398 	CleanupStack::PushL(rootEntry);

   399 	CMsvStore*				store = rootEntry->EditStoreL();

   400 	CleanupStack::PushL(store);

   401 	CMsvDefaultServices*	services = new(ELeave)CMsvDefaultServices;

   402 	CleanupStack::PushL(services);

   403 	services->RestoreL(*store);

   404 

   405 	// --- And now re-set the default service for the MTM to the one given ---

   406 	TMsvDefaultService	defaultService;

   407 	defaultService.iMtm=aMtm;

   408 	defaultService.iService=aService;

   409 	services->ChangeDefaultServiceL(defaultService);

   410 	services->StoreL(*store);

   411 	store->CommitL();

   412 	CleanupStack::PopAndDestroy(3, rootEntry);

   413 	}

   414 

   415 TInt CTestMessBase::DefaultServiceL(TUid aMtm, TMsvId& aService) const

   416 	{

   417 	// --- Now restore the default services from the root store ---

   418 	CMsvEntry*				rootEntry=iSession->GetEntryL(KMsvRootIndexEntryIdValue);

   419 	CleanupStack::PushL(rootEntry);

   420 	CMsvStore*				store=rootEntry->ReadStoreL();

   421 	CleanupStack::PushL(store);

   422 	CMsvDefaultServices*	services=new(ELeave)CMsvDefaultServices;

   423 	CleanupStack::PushL(services);

   424 	services->RestoreL(*store);

   425 

   426 	TInt					ret=services->DefaultService(aMtm, aService);

   427 

   428 	CleanupStack::PopAndDestroy(3, rootEntry);

   429 

   430 	return ret;

   431 	}

   432 #endif

   433 

   434 void CTestMessBase::PrintTreeL(TMsvId aRoot)

   435 	{

   436 	INFO_PRINTF1(_L("PrintTreeL In"));

   437 	CMsvEntry*			entry=iSession->GetEntryL(aRoot);

   438 	CleanupStack::PushL(entry);

   439 	entry->SetSortTypeL(SelectionOrdering());

   440 	CMsvEntrySelection*	selection=entry->ChildrenL();

   441 	CleanupStack::PushL(selection);

   442 

   443 	PrintEntryL(*entry);

   444 	for (TInt i=0; i<selection->Count(); )

   445 		{

   446 		PrintTreeL(selection->At(i++));

   447 		}

   448 

   449 	CleanupStack::PopAndDestroy(2, entry);

   450 	INFO_PRINTF1(_L("PrintTreeL Out"));

   451 	}

   452 

   453 void CTestMessBase::PrintEntryL(CMsvEntry& aEntry)

   454 	{

   455 	TMsvEntry	entry=aEntry.Entry();

   456 

   457 	INFO_PRINTF2(_L("Entry Detail : %S"), &(entry.iDetails));

   458 	INFO_PRINTF2(_L("  Description: %S"), &(entry.iDescription));

   459 	INFO_PRINTF2(_L("  Id         : %x"), entry.Id());

   460 	INFO_PRINTF2(_L("  Parent Id  : %x"), entry.Parent());

   461 	INFO_PRINTF2(_L("  Service Id : %x"), entry.iServiceId);

   462 	if ( entry.iRelatedId != 0 )

   463 		{

   464 		INFO_PRINTF2(_L("  Related Id : %x"), entry.iRelatedId);

   465 		}

   466 	INFO_PRINTF2(_L("  Type       : %x"), entry.iType);

   467 	INFO_PRINTF2(_L("  Mtm        : %x"), entry.iMtm);

   468 

   469 

   470 	if ( entry.iSize != 0 )

   471 		{

   472 		INFO_PRINTF2(_L("  Size       : %x"), entry.iSize);

   473 		}

   474 	if ( entry.iError != 0 )

   475 		{

   476 		INFO_PRINTF2(_L("  Error      : %d"), entry.iError);

   477 		}

   478 	if ( entry.iBioType != 0 )

   479 		{

   480 		INFO_PRINTF2(_L("  BioType    : %x"), entry.iBioType);

   481 		}

   482 	if ( entry.MtmData1() != 0 )

   483 		{

   484 		INFO_PRINTF2(_L("  MtmData1   : %x"), entry.MtmData1());

   485 		}

   486 	if ( entry.MtmData2() != 0 )

   487 		{

   488 		INFO_PRINTF2(_L("  MtmData2   : %x"), entry.MtmData2());

   489 		}

   490 	if ( entry.MtmData3() != 0 )

   491 		{

   492 		INFO_PRINTF2(_L("  MtmData3   : %x"), entry.MtmData3());

   493 		}

   494 	if ( entry.Attachment() != 0 )

   495 		{

   496 		INFO_PRINTF2(_L("  Attachment : %x"), entry.Attachment());

   497 		}

   498 	if ( entry.Complete() != 0 )

   499 		{

   500 		INFO_PRINTF2(_L("  Complete   : %x"), entry.Complete());

   501 		}

   502 	if ( entry.Connected() != 0 )

   503 		{

   504 		INFO_PRINTF2(_L("  Connected  : %x"), entry.Connected());

   505 		}

   506 	if ( entry.Deleted() != 0 )

   507 		{

   508 		INFO_PRINTF2(_L("  Deleted    : %x"), entry.Deleted());

   509 		}

   510 	if ( entry.Failed() != 0 )

   511 		{

   512 		INFO_PRINTF2(_L("  Failed     : %x"), entry.Failed());

   513 		}

   514 	if ( entry.InPreparation() != 0 )

   515 		{

   516 		INFO_PRINTF2(_L("  InPrep     : %x"), entry.InPreparation());

   517 		}

   518 	if ( entry.MultipleRecipients() != 0 )

   519 		{

   520 		INFO_PRINTF2(_L("  MultiRecip : %x"), entry.MultipleRecipients());

   521 		}

   522 	if ( entry.OffPeak() != 0 )

   523 		{

   524 		INFO_PRINTF2(_L("  OffPeak    : %x"), entry.OffPeak());

   525 		}

   526 	if ( entry.Operation() != 0 )

   527 		{

   528 		INFO_PRINTF2(_L("  Operation  : %x"), entry.Operation());

   529 		}

   530 	if ( entry.Owner() != 0 )

   531 		{

   532 		INFO_PRINTF2(_L("  Owner      : %x"), entry.Owner());

   533 		}

   534 	if ( entry.PcSyncCount() != 0 )

   535 		{

   536 		INFO_PRINTF2(_L("  PcSyncCount: %x"), entry.PcSyncCount());

   537 		}

   538 	if ( entry.Priority() != 0 )

   539 		{

   540 		INFO_PRINTF2(_L("  Priority   : %x"), entry.Priority());

   541 		}

   542 	if ( entry.ReadOnly() != 0 )

   543 		{

   544 		INFO_PRINTF2(_L("  ReadOnly   : %x"), entry.ReadOnly());

   545 		}

   546 	if ( entry.Scheduled() != 0 )

   547 		{

   548 		INFO_PRINTF2(_L("  Scheduled  : %x"), entry.Scheduled());

   549 		}

   550 	if ( entry.SendingState() != 0 )

   551 		{

   552 		INFO_PRINTF2(_L("  Send State : %x"), entry.SendingState());

   553 		}

   554 	if ( entry.StandardFolder() != 0 )

   555 		{

   556 		INFO_PRINTF2(_L("  StdFolder  : %x"), entry.StandardFolder());

   557 		}

   558 	if ( entry.Unread() != 0 )

   559 		{

   560 		INFO_PRINTF2(_L("  Unread     : %x"), entry.Unread());

   561 		}

   562 	if ( entry.Visible() != 0 )

   563 		{

   564 		INFO_PRINTF2(_L("  Visible    : %x"), entry.Visible());

   565 		}

   566 

   567 #if (!defined CDMA_API_ENABLED)

   568 	if ( aEntry.HasStoreL() )

   569 		{

   570 		PrintStoreL(aEntry);

   571 		}

   572 #endif

   573 	}

   574 

   575 void CTestMessBase::PrintStoreL(CMsvEntry& aEntry)

   576 	{

   577 	TMsvEntry					entry=aEntry.Entry();

   578 	CTestMessPrintEntryUtil*	printUtil=new (ELeave) CTestMessPrintEntryUtil(*this);

   579 	CleanupStack::PushL(printUtil);

   580 

   581 	printUtil->ProcessEntryL(entry.Id());

   582 	CleanupStack::PopAndDestroy(printUtil);

   583 

   584 	if ( entry.iMtm==KUidMsgTypeSMTP )

   585 		{

   586 		PrintStoreSmtpL(aEntry);

   587 		}

   588 	else if ( entry.iMtm == KUidMsgTypePOP3 )

   589 		{

   590 		PrintStorePop3L(aEntry);

   591 		}

   592 	else if ( entry.iMtm == KUidMsgTypeIMAP4 )

   593 		{

   594 		PrintStoreImap4L(aEntry);

   595 		}

   596 	else if ( entry.iMtm == KUidMsgTypeSMS )

   597 		{

   598 		PrintStoreSmsL(aEntry);

   599 		}

   600 	}

   601 

   602 void CTestMessBase::PrintStoreSmtpL(CMsvEntry& aEntry)

   603 	{

   604 	TMsvEntry	entry=aEntry.Entry();

   605 	CMsvStore*	store=aEntry.ReadStoreL();

   606 	CleanupStack::PushL(store);

   607 

   608 	TPtrC	ptrTemp;

   609 	if ( entry.iType == KUidMsvServiceEntry )

   610 		{

   611 		CImSmtpSettings*	settings = new(ELeave) CImSmtpSettings();

   612 		CleanupStack::PushL(settings);

   613 #ifdef __MESSAGING_API_V2__

   614 		CEmailAccounts*		accounts = CEmailAccounts::NewLC();

   615 		TSmtpAccount smtpAccountId;

   616 		accounts->GetSmtpAccountL(aEntry.EntryId(), smtpAccountId);

   617 		TRAPD(err, accounts->LoadSmtpSettingsL(smtpAccountId, *settings));

   618 		CleanupStack::PopAndDestroy(accounts);

   619 #else

   620 		TRAPD(err, settings->RestoreL(*store));

   621 #endif

   622 		if ( err == KErrNone )

   623 			{

   624 			ptrTemp.Set(settings->ServerAddress());

   625 			INFO_PRINTF2(_L("  ServerAddress                : %S"), &ptrTemp);

   626 #ifndef __MESSAGING_API_V2__

   627 			ptrTemp.Set(settings->UserAddress());

   628 			INFO_PRINTF2(_L("  UserAddress                  : %S"), &ptrTemp);

   629 			INFO_PRINTF2(_L("  Version                      : %x"), (TUint)settings->Version());

   630 #endif

   631 			INFO_PRINTF2(_L("  Port                         : %x"), settings->Port());

   632 			INFO_PRINTF2(_L("  SecureSockets                : %x"), (TUint)settings->SecureSockets());

   633 			ptrTemp.Set(settings->EmailAlias());

   634 			INFO_PRINTF2(_L("  EmailAlias                   : %S"), &ptrTemp);

   635 			ptrTemp.Set(settings->EmailAddress());

   636 			INFO_PRINTF2(_L("  EmailAddress                 : %S"), &ptrTemp);

   637 			ptrTemp.Set(settings->ReplyToAddress());

   638 			INFO_PRINTF2(_L("  ReplyToAddress               : %S"), &ptrTemp);

   639 			ptrTemp.Set(settings->ReceiptAddress());

   640 			INFO_PRINTF2(_L("  ReceiptAddress               : %S"), &ptrTemp);

   641 			if ( settings->RequestReceipts() != 0 )

   642 				{

   643 				INFO_PRINTF2(_L("  RequestReceipts              : %x"), (TUint)settings->RequestReceipts());

   644 				}

   645 			if ( settings->SendCopyToSelf() != 0 )

   646 				{

   647 				INFO_PRINTF2(_L("  SendCopyToSelf               : %x"), (TUint)settings->SendCopyToSelf());

   648 				}

   649 			INFO_PRINTF2(_L("  SendMessageOption            : %x"), (TUint)settings->SendMessageOption());

   650 			}

   651 		CleanupStack::PopAndDestroy(settings);

   652 		}

   653 

   654 	CleanupStack::PopAndDestroy(store);

   655 	}

   656 

   657 void CTestMessBase::PrintStorePop3L(CMsvEntry& aEntry)

   658 	{

   659 	TMsvEntry	entry=aEntry.Entry();

   660 	CMsvStore*	store=aEntry.ReadStoreL();

   661 	CleanupStack::PushL(store);

   662 

   663 	TPtrC	ptrTemp;

   664 	if ( entry.iType == KUidMsvServiceEntry )

   665 		{

   666 		CImPop3Settings*	settings = new(ELeave) CImPop3Settings();

   667 		CleanupStack::PushL(settings);

   668 

   669 #ifdef __MESSAGING_API_V2__

   670 		CEmailAccounts*		accounts = CEmailAccounts::NewLC();

   671 		TPopAccount popAccountId;

   672 		accounts->GetPopAccountL(aEntry.EntryId(), popAccountId);

   673 		TRAPD(err, accounts->LoadPopSettingsL(popAccountId, *settings));

   674 		CleanupStack::PopAndDestroy(accounts);

   675 #else

   676 		TRAPD(err, settings->RestoreL(*store));

   677 #endif

   678 		if ( err == KErrNone )

   679 			{

   680 			ptrTemp.Set(settings->ServerAddress());

   681 			INFO_PRINTF2(_L("  ServerAddress                : %S"), &ptrTemp);

   682 #ifndef __MESSAGING_API_V2__

   683 			ptrTemp.Set(settings->UserAddress());

   684 			INFO_PRINTF2(_L("  UserAddress                  : %S"), &ptrTemp);

   685 			INFO_PRINTF2(_L("  Version                      : %x"), (TUint)settings->Version());

   686 #endif

   687 			INFO_PRINTF2(_L("  Port                         : %x"), settings->Port());

   688 			INFO_PRINTF2(_L("  SecureSockets                : %x"), (TUint)settings->SecureSockets());

   689 			HBufC*	loginName=CopyToBufLC(settings->LoginName());

   690 			INFO_PRINTF2(_L("  LoginName                    : %S"), loginName);

   691 			CleanupStack::PopAndDestroy(loginName);

   692 			if ( settings->AutoSendOnConnect() != 0 )

   693 				{

   694 				INFO_PRINTF2(_L("  AutoSendOnConnect            : %x"), (TUint)settings->AutoSendOnConnect());

   695 				}

   696 			if ( settings->Apop() != 0 )

   697 				{

   698 				INFO_PRINTF2(_L("  Apop                         : %x"), (TUint)settings->Apop());

   699 				}

   700 			if ( settings->DisconnectedUserMode() != 0 )

   701 				{

   702 				INFO_PRINTF2(_L("  DisconnectedUserMode         : %x"), (TUint)settings->DisconnectedUserMode());

   703 				}

   704 			if ( settings->DeleteEmailsWhenDisconnecting() != 0 )

   705 				{

   706 				INFO_PRINTF2(_L("  DeleteEmailsWhenDisconnecting: %x"), (TUint)settings->DeleteEmailsWhenDisconnecting());

   707 				}

   708 			if ( settings->AcknowledgeReceipts() != 0 )

   709 				{

   710 				INFO_PRINTF2(_L("  AcknowledgeReceipts          : %x"), (TUint)settings->AcknowledgeReceipts());

   711 				}

   712 			if ( settings->MaxEmailSize() != 0 )

   713 				{

   714 				INFO_PRINTF2(_L("  MaxEmailSize                 : %x"), (TUint)settings->MaxEmailSize());

   715 				}

   716 			if ( settings->GetMailOptions() != 0 )

   717 				{

   718 				INFO_PRINTF2(_L("  GetMailOptions               : %x"), (TUint)settings->GetMailOptions());

   719 				}

   720 			if ( settings->InboxSynchronisationLimit() != 0 )

   721 				{

   722 				INFO_PRINTF2(_L("  InboxSynchronisationLimit    : %x"), (TUint)settings->InboxSynchronisationLimit());

   723 				}

   724 			}

   725 		CleanupStack::PopAndDestroy(settings);

   726 		}

   727 

   728 	CleanupStack::PopAndDestroy(store);

   729 	}

   730 

   731 void CTestMessBase::PrintStoreImap4L(CMsvEntry& aEntry)

   732 	{

   733 	TMsvEntry	entry=aEntry.Entry();

   734 	CMsvStore*	store=aEntry.ReadStoreL();

   735 	CleanupStack::PushL(store);

   736 

   737 	TPtrC	ptrTemp;

   738 	if ( entry.iType == KUidMsvServiceEntry )

   739 		{

   740 		CImImap4Settings*	settings = new(ELeave) CImImap4Settings();

   741 		CleanupStack::PushL(settings);

   742 

   743 #ifdef __MESSAGING_API_V2__

   744 		CEmailAccounts*		accounts = CEmailAccounts::NewLC();

   745 		TImapAccount imapAccountId;

   746 		accounts->GetImapAccountL(aEntry.EntryId(), imapAccountId);

   747 		TRAPD(err, accounts->LoadImapSettingsL(imapAccountId, *settings));

   748 		CleanupStack::PopAndDestroy(accounts);

   749 #else

   750 		TRAPD(err, settings->RestoreL(*store));

   751 #endif

   752 		if ( err == KErrNone )

   753 			{

   754 			ptrTemp.Set(settings->ServerAddress());

   755 			INFO_PRINTF2(_L("  ServerAddress                : %S"), &ptrTemp);

   756 #ifndef __MESSAGING_API_V2__

   757 			ptrTemp.Set(settings->UserAddress());

   758 			INFO_PRINTF2(_L("  UserAddress                  : %S"), &ptrTemp);

   759 			INFO_PRINTF2(_L("  Version                      : %x"), (TUint)settings->Version());

   760 #endif

   761 			INFO_PRINTF2(_L("  Port                         : %x"), settings->Port());

   762 			INFO_PRINTF2(_L("  SecureSockets                : %x"), (TUint)settings->SecureSockets());

   763 

   764 			HBufC*	loginName=CopyToBufLC(settings->LoginName());

   765 			INFO_PRINTF2(_L("  LoginName                    : %S"), loginName);

   766 			HBufC*	folderPath=CopyToBufLC(settings->FolderPath());

   767 			INFO_PRINTF2(_L("  FolderPath                   : %S"), folderPath);

   768 			CleanupStack::PopAndDestroy(2, loginName);

   769 			if ( settings->PathSeparator() != 0 )

   770 				{

   771 				INFO_PRINTF2(_L("  PathSeparator                : %c"), (TText)settings->PathSeparator());

   772 				}

   773 			if ( settings->DisconnectedUserMode() != 0 )

   774 				{

   775 				INFO_PRINTF2(_L("  DisconnectedUserMode         : %x"), (TUint)settings->DisconnectedUserMode());

   776 				}

   777 			if ( settings->Synchronise() != 0 )

   778 				{

   779 				INFO_PRINTF2(_L("  Synchronise                  : %x"), (TUint)settings->Synchronise());

   780 				}

   781 			if ( settings->Subscribe() != 0 )

   782 				{

   783 				INFO_PRINTF2(_L("  Subscribe                    : %x"), (TUint)settings->Subscribe());

   784 				}

   785 			if ( settings->AutoSendOnConnect() != 0 )

   786 				{

   787 				INFO_PRINTF2(_L("  AutoSendOnConnect            : %x"), (TUint)settings->AutoSendOnConnect());

   788 				}

   789 			if ( settings->MaxEmailSize() != 0 )

   790 				{

   791 				INFO_PRINTF2(_L("  MaxEmailSize                 : %x"), (TUint)settings->MaxEmailSize());

   792 				}

   793 			if ( settings->DeleteEmailsWhenDisconnecting() != 0 )

   794 				{

   795 				INFO_PRINTF2(_L("  DeleteEmailsWhenDisconnecting: %x"), (TUint)settings->DeleteEmailsWhenDisconnecting());

   796 				}

   797 			if ( settings->AcknowledgeReceipts() != 0 )

   798 				{

   799 				INFO_PRINTF2(_L("  AcknowledgeReceipts          : %x"), (TUint)settings->AcknowledgeReceipts());

   800 				}

   801 			if ( settings->GetMailOptions() != 0 )

   802 				{

   803 				INFO_PRINTF2(_L("  GetMailOptions               : %x"), (TUint)settings->GetMailOptions());

   804 				}

   805 			if ( settings->InboxSynchronisationLimit() != 0 )

   806 				{

   807 				INFO_PRINTF2(_L("  InboxSynchronisationLimit    : %x"), (TUint)settings->InboxSynchronisationLimit());

   808 				}

   809 			if ( settings->MailboxSynchronisationLimit() != 0 )

   810 				{

   811 				INFO_PRINTF2(_L("  MailboxSynchronisationLimit  : %x"), (TUint)settings->MailboxSynchronisationLimit());

   812 				}

   813 			}

   814 		CleanupStack::PopAndDestroy(settings);

   815 		}

   816 

   817 	CleanupStack::PopAndDestroy(store);

   818 	}

   819 

   820 void CTestMessBase::PrintStoreSmsL(CMsvEntry& aEntry)

   821 	{

   822 	TMsvEntry	entry=aEntry.Entry();

   823 	CMsvStore*	store=aEntry.ReadStoreL();

   824 	CleanupStack::PushL(store);

   825 

   826 	TPtrC	ptrTemp;

   827 	if ( entry.iType == KUidMsvServiceEntry )

   828 		{

   829 		CSmsSettings*	settings = CSmsSettings::NewL();

   830 		CleanupStack::PushL(settings);

   831 

   832 #ifdef __MESSAGING_API_V2__

   833 		CSmsAccount*		smsAccount = CSmsAccount::NewLC();

   834 		TRAPD(err, smsAccount->LoadSettingsL(*settings));

   835 		CleanupStack::PopAndDestroy(smsAccount);

   836 #else

   837 		TRAPD(err, settings->RestoreL(*store));

   838 #endif

   839 		if ( err == KErrNone )

   840 			{

   841 			TSmsDelivery	delivery(settings->Delivery());

   842 			INFO_PRINTF2(_L("  Delivery                     : %d"), delivery);

   843 			CSmsSettings::TSmsReportHandling	reportHandling(settings->StatusReportHandling());

   844 			INFO_PRINTF2(_L("  StatusReportHandling         : %d"), reportHandling);

   845 			CSmsSettings::TSmsReportHandling	specialMsgHandling(settings->SpecialMessageHandling());

   846 			INFO_PRINTF2(_L("  SpecialMessageHandling       : %d"), specialMsgHandling);

   847 			INFO_PRINTF2(_L("  ReplyQuoted                  : %d"), settings->ReplyQuoted());

   848 #ifdef __MESSAGING_API_V2__

   849 			const TInt	numSCAddr = settings->ServiceCenterCount();

   850 #else

   851 			const TInt	numSCAddr = settings->NumSCAddresses();

   852 #endif

   853 			for( TInt index=0;index<numSCAddr;index++ )

   854 				{

   855 #ifdef __MESSAGING_API_V2__

   856 				CSmsServiceCenter&	scAddr = settings->GetServiceCenter(index);

   857 #else

   858 				CSmsNumber&			scAddr = settings->SCAddress(index);

   859 #endif

   860 				ptrTemp.Set(scAddr.Name());

   861 				INFO_PRINTF2(_L("  SC Name                      : %S"), &ptrTemp);

   862 				ptrTemp.Set(scAddr.Address());

   863 				INFO_PRINTF2(_L("  SC Address                   : %S"), &ptrTemp);

   864 				}

   865 			CSmsSettings::TSmsSettingsCommDbAction	commDbAction(settings->SmsBearerAction());

   866 			INFO_PRINTF2(_L("  SmsBearerAction              : %d"), commDbAction);

   867 

   868 			CSmsSettings::TMobileSmsBearer	smsBearer(settings->SmsBearer());

   869 			INFO_PRINTF2(_L("  SmsBearer                    : %d"), smsBearer);

   870 			}

   871 		CleanupStack::PopAndDestroy(settings);

   872 		}

   873 

   874 	CleanupStack::PopAndDestroy(store);

   875 	}

   876 

   877 void CTestMessBase::IssueTimerRequest()

   878 	{

   879 	if (iMessageTimer!= NULL)

   880 		{

   881 		iMessageTimer->IssueRequest();

   882 		}

   883 	}

   884 

   885 void CTestMessBase::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny*, TAny*)

   886 /**

   887  Handler for the Session Event

   888  @param aEvent - TMsvSessionEvent object

   889  @param aArg1 - TAny object pointer, used to store the argument for the event

   890  @leave - System wide error codes

   891 */

   892 	{

   893 	TBool	printSelection=EFalse;

   894 

   895 	switch (aEvent)

   896 		{

   897 	case EMsvEntriesCreated:

   898 		INFO_PRINTF1(_L("EMsvEntriesCreated"));

   899 		printSelection=ETrue;

   900 		break;

   901 	case EMsvEntriesChanged:

   902 		INFO_PRINTF1(_L("EMsvEntriesChanged"));

   903 		printSelection=ETrue;

   904 		break;

   905 	case EMsvEntriesDeleted:

   906 		INFO_PRINTF1(_L("EMsvEntriesDeleted"));

   907 		break;

   908 	case EMsvEntriesMoved:

   909 		INFO_PRINTF1(_L("EMsvEntriesMoved"));

   910 		printSelection=ETrue;

   911 		break;

   912 	case EMsvMtmGroupInstalled:

   913 		INFO_PRINTF1(_L("EMsvMtmGroupInstalled"));

   914 		break;

   915 	case EMsvMtmGroupDeInstalled:

   916 		INFO_PRINTF1(_L("EMsvMtmGroupDeInstalled"));

   917 		break;

   918 	case EMsvGeneralError:

   919 		INFO_PRINTF1(_L("EMsvGeneralError"));

   920 		break;

   921 	case EMsvCloseSession:

   922 		INFO_PRINTF1(_L("EMsvCloseSession"));

   923 		break;

   924 	case EMsvServerReady:

   925 		INFO_PRINTF1(_L("EMsvServerReady"));

   926 		break;

   927 	case EMsvServerFailedToStart:

   928 		INFO_PRINTF1(_L("EMsvServerFailedToStart"));

   929 		break;

   930 	case EMsvCorruptedIndexRebuilt:

   931 		INFO_PRINTF1(_L("EMsvCorruptedIndexRebuilt"));

   932 		break;

   933 	case EMsvServerTerminated:

   934 		INFO_PRINTF1(_L("EMsvServerTerminated"));

   935 		break;

   936 	case EMsvMediaChanged:

   937 		INFO_PRINTF1(_L("EMsvMediaChanged"));

   938 		break;

   939 	case EMsvMediaUnavailable:

   940 		INFO_PRINTF1(_L("EMsvMediaUnavailable"));

   941 		break;

   942 	case EMsvMediaAvailable:

   943 		INFO_PRINTF1(_L("EMsvMediaAvailable"));

   944 		break;

   945 	case EMsvMediaIncorrect:

   946 		INFO_PRINTF1(_L("EMsvMediaIncorrect"));

   947 		break;

   948 	case EMsvCorruptedIndexRebuilding:

   949 		INFO_PRINTF1(_L("EMsvCorruptedIndexRebuilding"));

   950 		break;

   951 	default:

   952 		INFO_PRINTF2(_L("EMsv Unknown event:%d"), aEvent);

   953 		break;

   954 	}

   955 

   956 	if ( printSelection )

   957 		{

   958 		CMsvEntrySelection*	selection=STATIC_CAST(CMsvEntrySelection*, aArg1);

   959 		CMsvEntry*			entry=NULL;

   960 		for ( int i=0; i<selection->Count(); )

   961 			{

   962 			entry=iSession->GetEntryL(selection->At(i++));

   963 			CleanupStack::PushL(entry);

   964 			PrintEntryL(*entry);

   965 			CleanupStack::PopAndDestroy(entry);

   966 			}

   967 		}

   968 	}

   969 

   970 

   971 void CTestMessBase::PrepareSmsHeaderFromIniFileL(CSmsHeader& aSmsHeader)

   972 	{

   973 	// Starts the Bitmap server

   974 	FbsStartup();

   975 	// start the server

   976 	RFbsSession::Connect();

   977 

   978 	// Add the Fromating required for EMS if required

   979 	TInt	emsElements=0;

   980 	if ( !GetIntFromConfig(ConfigSection(), KElements, emsElements) )

   981 		{

   982 		ERR_PRINTF1(_L("Elements not set"));

   983 		SetTestStepResult(EFail);

   984 		}

   985 

   986 // Macro usage for CDMA mtm

   987 #if (defined CDMA_API_ENABLED)

   988 	TMsvMessageSms&	message=aSmsHeader.SmsMessage();

   989 #else

   990 	CSmsMessage&	message=aSmsHeader.Message(); 

   991 #endif

   992 

   993 	TBuf<KMaxTestExecuteCommandLength>	tempStore;

   994 	for ( TInt element=0; element<emsElements && TestStepResult()==EPass;)

   995 		{

   996 		++element;

   997 		INFO_PRINTF2(_L("==== PROCESSING ELEMENT %d ===="), element);

   998 		//	Start position

   999 		tempStore.Format(KStartPosition, element);

  1000 		TInt	startPosition=KDefaultStartPos;

  1001 		if ( GetIntFromConfig(ConfigSection(), tempStore, startPosition) )

  1002 			{

  1003 			INFO_PRINTF2(_L("Start position %d"), startPosition);

  1004 			}

  1005 

  1006 		//	File

  1007 		tempStore.Format(KFile, element);

  1008 		TPtrC	file;

  1009 		TParse	fileName;

  1010 		TBool	hasFile=GetStringFromConfig(ConfigSection(), tempStore, file);

  1011 		if ( hasFile )

  1012 			{

  1013 			INFO_PRINTF2(_L("File %S"), &file);

  1014 			fileName.Set(file,NULL,NULL);

  1015 			}

  1016 

  1017 		tempStore.Format(KType, element);

  1018 		TPtrC	type;

  1019 		if ( GetStringFromConfig(ConfigSection(), tempStore, type) )

  1020 			{

  1021 			if ( type.Compare(KTypeFormat) == 0 )

  1022 				{

  1023 				//	=== Process text formating Information Element ===

  1024 				CEmsFormatIE*	newElement=CEmsFormatIE::NewL();

  1025 				CleanupStack::PushL(newElement);

  1026 				newElement->SetStartPosition(startPosition);

  1027 

  1028 				TInt			intTemp;

  1029 				TBool			boolTemp;

  1030 				TPtrC			alignment;

  1031 				TPtrC			fontSize;

  1032 

  1033 				// Set the Format length and other information

  1034 				tempStore.Format(KFormatLength, element);

  1035 				if ( GetIntFromConfig(ConfigSection(), tempStore, intTemp) )

  1036 					{

  1037 					INFO_PRINTF2(_L("Format Length %d"), intTemp);

  1038 					newElement->SetFormatLength(intTemp);

  1039 					}

  1040 				tempStore.Format(KBold, element);

  1041 				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )

  1042 					{

  1043 					INFO_PRINTF2(_L("Bold %d"), boolTemp);

  1044 					newElement->SetBold(boolTemp);

  1045 					}

  1046 				tempStore.Format(KItalic, element);

  1047 				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )

  1048 					{

  1049 					INFO_PRINTF2(_L("Italic %d"), boolTemp);

  1050 				    newElement->SetItalic(boolTemp);

  1051 					}

  1052 				tempStore.Format(KUnderline, element);

  1053 				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )

  1054 					{

  1055 					INFO_PRINTF2(_L("Underline %d"), boolTemp);

  1056 					newElement->SetUnderline(boolTemp);

  1057 					}

  1058 				tempStore.Format(KStrikethrough, element);

  1059 				if ( GetBoolFromConfig(ConfigSection(), tempStore, boolTemp) )

  1060 					{

  1061 					INFO_PRINTF2(_L("Strikethrough %d"), boolTemp);

  1062 					newElement->SetStrikethrough(boolTemp);

  1063 					}

  1064 				tempStore.Format(KAlignment,element);

  1065 				if(GetStringFromConfig(ConfigSection(),tempStore,alignment))

  1066 					{

  1067 					SetAlignmentFormat(*newElement, alignment);

  1068 					}

  1069 				

  1070 				tempStore.Format(KFontSize,element);

  1071 				if(GetStringFromConfig(ConfigSection(),tempStore,fontSize))

  1072 					{

  1073 					//

  1074 					SetFontSizeFormat(*newElement, fontSize);

  1075 					}

  1076 			    message.AddEMSInformationElementL(*newElement); 

  1077 				CleanupStack::PopAndDestroy(newElement);

  1078 				}

  1079 			else if ( type.Compare(KTypeSound) == 0 )

  1080 				{

  1081 				//	=== Process sound Information Element ===

  1082 				if ( hasFile )

  1083 					{

  1084 					HBufC8*			buffFile=CopyToBuf8LC(fileName.FullName());

  1085 					CEmsSoundIE*	newElement=CEmsSoundIE::NewL(buffFile->Des());

  1086 					CleanupStack::PushL(newElement);

  1087 					newElement->SetStartPosition(startPosition); 

  1088 				    message.AddEMSInformationElementL(*newElement); 

  1089 					CleanupStack::PopAndDestroy(2, buffFile);

  1090 					}

  1091 				else

  1092 					{

  1093 					ERR_PRINTF1(_L("No Sound file name"));

  1094 					SetTestStepResult(EFail);

  1095 					}

  1096 				}

  1097 			else if ( type.Compare(KTypePreDefSound) == 0 )

  1098 				{

  1099 				//	=== Process predefined sound Information Element ===

  1100 				TPtrC	preDefSound;

  1101 				tempStore.Format(KEmsPreDef, element);

  1102 				if ( !GetStringFromConfig(ConfigSection(),tempStore, preDefSound))

  1103 					{

  1104 					ERR_PRINTF1(_L("Predefined sound not present"));

  1105 					SetTestStepResult(EFail);

  1106 					}

  1107 				else

  1108 					{

  1109 					INFO_PRINTF2(_L("Predefined sound %S"), &preDefSound);

  1110 					CEmsPreDefSoundIE*	newElement=NewPreDefSoundL(preDefSound);

  1111 

  1112 					if ( newElement != NULL )

  1113 						{

  1114 						//Assign the predef animation element to newElement

  1115 						CleanupStack::PushL(newElement);

  1116 						newElement->SetStartPosition(startPosition);

  1117 					    message.AddEMSInformationElementL(*newElement); 

  1118 						CleanupStack::PopAndDestroy(newElement);

  1119 						}

  1120 					else

  1121 						{

  1122 						ERR_PRINTF1(_L("Unable to create predefined sound"));

  1123 						SetTestStepResult(EFail);

  1124 						}

  1125 					}

  1126 				}

  1127 			else if ( type.Compare(KTypeAnimation) == 0 )

  1128 				{

  1129 				//	=== Process animation Information Element ===

  1130 				if ( hasFile )

  1131 					{

  1132 					TPtrC	objectSize;

  1133 

  1134 					tempStore.Format(KObjectSize, element);