diff -r 000000000000 -r f979ecb2b13e pimappsupport/vcardandvcal/tsrc/tPerformance.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappsupport/vcardandvcal/tsrc/tPerformance.cpp	Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,989 @@
+// Copyright (c) 2001-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:
+//
+
+#define __PROFILING__
+
+// System includes
+#include <e32std.h>
+#include <e32base.h>
+#include <e32test.h>
+#include <s32mem.h>
+
+// User includes
+#include <versit.h>
+#include <vcal.h>
+#include <vcard.h>
+#include <vtoken.h>
+
+// Globals
+_LIT(KTestName,"Performance Test");
+_LIT(KTestDirInput,"Z:\\TPerFormance\\inputFile\\");
+_LIT(KTestDirOutput,"c:\\TPerFormance\\outputFile\\");
+_LIT(KTestDirResult,"c:\\TPerFormance\\resultFile\\");
+_LIT(KTestFileNameExt,".TXT");
+
+_LIT8(KVersitTokenAGENDAENTRYTYPE,		"AGENDAENTRYTYPE");
+_LIT8(KVersitTokenNICKNAME,				"NICKNAME");
+_LIT8(KVersitTokenXWABGENDER,				"X-WAB-GENDER");
+
+LOCAL_D RTest TheTest(KTestName);
+
+class SRHeapCopy 
+	{// dummy heap which is a copy RHeapCopy butmake iAllocCount public
+public:
+	//enum TAllocFail {ERandom,ETrueRandom,EDeterministic,ENone,EFailNext};
+public:
+	TBool iTestCodeRunning;	
+	TInt iTestNestingLevel;
+	TInt iTestNumAllocCells;
+	TUint iTestAddress;
+	TInt iTestSize;
+	TInt iTestAllocCount;
+public:
+	struct SDebugCell {TInt len;TInt nestingLevel;TInt allocCount;};
+private:
+	TInt iNestingLevel;
+public:
+	TInt iAllocCount;
+private:
+	TInt iLevelNumAllocCells;
+	SDebugCell* iPtrDebugCell;
+	RHeap::TAllocFail iFailType;
+	TInt iFailRate;
+	TBool iFailed;
+	TInt iFailAllocCount;
+	TInt iRand;
+	};
+
+class CTests : public CBase
+	{
+public:
+	static void DoTestsL();
+private:
+	enum TDataType
+		{
+		ETvCardFile,
+		ETvCalFile,
+		ETvCardLine,
+		ETvCalLine,
+		};
+
+	struct SPrintResult
+		{
+		TInt TimeInt;				//internalising time
+		TInt TimeExt;				//externalising time
+		TInt IncreasedCells;		//net increase in heap cells
+		TInt IncreasedSizeInBytes;	//net increase in heap size
+		TInt NumAlloInt;			//overall number of allocations when internalising
+		TInt NumAlloExt;			//overall number of allocations when externalising
+		};
+
+	~CTests();
+	void ConstructL();
+	void AllTestsL();
+	void TestIntExtFileL(TDataType aDataType);
+	void TestVCalMemoryUsageByAddingEntitiesL(TInt aNumOfEntry,SPrintResult& aResult);
+	void TestVCardMemoryUsageWithDiffCharsetsL(SPrintResult& aResult,const TDesC& aFileName, Versit::TVersitCharSet aCharset=Versit::EUSAsciiCharSet);
+	void TestVCardMemoryUsageL();
+	void TestVCalMemoryUsageL();
+	void CreateEntityEventEntryL(CParserVCalEntity& aEntity);
+	void CreateEntityTodoEntryL(CParserVCalEntity& aEntity);
+	void PrintOutResult(const TDesC& aFilename, RFile& aFile, SPrintResult aResult);
+	void PrintOutResult(RFile& aFile, TInt aNumOfEntries, SPrintResult aResult);
+	void CreateAparserLC(TDataType aDataType,CVersitParser*& aParser);
+	void ExternaliseFileL(CVersitParser& aParser,const TDesC& aFileName);
+	void InternaliseFileL(CVersitParser& aParser,const TDesC& aFileName);
+private:
+	RFs iFsSession;
+	TBool iSessionConnected;
+	CVersitParser* iParser;		//This is to keep the Static Utilities around
+	CFileMan* iFm;
+	};
+
+void CTests::DoTestsL()
+	{
+	CTests* self=new(ELeave) CTests;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	self->AllTestsL();
+	CleanupStack::PopAndDestroy(self);
+	}
+
+void CTests::ConstructL()
+	{
+	TheTest.Printf(_L("About to connect to file session\r\n"));
+	User::LeaveIfError(iFsSession.Connect());
+	iSessionConnected=ETrue;
+	iFm = CFileMan::NewL(iFsSession);
+	iParser=new(ELeave) CVersitParser(CVersitParser::ENoVersionProperty);
+	iParser->ConstructL();
+	}
+
+CTests::~CTests()
+	{
+	delete iParser;
+	if(iFm)
+		{
+		iFm->RmDir(KTestDirOutput);
+		iFm->RmDir(KTestDirResult);
+		iFm->RmDir(_L("c:\\TPerFormance\\"));
+		delete iFm;
+		}
+	if (iSessionConnected)
+		iFsSession.Close();
+	}
+
+void CTests::ExternaliseFileL(CVersitParser& aParser,const TDesC& aFileName)
+	{
+	RFile file;
+	User::LeaveIfError(file.Replace(iFsSession, aFileName, EFileWrite));
+	CleanupClosePushL(file);
+	aParser.ExternalizeL(file);
+	CleanupStack::PopAndDestroy(&file);
+	}
+
+void CTests::InternaliseFileL(CVersitParser& aParser,const TDesC& aFileName)
+	{
+	RFile file;
+	User::LeaveIfError(file.Open(iFsSession, aFileName, EFileRead));
+	CleanupClosePushL(file);
+	TInt start=0;
+	aParser.InternalizeL(file, start);
+	CleanupStack::PopAndDestroy(&file);
+	}
+
+void CTests::CreateAparserLC(TDataType aDataType,CVersitParser*& aParser)
+	{
+	if ((aDataType==ETvCardFile)||(aDataType==ETvCardLine))
+		aParser = CParserVCard::NewL();
+	else
+		aParser = CParserVCal::NewL();
+	CleanupStack::PushL(aParser);
+	}
+
+void CTests::PrintOutResult(RFile& aFile,TInt aNumOfEntries, SPrintResult aResult)
+	{
+	TBuf<200> resultBuf;
+	resultBuf.Format(_L("\t%d\t\t%d\t\t%d\t\t%d\x0d\x0a"),aNumOfEntries,aResult.IncreasedSizeInBytes,aResult.IncreasedCells,aResult.NumAlloExt);
+	TheTest.Printf(resultBuf);
+	TBuf8<100> resultBuf8;
+	resultBuf8.Copy(resultBuf);
+	aFile.Write(resultBuf8);
+	}
+
+void CTests::PrintOutResult(const TDesC& aDescription, RFile& file, SPrintResult aResult)
+	{
+	//output result
+	TBuf<200> resultBuf;
+	if (aResult.TimeInt==0)
+		resultBuf.Format(_L("%-23S\t%d\t\t%d\t\t%d\x0d\x0a"),&aDescription, aResult.IncreasedSizeInBytes,aResult.IncreasedCells,aResult.NumAlloExt);
+	else
+		resultBuf.Format(_L("%-23S\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\x0d\x0a"),&aDescription, aResult.TimeInt, aResult.TimeExt, aResult.TimeInt+aResult.TimeExt,aResult.IncreasedCells,aResult.IncreasedSizeInBytes,aResult.NumAlloInt,aResult.NumAlloExt);
+	TheTest.Printf(resultBuf);
+	TBuf8<100> resultBuf8;
+	resultBuf8.Copy(resultBuf);
+	file.Write(resultBuf8);
+	}
+
+void CTests::AllTestsL()
+	{
+	TInt err;
+	err=iFsSession.MkDirAll(KTestDirOutput());
+	if((err!=KErrAlreadyExists) && (err!=KErrNone))
+		{
+		TheTest.Printf(_L("Directory failed to created err=%d\r\n"),err);
+		TheTest.Getch();
+		User::Leave(err);
+		}
+	err=iFsSession.MkDirAll(KTestDirResult());
+	if((err!=KErrAlreadyExists) && (err!=KErrNone))
+		User::Leave(err);
+
+	_LIT(KTest1,"Int & Ext vCards\n");
+	TheTest.Printf(KTest1);
+	TestIntExtFileL(ETvCardFile);
+
+	_LIT(KTest2,"\n\nInt & Ext vCals\n");
+  	TheTest.Printf(KTest2);
+  	TestIntExtFileL(ETvCalFile);
+  
+ 	_LIT(KTest3,"\n\nInt & Ext vCards with single line\n");
+  	TheTest.Printf(KTest3);
+  	TestIntExtFileL(ETvCardLine);
+  
+  	_LIT(KTest4,"\n\nInt & Ext vCal with single line\n");
+  	TheTest.Printf(KTest4);
+  	TestIntExtFileL(ETvCalLine);
+
+	_LIT(KTest5,"\n\nVCal Test with added entities\n");
+	TheTest.Printf(KTest5);
+	TestVCalMemoryUsageL();
+	
+	_LIT(KTest6, "\n\nCreate a vCard by Adding Properties\n\n");
+	TheTest.Printf(KTest6);
+	TestVCardMemoryUsageL(); 
+	}
+
+void CTests::TestVCalMemoryUsageL()
+	{
+	_LIT(KResultWithAddingEntities,"vCalAddingEntriesResult");
+	TFileName resultFile;
+	resultFile=KTestDirResult;
+	resultFile.Append(KResultWithAddingEntities);
+	resultFile.Append(KTestFileNameExt);
+	RFile file;
+	User::LeaveIfError(file.Replace(iFsSession, resultFile,EFileWrite+EFileShareAny+EFileStreamText));
+	CleanupClosePushL(file);//file
+
+	TBuf<200> title;
+	title.Format(_L("num entries\theap size\tnum obj \tnum. Alloc\x0d\x0a"));
+	TheTest.Printf(title);
+	TBuf8<200> title8;
+	title8.Copy(title);
+	file.Write(title8);
+
+	for(TInt i=5;i<41;i=i+5)
+		{
+		SPrintResult result;
+		TestVCalMemoryUsageByAddingEntitiesL(i,result);
+		PrintOutResult(file,i,result);
+		}
+
+	CleanupStack::PopAndDestroy(&file);
+	}
+
+void CTests::TestVCardMemoryUsageL()
+	{
+	_LIT(KvCardResult,"vCardAddingPropertyResult");
+	TFileName resultFile;
+	resultFile=KTestDirResult;
+	resultFile.Append(KvCardResult);
+	resultFile.Append(KTestFileNameExt);
+	RFile file;
+	User::LeaveIfError(file.Replace(iFsSession, resultFile,EFileWrite+EFileShareAny+EFileStreamText));
+	CleanupClosePushL(file);//file
+
+	TBuf<200> title;
+	title.Format(_L("file Name\t\t\theap size\tnum obj \tnum. Alloc\x0d\x0a"));
+	TheTest.Printf(title);
+	TBuf8<200> title8;
+	title8.Copy(title);
+	file.Write(title8);
+	SPrintResult result;
+	result.TimeInt=0;
+	Versit::TVersitCharSet charset;
+
+	_LIT(KVCardTestFile1, "vCardAddedProAscii");
+	TestVCardMemoryUsageWithDiffCharsetsL(result,KVCardTestFile1);
+	PrintOutResult(KVCardTestFile1,file,result);
+
+	_LIT(KVCardTestFile2, "vCardAddedProGBK");
+	charset=Versit::EGBKCharSet;
+	TestVCardMemoryUsageWithDiffCharsetsL(result,KVCardTestFile2,charset);
+	PrintOutResult(KVCardTestFile2,file,result);
+
+	_LIT(KVCardTestFile3, "vCardAddedProShifJis");
+	charset=Versit::EShiftJISCharSet;
+	TestVCardMemoryUsageWithDiffCharsetsL(result,KVCardTestFile3,charset);
+	PrintOutResult(KVCardTestFile3,file,result);
+
+	_LIT(KVCardTestFile4,"vCardAddedProUtf7");
+	charset=Versit::EUTF7CharSet;
+	TestVCardMemoryUsageWithDiffCharsetsL(result,KVCardTestFile4,charset);
+	PrintOutResult(KVCardTestFile4,file,result);
+
+	_LIT(KVCardTestFile5,"vCardAddedProJis");
+	charset=Versit::EJISCharSet;
+	TestVCardMemoryUsageWithDiffCharsetsL(result,KVCardTestFile5,charset);
+	PrintOutResult(KVCardTestFile5,file,result);
+
+	CleanupStack::PopAndDestroy(&file);
+	}
+
+void CTests::TestVCardMemoryUsageWithDiffCharsetsL(SPrintResult& aResult, const TDesC& aFileName,Versit::TVersitCharSet aCharset)
+	{
+	TInt numCellsBefore, numCellsAfter, sizeInBytesBefore, sizeInBytesAfter, numAllocBefore, numAllocAfter;
+	RHeap& heap = User::Heap();
+	SRHeapCopy& myHeap = REINTERPRET_CAST(SRHeapCopy&, heap);
+	numCellsBefore = heap.AllocSize(sizeInBytesBefore);
+	numAllocBefore = myHeap.iAllocCount; 
+	
+	CParserVCard* vCardParser = CParserVCard::NewL();
+	CleanupStack::PushL(vCardParser);
+
+	_LIT8(KHOME, "HOME");
+	_LIT8(KVOICE, "VOICE");
+	_LIT8(KCELL, "CELL");
+	_LIT8(KFAX, "FAX");
+	_LIT8(KPOSTAL, "POSTAL");
+	_LIT8(KPREF, "PREF");
+	_LIT8(KWORK, "WORK");
+
+	_LIT(KSurname, "Example");
+	_LIT(KFirstname, "A");
+	_LIT(KMiddlename, "N");
+	_LIT(KFullname, "A N Example");
+	_LIT(KTIME, "20010419T103325Z");
+	_LIT(KEMAIL, "symbian.foundation@exp.example.test");
+	_LIT(KTELNUM, "01-6329-60000");
+	_LIT(KORG, "Symbian Foundation Center");
+	_LIT(KDR, "DR");
+	_LIT(KLONGNOTE, "This is a long note to test This is a long note to testThis is a long note to test This is a long note to test This is a long note to test This is a long note to test");
+	_LIT(KADSFIELD1, "Example 1");
+	_LIT(KADSFIELD2, "Example City Ø");
+	_LIT(KADSFIELD3, "ZZ99 EXP");
+	_LIT(KLONGLAB, "long label to test ong label to test ong label to test ong label to test ong label to test ong label to test ong label to test");
+	_LIT(KNUM, "2");
+	_LIT(KADSINTER, "http://www.symbianfoundation.example");
+	_LIT(KDATE, "19520607");
+
+	//property 1
+	CDesCArrayFlat* desArray1 = new (ELeave) CDesCArrayFlat(3);
+	CleanupStack::PushL(desArray1);
+	desArray1->AppendL(KSurname);  
+	desArray1->AppendL(KFirstname);
+	desArray1->AppendL(KMiddlename); 
+	CParserPropertyValue* valueN=new (ELeave) CParserPropertyValueCDesCArray(desArray1);
+  	CleanupStack::Pop(desArray1);
+	CleanupStack::PushL(valueN);
+	CParserGroupedProperty* propertyN = CParserGroupedProperty::NewL(*valueN, KVersitTokenN, NULL, NULL);
+	CleanupStack::Pop(valueN);
+	CleanupStack::PushL(propertyN);
+	vCardParser->AddPropertyL(propertyN);
+	CleanupStack::Pop(propertyN);
+
+	//property 2
+	CParserPropertyValue* valueFN = CParserPropertyValueHBufC::NewL(KFullname);
+	CleanupStack::PushL(valueFN);
+	CParserGroupedProperty* propertyFN = CParserGroupedProperty::NewL(*valueFN, KVersitTokenFN, NULL, NULL);
+	CleanupStack::Pop(valueFN);
+	CleanupStack::PushL(propertyFN);
+	vCardParser->AddPropertyL(propertyFN);
+	CleanupStack::Pop(propertyFN);
+
+	//property 3
+	CParserPropertyValue* valueNN = CParserPropertyValueHBufC::NewL(KFullname);
+	CleanupStack::PushL(valueNN);
+	CParserGroupedProperty* propertyNN = CParserGroupedProperty::NewL(*valueNN, KVersitTokenNICKNAME, NULL, NULL);
+	CleanupStack::Pop(valueNN);
+	CleanupStack::PushL(propertyNN);
+	vCardParser->AddPropertyL(propertyNN);
+	CleanupStack::Pop(propertyNN);
+
+	//property 4
+	CParserPropertyValue* value4 = CParserPropertyValueHBufC::NewL(KORG);
+	CleanupStack::PushL(value4);
+	CParserGroupedProperty* property4 = CParserGroupedProperty::NewL(*value4, KVersitTokenORG, NULL, NULL);
+	CleanupStack::Pop(value4);
+	CleanupStack::PushL(property4);
+	vCardParser->AddPropertyL(property4);
+	CleanupStack::Pop(property4);
+
+	//property 5
+	CParserPropertyValue* value5 = CParserPropertyValueHBufC::NewL(KDR);
+	CleanupStack::PushL(value5);
+	CParserGroupedProperty* property5 = CParserGroupedProperty::NewL(*value5, KVersitTokenTITLE, NULL, NULL);
+	CleanupStack::Pop(value5);
+	CleanupStack::PushL(property5);
+	vCardParser->AddPropertyL(property5);
+	CleanupStack::Pop(property5);
+
+	//property 6
+	CParserPropertyValue* value6 = CParserPropertyValueHBufC::NewL(KLONGNOTE);
+	CleanupStack::PushL(value6);
+	CParserGroupedProperty* property6 = CParserGroupedProperty::NewL(*value6, KVersitTokenNOTE, NULL, NULL);
+	CleanupStack::Pop(value6);
+	CleanupStack::PushL(property6);
+	vCardParser->AddPropertyL(property6);
+	CleanupStack::Pop(property6);
+
+	//property 7
+	CArrayPtr<CParserParam>* arrayOfParams = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam1 = CParserParam::NewL(KWORK, KNullDesC8);
+	CleanupStack::PushL(parserParam1);
+	arrayOfParams->AppendL(parserParam1);
+	CleanupStack::Pop(parserParam1);
+
+	CParserParam* parserParam2= CParserParam::NewL(KVOICE, KNullDesC8);
+	CleanupStack::PushL(parserParam2);
+	arrayOfParams->AppendL(parserParam2);
+	CleanupStack::Pop(parserParam2);
+	CParserPropertyValue* value7 = CParserPropertyValueHBufC::NewL(KTELNUM);
+	CleanupStack::PushL(value7);
+	CParserGroupedProperty* property7 = CParserGroupedProperty::NewL(*value7, KVersitTokenTEL, NULL, arrayOfParams);
+	CleanupStack::Pop(value7);
+	CleanupStack::PushL(property7);
+	vCardParser->AddPropertyL(property7);
+	CleanupStack::Pop(property7);
+
+	//property 8
+	CArrayPtr<CParserParam>* arrayOfParams8 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam8A = CParserParam::NewL(KHOME, KNullDesC8);
+	CleanupStack::PushL(parserParam8A);
+	arrayOfParams8->AppendL(parserParam8A);
+	CleanupStack::Pop(parserParam8A);
+	CParserParam* parserParam8B = CParserParam::NewL(KHOME, KNullDesC8);
+	CleanupStack::PushL(parserParam8B);
+	arrayOfParams8->AppendL(parserParam8B);
+	CleanupStack::Pop(parserParam8B);
+	CParserPropertyValue* value8 = CParserPropertyValueHBufC::NewL(KTELNUM);
+	CleanupStack::PushL(value8);
+	CParserGroupedProperty* property8 = CParserGroupedProperty::NewL(*value8, KVersitTokenTEL, NULL, arrayOfParams8);
+	CleanupStack::Pop(value8);
+	CleanupStack::PushL(property8);
+	vCardParser->AddPropertyL(property8);
+	CleanupStack::Pop(property8);
+
+	//property 9
+	CArrayPtr<CParserParam>* arrayOfParams9 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam9A = CParserParam::NewL(KCELL, KNullDesC8);
+	CleanupStack::PushL(parserParam9A);
+	arrayOfParams9->AppendL(parserParam9A);
+	CleanupStack::Pop(parserParam9A);
+	CParserParam* parserParam9B = CParserParam::NewL(KVOICE, KNullDesC8);
+	CleanupStack::PushL(parserParam9B);
+	arrayOfParams9->AppendL(parserParam9B);
+	CleanupStack::Pop(parserParam9B);
+	CParserPropertyValue* value9 = CParserPropertyValueHBufC::NewL(KTELNUM);
+	CleanupStack::PushL(value9);
+	CParserGroupedProperty* property9 = CParserGroupedProperty::NewL(*value9, KVersitTokenTEL, NULL, arrayOfParams9);
+	CleanupStack::Pop(value9);
+	CleanupStack::PushL(property9);
+	vCardParser->AddPropertyL(property9);
+	CleanupStack::Pop(property9);
+
+	//property 10
+	CArrayPtr<CParserParam>* arrayOfParams10 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam10A = CParserParam::NewL(KWORK, KNullDesC8);
+	CleanupStack::PushL(parserParam10A);
+	arrayOfParams10->AppendL(parserParam10A);
+	CleanupStack::Pop(parserParam10A);
+	CParserParam* parserParam10B = CParserParam::NewL(KFAX, KNullDesC8);
+	CleanupStack::PushL(parserParam10B);
+	arrayOfParams10->AppendL(parserParam10B);
+	CleanupStack::Pop(parserParam10B);
+	CParserPropertyValue* value10 = CParserPropertyValueHBufC::NewL(KTELNUM);
+	CleanupStack::PushL(value10);
+	CParserGroupedProperty* property10 = CParserGroupedProperty::NewL(*value10, KVersitTokenTEL, NULL, arrayOfParams10);
+	CleanupStack::Pop(value10);
+	CleanupStack::PushL(property10);
+	vCardParser->AddPropertyL(property10);
+	CleanupStack::Pop(property10);
+
+	//property 11
+
+	CArrayPtr<CParserParam>* arrayOfParams11 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam11A = CParserParam::NewL(KPOSTAL, KNullDesC8);
+	CleanupStack::PushL(parserParam11A);
+	arrayOfParams11->AppendL(parserParam11A);
+	CleanupStack::Pop(parserParam11A);
+	CParserParam* parserParam11B = CParserParam::NewL(KWORK, KNullDesC8);
+	CleanupStack::PushL(parserParam11B);
+	arrayOfParams11->AppendL(parserParam11B);
+	CleanupStack::Pop(parserParam11B);
+	CDesCArrayFlat* desArrayAdr = new (ELeave) CDesCArrayFlat(3);
+	CleanupStack::PushL(desArrayAdr);
+	desArrayAdr->AppendL(KNullDesC);  
+	desArrayAdr->AppendL(KADSFIELD1);  
+	desArrayAdr->AppendL(KADSFIELD2);
+	desArrayAdr->AppendL(KNullDesC);  
+	desArrayAdr->AppendL(KADSFIELD3); 
+	CParserPropertyValue* valueAdr=new (ELeave) CParserPropertyValueCDesCArray(desArrayAdr);
+  	CleanupStack::Pop(desArrayAdr);
+	CleanupStack::PushL(valueAdr);
+	CParserGroupedProperty* property11 = CParserGroupedProperty::NewL(*valueAdr, KVersitTokenADR, NULL, arrayOfParams11);
+	CleanupStack::Pop(valueAdr);
+	CleanupStack::PushL(property11);
+	vCardParser->AddPropertyL(property11);
+	CleanupStack::Pop(property11);
+
+	//property 12
+	CArrayPtr<CParserParam>* arrayOfParams12 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam12 = CParserParam::NewL(KWORK, KNullDesC8);
+	CleanupStack::PushL(parserParam12);
+	arrayOfParams12->AppendL(parserParam12);
+	CleanupStack::Pop(parserParam12);
+	CParserPropertyValue* value12 = CParserPropertyValueHBufC::NewL(KLONGLAB);
+	CleanupStack::PushL(value12);
+	CParserGroupedProperty* property12 = CParserGroupedProperty::NewL(*value12, KVersitTokenLABEL, NULL, arrayOfParams12);
+	CleanupStack::Pop(value12);
+	CleanupStack::PushL(property12);
+	vCardParser->AddPropertyL(property12);
+	CleanupStack::Pop(property12);
+
+	//property 13
+
+	CArrayPtr<CParserParam>* arrayOfParams13 = new(ELeave) CArrayPtrFlat<CParserParam>(3);
+	CParserParam* parserParam13A = CParserParam::NewL(KPOSTAL, KNullDesC8);
+	CleanupStack::PushL(parserParam13A);
+	arrayOfParams13->AppendL(parserParam13A);
+	CleanupStack::Pop(parserParam13A);
+	CParserParam* parserParam13B = CParserParam::NewL(KHOME, KNullDesC8);
+	CleanupStack::PushL(parserParam13B);
+	arrayOfParams13->AppendL(parserParam13B);
+	CleanupStack::Pop(parserParam13B);
+	CDesCArrayFlat* desArrayAdr1 = new (ELeave) CDesCArrayFlat(3);
+	CleanupStack::PushL(desArrayAdr1);
+	desArrayAdr1->AppendL(KNullDesC);  
+	desArrayAdr1->AppendL(KADSFIELD1);  
+	desArrayAdr1->AppendL(KADSFIELD2);
+	desArrayAdr1->AppendL(KNullDesC);  
+	desArrayAdr1->AppendL(KADSFIELD3); 
+	CParserPropertyValue* valueAdr1=new (ELeave) CParserPropertyValueCDesCArray(desArrayAdr1);
+  	CleanupStack::Pop(desArrayAdr1);
+	CleanupStack::PushL(valueAdr1);
+	CParserGroupedProperty* property13 = CParserGroupedProperty::NewL(*valueAdr1, KVersitTokenADR, NULL, arrayOfParams13);
+	CleanupStack::Pop(valueAdr1);
+	CleanupStack::PushL(property13);
+	vCardParser->AddPropertyL(property13);
+	CleanupStack::Pop(property13);
+
+	//property 14
+	CArrayPtr<CParserParam>* arrayOfParams14 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam14 = CParserParam::NewL(KHOME, KNullDesC8);
+	CleanupStack::PushL(parserParam14);
+	arrayOfParams14->AppendL(parserParam14);
+	CleanupStack::Pop(parserParam14);
+	CParserPropertyValue* value14 = CParserPropertyValueHBufC::NewL(KLONGLAB);
+	CleanupStack::PushL(value14);
+	CParserGroupedProperty* property14 = CParserGroupedProperty::NewL(*value14, KVersitTokenLABEL, NULL, arrayOfParams14);
+	CleanupStack::Pop(value14);
+	CleanupStack::PushL(property14);
+	vCardParser->AddPropertyL(property14);
+	CleanupStack::Pop(property14);
+
+	//property 15
+	CParserPropertyValue* value15 = CParserPropertyValueHBufC::NewL(KNUM);
+	CleanupStack::PushL(value15);
+	CParserGroupedProperty* property15 = CParserGroupedProperty::NewL(*value15, KVersitTokenXWABGENDER, NULL, NULL);
+	CleanupStack::Pop(value15);
+	CleanupStack::PushL(property15);
+	vCardParser->AddPropertyL(property15);
+	CleanupStack::Pop(property15);
+
+	//property 16
+	CParserPropertyValue* value16 = CParserPropertyValueHBufC::NewL(KVersitTokenEmpty);
+	CleanupStack::PushL(value16);
+	CParserGroupedProperty* property16 = CParserGroupedProperty::NewL(*value16, KVersitTokenURL, NULL, NULL);
+	CleanupStack::Pop(value16);
+	CleanupStack::PushL(property16);
+	vCardParser->AddPropertyL(property16);
+	CleanupStack::Pop(property16);
+
+	//property 17
+	CParserPropertyValue* value17 = CParserPropertyValueHBufC::NewL(KADSINTER);
+	CleanupStack::PushL(value17);
+	CParserGroupedProperty* property17 = CParserGroupedProperty::NewL(*value17, KVersitTokenURL, NULL, NULL);
+	CleanupStack::Pop(value17);
+	CleanupStack::PushL(property17);
+	vCardParser->AddPropertyL(property17);
+	CleanupStack::Pop(property17);
+
+	//property 18
+	CParserPropertyValue* value18 = CParserPropertyValueHBufC::NewL(KDATE);
+	CleanupStack::PushL(value18);
+	CParserGroupedProperty* property18 = CParserGroupedProperty::NewL(*value18, KVersitTokenBDAY, NULL, NULL);
+	CleanupStack::Pop(value18);
+	CleanupStack::PushL(property18);
+	vCardParser->AddPropertyL(property18);
+	CleanupStack::Pop(property18);
+
+	//property 19
+	CArrayPtr<CParserParam>* arrayOfParams19 = new(ELeave) CArrayPtrFlat<CParserParam>(2);
+	CParserParam* parserParam19A = CParserParam::NewL(KPREF, KNullDesC8);
+	CleanupStack::PushL(parserParam19A);
+	arrayOfParams19->AppendL(parserParam19A);
+	CleanupStack::Pop(parserParam19A);
+	CParserParam* parserParam19B= CParserParam::NewL(KVersitTokenINTERNET, KNullDesC8);
+	CleanupStack::PushL(parserParam19B);
+	arrayOfParams19->AppendL(parserParam19B);
+	CleanupStack::Pop(parserParam19B);
+	CParserPropertyValue* value19 = CParserPropertyValueHBufC::NewL(KEMAIL);
+	CleanupStack::PushL(value19);
+	CParserGroupedProperty* property19 = CParserGroupedProperty::NewL(*value19, KVersitTokenEMAIL, NULL, arrayOfParams19);
+	CleanupStack::Pop(value19);
+	CleanupStack::PushL(property19);
+	vCardParser->AddPropertyL(property19);
+	CleanupStack::Pop(property19);
+
+	//property 20
+	CArrayPtr<CParserParam>* arrayOfParams20 = new(ELeave) CArrayPtrFlat<CParserParam>(1);
+	CParserParam* parserParam20= CParserParam::NewL(KVersitTokenINTERNET, KNullDesC8);
+	CleanupStack::PushL(parserParam20);
+	arrayOfParams20->AppendL(parserParam20);
+	CleanupStack::Pop(parserParam20);
+	CParserPropertyValue* value20 = CParserPropertyValueHBufC::NewL(KEMAIL);
+	CleanupStack::PushL(value20);
+	CParserGroupedProperty* property20 = CParserGroupedProperty::NewL(*value20, KVersitTokenEMAIL, NULL, arrayOfParams20);
+	CleanupStack::Pop(value20);
+	CleanupStack::PushL(property20);
+	vCardParser->AddPropertyL(property20);
+	CleanupStack::Pop(property20);
+
+	//property 21
+	CParserPropertyValue* value21 = CParserPropertyValueHBufC::NewL(KTIME);
+	CleanupStack::PushL(value21);
+	CParserGroupedProperty* property21 = CParserGroupedProperty::NewL(*value21, KVersitTokenREV, NULL, NULL);
+	CleanupStack::Pop(value21);
+	CleanupStack::PushL(property21);
+	vCardParser->AddPropertyL(property21);
+	CleanupStack::Pop(property21);
+
+	_LIT(KvCard,".VCF");
+
+	TFileName fullNameFile;
+	fullNameFile=KTestDirOutput;
+	fullNameFile.Append(aFileName);
+	fullNameFile.Append(KvCard);
+	vCardParser->SetDefaultCharSet(aCharset);
+	ExternaliseFileL(*vCardParser, fullNameFile);
+
+	numAllocAfter = myHeap.iAllocCount;
+	numCellsAfter = heap.AllocSize(sizeInBytesAfter);
+	aResult.NumAlloExt = numAllocAfter - numAllocBefore;
+	aResult.IncreasedCells = numCellsAfter - numCellsBefore;
+	aResult.IncreasedSizeInBytes = sizeInBytesAfter - sizeInBytesBefore;
+	CleanupStack::PopAndDestroy(vCardParser);
+	}
+
+void CTests::TestVCalMemoryUsageByAddingEntitiesL(TInt aNumOfEntry,SPrintResult& aResult)
+	{
+	_LIT(KVCalTestFile, "VCalWithAddedEntries");
+	_LIT(KvCal,".VCS");
+
+	TInt numCellsBefore, numCellsAfter, sizeInBytesBefore, sizeInBytesAfter, numAllocBefore, numAllocAfter;
+	RHeap& heap = User::Heap();
+	SRHeapCopy& myHeap = REINTERPRET_CAST(SRHeapCopy&, heap);
+	numCellsBefore = heap.AllocSize(sizeInBytesBefore);
+	numAllocBefore = myHeap.iAllocCount; 
+
+	CParserVCal* vCalParser = CParserVCal::NewL();
+	CleanupStack::PushL(vCalParser);
+	for(TInt i=0;i<aNumOfEntry/2;i++)
+		{
+		CParserVCalEntity* entityEvent = CParserVCalEntity::NewL();
+		CleanupStack::PushL(entityEvent);
+		CreateEntityEventEntryL(*entityEvent);
+		CleanupStack::Pop(entityEvent);
+		vCalParser->AddEntityL(entityEvent);
+		}
+	TInt mumTodo=aNumOfEntry/2+aNumOfEntry%2;
+	for(TInt j=0;j<mumTodo;j++)
+		{
+		CParserVCalEntity* entityTodo = CParserVCalEntity::NewL();
+		CleanupStack::PushL(entityTodo);
+		CreateEntityTodoEntryL(*entityTodo);
+		CleanupStack::Pop(entityTodo);
+		vCalParser->AddEntityL(entityTodo);
+		}
+
+	//creating an output file and externalise all the data (properties)
+	//that have just been created
+	TBuf<2> numString;
+	numString.Num(aNumOfEntry);
+	TFileName fullNameFile;
+	fullNameFile=KTestDirOutput;
+	fullNameFile.Append(KVCalTestFile);
+	fullNameFile.Append(numString);
+	fullNameFile.Append(KvCal);
+	RFile file;
+	CleanupClosePushL(file);//file
+	ExternaliseFileL(*vCalParser, fullNameFile);
+
+	numAllocAfter = myHeap.iAllocCount;
+	numCellsAfter = heap.AllocSize(sizeInBytesAfter);
+	aResult.NumAlloExt = numAllocAfter - numAllocBefore;
+	aResult.IncreasedCells = numCellsAfter - numCellsBefore;
+	aResult.IncreasedSizeInBytes = sizeInBytesAfter - sizeInBytesBefore;
+ 	CleanupStack::PopAndDestroy(2,vCalParser);
+	}
+
+void CTests::CreateEntityEventEntryL(CParserVCalEntity& aEntity)
+	{
+	_LIT(KTIME, "19991101T000000Z");
+
+	aEntity.SetEntityNameL(KVersitVarTokenVEVENT);
+
+	//property 1 within same entity
+	CParserPropertyValue* value1 = CParserPropertyValueHBufC::NewL(_L("APPOINTMENT"));
+	CleanupStack::PushL(value1);
+	CParserProperty* property1 = CParserProperty::NewL(*value1, KVersitTokenAGENDAENTRYTYPE, NULL);
+	CleanupStack::Pop(value1);
+	CleanupStack::PushL(property1);
+	aEntity.AddPropertyL(property1);
+	CleanupStack::Pop(property1);
+	
+	//property 2 within same entity
+	CParserPropertyValue* value2 = CParserPropertyValueHBufC::NewL(_L("app engines weekly meeting APPOINTMENT"));
+	CleanupStack::PushL(value2);
+	CParserProperty* property2 = CParserProperty::NewL(*value2, KVersitTokenDESCRIPTION, NULL);
+	CleanupStack::Pop(value2);
+	CleanupStack::PushL(property2);
+	aEntity.AddPropertyL(property2);
+	CleanupStack::Pop(property2);
+
+	//property 3 within same entity
+	CParserPropertyValue* value3 = CParserPropertyValueHBufC::NewL(_L("2"));
+	CleanupStack::PushL(value3);
+	CParserProperty* property3 = CParserProperty::NewL(*value3, KVersitTokenUID, NULL);
+	CleanupStack::Pop(value3);
+	CleanupStack::PushL(property3);
+	aEntity.AddPropertyL(property3);
+	CleanupStack::Pop(property3);
+
+	CArrayPtr<CParserParam>* arrayOfParams4 = new(ELeave) CArrayPtrFlat<CParserParam>(1);
+	CParserParam* parserParam4 = CParserParam::NewL(KVersitTokenSOUND, KNullDesC8);
+	CleanupStack::PushL(parserParam4);
+	arrayOfParams4->AppendL(parserParam4);
+	CleanupStack::Pop(parserParam4);
+
+	TDateTime date(2001,ENovember,1,0,15,0,0);
+	TVersitDateTime* runtime = new(ELeave) TVersitDateTime(date, TVersitDateTime::EIsMachineLocal);
+	CleanupStack::PushL(runtime);
+	CVersitAlarm* value4 = CVersitAlarm::NewL(runtime,0,0,_L("Fanfare"),KNullDesC);
+	CleanupStack::Pop(runtime);
+	CleanupStack::PushL(value4);
+
+	CParserPropertyValueAlarm* alarmValue4 = new(ELeave) CParserPropertyValueAlarm(value4);
+	CleanupStack::Pop(value4);
+	CleanupStack::PushL(alarmValue4);
+	CParserProperty* property4 = CParserProperty::NewL(*alarmValue4, KVersitTokenAALARM, arrayOfParams4);
+	CleanupStack::Pop(alarmValue4);
+	CleanupStack::PushL(property4);
+	aEntity.AddPropertyL(property4);
+	CleanupStack::Pop(property4);
+
+	//property 5 within same entity
+	CParserPropertyValue* value5 = CParserPropertyValueHBufC::NewL(_L("PUBLIC"));
+	CleanupStack::PushL(value5);
+	CParserProperty* property5 = CParserProperty::NewL(*value5, KVersitTokenCLASS, NULL);
+	CleanupStack::Pop(value5);
+	CleanupStack::PushL(property5);
+	aEntity.AddPropertyL(property5);
+	CleanupStack::Pop(property5);
+
+	//property 6 within same entity
+	CParserPropertyValue* value6 = CParserPropertyValueHBufC::NewL(_L("19991101T000000Z"));
+	CleanupStack::PushL(value6);
+	CParserProperty* property6 = CParserProperty::NewL(*value6, KVersitTokenDCREATED, NULL);
+	CleanupStack::Pop(value6);
+	CleanupStack::PushL(property6);
+	aEntity.AddPropertyL(property6);
+	CleanupStack::Pop(property6);
+
+	//property 7 within same entity
+	CParserPropertyValue* value7 = CParserPropertyValueHBufC::NewL(KTIME);
+	CleanupStack::PushL(value7);
+	CParserProperty* property7 = CParserProperty::NewL(*value7, KVersitTokenLASTMODIFIED, NULL);
+	CleanupStack::Pop(value7);
+	CleanupStack::PushL(property7);
+	aEntity.AddPropertyL(property7);
+	CleanupStack::Pop(property7);
+
+	//property 8 within same entity
+	CParserPropertyValue* value8 = CParserPropertyValueHBufC::NewL(KTIME);
+	CleanupStack::PushL(value8);
+	CParserProperty* property8 = CParserProperty::NewL(*value8, KVersitTokenDTSTART, NULL);
+	CleanupStack::Pop(value8);
+	CleanupStack::PushL(property8);
+	aEntity.AddPropertyL(property8);
+	CleanupStack::Pop(property8);
+
+	//property 9 within same entity
+	CParserPropertyValue* value9 = CParserPropertyValueHBufC::NewL(KTIME);
+	CleanupStack::PushL(value9);
+	CParserProperty* property9 = CParserProperty::NewL(*value9, KVersitTokenDTEND, NULL);
+	CleanupStack::Pop(value9);
+	CleanupStack::PushL(property9);
+	aEntity.AddPropertyL(property9);
+	CleanupStack::Pop(property9);
+	}
+
+
+void CTests::CreateEntityTodoEntryL(CParserVCalEntity& aEntity)
+	{
+	aEntity.SetEntityNameL(KVersitVarTokenVTODO);
+	
+	//property 1 within same entity
+	CParserPropertyValue* value1 = CParserPropertyValueHBufC::NewL(_L("APPOINTMENT"));
+	CleanupStack::PushL(value1);
+	CParserProperty* property1 = CParserProperty::NewL(*value1, KVersitTokenAGENDAENTRYTYPE, NULL);
+	CleanupStack::Pop(value1);
+	CleanupStack::PushL(property1);
+	aEntity.AddPropertyL(property1);
+	CleanupStack::Pop(property1);
+
+	//property 2 within same entity
+	CParserPropertyValue* value2= CParserPropertyValueHBufC::NewL(_L("meeting with Nokia APPOINTMENT"));
+	CleanupStack::PushL(value2);
+	CParserProperty* property2 = CParserProperty::NewL(*value2, KVersitTokenDESCRIPTION, NULL);
+	CleanupStack::Pop(value2);
+	CleanupStack::PushL(property2);
+	aEntity.AddPropertyL(property2);
+	CleanupStack::Pop(property2);
+
+	//property 3 within same entity
+	CParserPropertyValue* value3 = CParserPropertyValueHBufC::NewL(_L("3"));
+	CleanupStack::PushL(value3);
+	CParserProperty* property3 = CParserProperty::NewL(*value3, KVersitTokenUID, NULL);
+	CleanupStack::Pop(value3);
+	CleanupStack::PushL(property3);
+	aEntity.AddPropertyL(property3);
+	CleanupStack::Pop(property3);
+
+	//property 4 within same entity
+	CParserPropertyValue* value4 = CParserPropertyValueHBufC::NewL(_L("PUBLIC"));
+	CleanupStack::PushL(value4);
+	CParserProperty* property4 = CParserProperty::NewL(*value4, KVersitTokenCLASS, NULL);
+	CleanupStack::Pop(value4);
+	CleanupStack::PushL(property4);
+	aEntity.AddPropertyL(property4);
+	CleanupStack::Pop(property4);
+
+	//property 5 within same entity
+	CParserPropertyValue* value5 = CParserPropertyValueHBufC::NewL(_L("19991101T000000Z"));
+	CleanupStack::PushL(value5);
+	CParserProperty* property5 = CParserProperty::NewL(*value5, KVersitTokenDCREATED, NULL);
+	CleanupStack::Pop(value5);
+	CleanupStack::PushL(property5);
+	aEntity.AddPropertyL(property5);
+	CleanupStack::Pop(property5);
+
+	//property 6 within same entity
+	CParserPropertyValue* value6 = CParserPropertyValueHBufC::NewL(_L("19991101T130400Z"));
+	CleanupStack::PushL(value6);
+	CParserProperty* property6 = CParserProperty::NewL(*value6, KVersitTokenLASTMODIFIED, NULL);
+	CleanupStack::Pop(value6);
+	CleanupStack::PushL(property6);
+	aEntity.AddPropertyL(property6);
+	CleanupStack::Pop(property6);
+
+
+	//property 7 within same entity
+	CParserPropertyValue* value7 = CParserPropertyValueHBufC::NewL(_L("19991101T100000Z"));
+	CleanupStack::PushL(value7);
+	CParserProperty* property7 = CParserProperty::NewL(*value7, KVersitTokenDTSTART, NULL);
+	CleanupStack::Pop(value7);
+	CleanupStack::PushL(property7);
+	aEntity.AddPropertyL(property7);
+	CleanupStack::Pop(property7);
+
+	//property 8 within same entity
+	CParserPropertyValue* value8 = CParserPropertyValueHBufC::NewL(_L("19991001T113000Z"));
+	CleanupStack::PushL(value8);
+	CParserProperty* property8 = CParserProperty::NewL(*value8, KVersitTokenDTEND, NULL);
+	CleanupStack::Pop(value8);
+	CleanupStack::PushL(property8);
+	aEntity.AddPropertyL(property8);
+	CleanupStack::Pop(property8);
+	}
+
+void CTests::TestIntExtFileL(TDataType aDataType)
+	{
+	//wild cards for searching testing files and store the profiling result in different files
+	_LIT(KvCardFile,"File*.vcf");
+	_LIT(KvCalFile,"File*.vcs");
+	_LIT(KvCardLine,"Line*.vcf");
+	_LIT(KvCalLine,"Line*.vcs");
+	_LIT(KvCardResultFile,"Int&Ext_vCardFile_com");
+	_LIT(KvCalResultFile,"Int&Ext_vCalFile_com");
+	_LIT(KvCardResultLine,"Int&Ext_vCardLine_com");
+	_LIT(KvCalResultLine,"Int&Ext_vCalLine_com");
+
+	TFileName dataFile;
+	TFileName resultFile;
+	resultFile=KTestDirResult;
+	switch (aDataType)
+		{
+		case ETvCardFile:
+			dataFile=KvCardFile;
+			resultFile.Append(KvCardResultFile);
+			break;
+		case ETvCalFile:
+			dataFile=KvCalFile;
+			resultFile.Append(KvCalResultFile);
+			break;
+		case ETvCardLine:
+			dataFile=KvCardLine;
+			resultFile.Append(KvCardResultLine);
+			break;
+		case ETvCalLine:
+			dataFile=KvCalLine;
+			resultFile.Append(KvCalResultLine);
+			break;
+		}
+	resultFile.Append(KTestFileNameExt);
+
+	TFindFile* findFile = new(ELeave) TFindFile(iFsSession);
+	CleanupStack::PushL(findFile);//findFile
+	CDir* directory=NULL;
+
+	User::LeaveIfError(findFile->FindWildByDir(dataFile,KTestDirInput,directory));
+	CleanupStack::PopAndDestroy(findFile);//findFile
+	CleanupStack::PushL(directory);//directory
+	RFile file;
+	User::LeaveIfError(file.Replace(iFsSession, resultFile,EFileWrite+EFileShareAny+EFileStreamText));
+	CleanupClosePushL(file);//file
+
+	TBuf<200> title;
+	title.Format(_L("file name\tinternalize\texternalize\ttotal time\tnum of obj\theap size\tnum. Alloc int\tnum. Alloc ext\x0d\x0a"));
+	TheTest.Printf(title);
+	TBuf8<200> title8;
+	title8.Copy(title);
+	file.Write(title8);
+
+	TInt numberOfFiles=directory->Count();
+	CleanupStack::PopAndDestroy(2,directory);
+	}
+
+//@SYMTestCaseID PIM-TPERFOMANCE-0001
+	
+GLDEF_C TInt E32Main()
+	{
+	
+	TTime startTime;
+	startTime.UniversalTime();
+	
+	__UHEAP_MARK;
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	if	(!cleanup)
+		return KErrNoMemory;
+	TheTest.Start(_L("@SYMTestCaseID PIM-TPERFOMANCE-0001 Performance Test"));
+	
+	TRAPD(err,CTests::DoTestsL());
+#if !defined(__WINS__)
+	if (err!=KErrNone)
+		{
+		_LIT(KError,"Test left with error %d\r\n");
+		TheTest.Printf(KError,err);
+		TheTest.Getch();
+		}
+#endif
+	TheTest(err == KErrNone);
+	TheTest.Printf(_L("Test complete\r\n"));
+	User::After(3000000);
+	TheTest.End();
+	TheTest.Close();
+
+	delete cleanup;
+	__UHEAP_MARKEND;
+	
+	TTime finishTime;
+	finishTime.UniversalTime();
+	TReal elapsed = (TReal)finishTime.MicroSecondsFrom(startTime).Int64();
+	TheTest.Printf(_L("Elapsed time: %.4f\n"), elapsed/1000000);
+	
+	return (KErrNone);
+	}