// 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);