// Copyright (c) 2005-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:

// @internalComponent

// 

//

#include <e32std.h>

#include <e32base.h>

#include <e32test.h>

#include <f32file.h>

#include <bsul/inifile.h>	// CIniDocument8, CIniDocument16

RTest test(_L("Ini File Parser and Generator"));

RFs TheRFs;

using namespace BSUL;

#define UNUSED_VAR(a) a=a

_LIT(KIniFile16,"z:\\resource\\testconfig16.ini")	;

void LeaveIfNoMemory(TInt ret)

	{

	if (ret==KErrNoMemory)

		User::LeaveNoMemory();

	}

void CheckResources(RFs& aFs, TInt aOriginalHandleCount)

	{

	UNUSED_VAR(aOriginalHandleCount);

	//check we haven't leaked any handles

	TInt processHandleCount = 0;

	TInt threadHandleCount = 0;

	RThread().HandleCount(processHandleCount, threadHandleCount);

	test(threadHandleCount == aOriginalHandleCount);

	//check we haven't leaked any files

	aFs.ResourceCountMarkEnd();	

	}

TBool CompareFilesL(RFs& aFs,const TDesC& aFileNameA,const TDesC& aFileNameB)

	{

	TBool filesAreSame=FALSE;

	RFile fileA;

	User::LeaveIfError(fileA.Open(aFs,aFileNameA,EFileShareReadersOrWriters ));

	CleanupClosePushL(fileA);

	RFile fileB;

	User::LeaveIfError(fileB.Open(aFs,aFileNameB,EFileShareReadersOrWriters ));

	CleanupClosePushL(fileB);

	TInt filesizeA=0;

	TInt filesizeB=0;

	fileA.Size(filesizeA);

	fileB.Size(filesizeB);

	if ( filesizeA == filesizeB)

		{

		HBufC8* aBufferPtrA=HBufC8::NewLC(filesizeA);

		HBufC8* aBufferPtrB=HBufC8::NewLC(filesizeB);

		TPtr8 asWriteableBufferA(aBufferPtrA->Des());

		User::LeaveIfError(fileA.Read(0,asWriteableBufferA,filesizeA));

		TPtr8 asWriteableBufferB(aBufferPtrB->Des());

		User::LeaveIfError(fileB.Read(0,asWriteableBufferB,filesizeB));

		if (asWriteableBufferA.Compare(asWriteableBufferB) == 0)

			{

			filesAreSame=TRUE;

			}

		CleanupStack::PopAndDestroy(2);

		}

	CleanupStack::PopAndDestroy(2);	

	return filesAreSame;

	}

class CIniParser16Test :public CBase

{

typedef void (CIniParser16Test::*ClassFuncPtr8L) (void);

public:

	static CIniParser16Test* NewL();

	~CIniParser16Test()

	{

	if (iIniDocument)

		{

		delete iIniDocument;

		iIniDocument=NULL;

		}

	}

	//heavy create and delete

	static void CreateDeleteTest1L();

	static void CreateDeleteOOMTestL();	

	//light

	static void CreateDeleteTest2L();

	static void CreateDeleteOOMTest2L();	

	//List of tests

	//heavy

	void DoTest1L();

	void DoTest2L();

	void DoTest3L();

	void DoTest4L();

	void DoTest5L();

	void DoTest6L();

	void DoTest7L();

	void DoTest8L();

	void DoTest9L();

	//light

	void DoTest10L();

	void DoTest11L();

	//OOM consistency test

	void DoTest12L();

	//class function utilities

	static void DoBasicTestL(ClassFuncPtr8L testFuncL, const TDesC& aTestDesc);	

	static void DoOOMTestL(ClassFuncPtr8L testFuncL, const TDesC& aTestDesc);

	static void DoOOMWithConsistencyCheckTestL(ClassFuncPtr8L testFuncL, const TDesC& aTestDesc,const TBool aShouldBeSame);

private:

	CIniParser16Test():iIniDocument(NULL){}

	CIniDocument16* iIniDocument;

};

CIniParser16Test* CIniParser16Test::NewL()

	{

	CIniParser16Test* self=new (ELeave)CIniParser16Test();

	CleanupStack::PushL(self);

	self->iIniDocument=CIniDocument16::NewL(TheRFs,KIniFile16);		

	CleanupStack::Pop();

	return self;

	}

void CIniParser16Test::DoBasicTestL(ClassFuncPtr8L testFuncL, const TDesC& aTestDesc)

	{

	test.Next(aTestDesc);

	__UHEAP_MARK;

  	// find out the number of open handles

	TInt startProcessHandleCount;

	TInt startThreadHandleCount;

	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

	CIniParser16Test* iniTest=CIniParser16Test::NewL();

	CleanupStack::PushL(iniTest);

	(iniTest->*testFuncL)();

	CleanupStack::PopAndDestroy();

	// check that no handles have leaked

	TInt endProcessHandleCount;

	TInt endThreadHandleCount;

	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	test(startProcessHandleCount == endProcessHandleCount);

	test(startThreadHandleCount  == endThreadHandleCount);

	__UHEAP_MARKEND;

	}

void CIniParser16Test::DoOOMTestL(ClassFuncPtr8L testFuncL, const TDesC& aTestDesc)

	{

	test.Next(aTestDesc);

	TInt err;

	TInt tryCount = 0;

	do

		{

		__UHEAP_MARK;

  		// find out the number of open handles

		TInt startProcessHandleCount;

		TInt startThreadHandleCount;

		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

		CIniParser16Test* iniTest=CIniParser16Test::NewL();

		CleanupStack::PushL(iniTest);

		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

		TRAP(err, (iniTest->*testFuncL)());

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		CleanupStack::PopAndDestroy(iniTest);

		iniTest=NULL;

		// check that no handles have leaked

		TInt endProcessHandleCount;

		TInt endThreadHandleCount;

		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

		test(startProcessHandleCount == endProcessHandleCount);

		test(startThreadHandleCount  == endThreadHandleCount);

		__UHEAP_MARKEND;

		} while(err == KErrNoMemory);

 	test(err==KErrNone);

	test.Printf(_L("- succeeded at heap failure rate of %i\n"), tryCount);

	}

void CIniParser16Test::CreateDeleteOOMTestL()

	{

	TInt err;

	TInt tryCount = 0;

	do

		{

		__UHEAP_MARK;

		// find out the number of open handles

		TInt startProcessHandleCount;

		TInt startThreadHandleCount;

		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

		CIniDocument16* ini=NULL;

		TRAP(err,ini=CIniDocument16::NewL(TheRFs,KIniFile16));

		delete ini;

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		// check that no handles have leaked

		TInt endProcessHandleCount;

		TInt endThreadHandleCount;

		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

		test(startProcessHandleCount == endProcessHandleCount);

		test(startThreadHandleCount  == endThreadHandleCount);

		__UHEAP_MARKEND;

		} while(err == KErrNoMemory);

	test(err==KErrNone);

	test.Printf(_L("- succeeded at heap failure rate of %i\n"), tryCount);	

	}

void CIniParser16Test::DoOOMWithConsistencyCheckTestL(ClassFuncPtr8L testFuncL, const TDesC& aTestDesc, const TBool aShouldBeSame)

	{

	test.Next(aTestDesc);

	// find out the number of open handles

	TInt startProcessHandleCount = 0;

	TInt startThreadHandleCount = 0;

	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

	//Compare the results against this instance.

	TInt err;

	CIniDocument16* referenceDoc=NULL;

	TRAP(err,referenceDoc=CIniDocument16::NewL(TheRFs,KIniFile16));

	User::LeaveIfError(err);

	CleanupStack::PushL(referenceDoc);

	//Open a file and Externalise the reference oom to it.

	User::LeaveIfError(referenceDoc->Externalise(_L("c:\\initest\\oom_ref16.ini")));

	CIniParser16Test* iniTest=NULL;

	for (TInt i = 1;;i++)

		{

		__UHEAP_FAILNEXT(i);

		__UHEAP_MARK;

		TRAP(err, iniTest=CIniParser16Test::NewL());

		if (err != KErrNone)

			continue;

		CleanupStack::PushL(iniTest);

		TRAP(err, (iniTest->*testFuncL)());

		if (err != KErrNone)

			{

			test(iniTest->iIniDocument->CompareDocs(*referenceDoc));

			CleanupStack::PopAndDestroy(iniTest);

			__UHEAP_SETFAIL(RHeap::ENone, 0);

			__UHEAP_MARKEND;

			continue;

			}

		else

			{

			//Open a file and Externalise to it.

			TRAP(err, iniTest->iIniDocument->Externalise(_L("c:\\initest\\oom16.ini")));

			if (err != KErrNone)

				{

				CleanupStack::PopAndDestroy(iniTest);

				__UHEAP_SETFAIL(RHeap::ENone, 0);

				__UHEAP_MARKEND;

				continue;

				}

			else

				{

				TBool result=EFalse;

				TRAP(err, result=CompareFilesL(TheRFs,_L("c:\\initest\\oom_ref16.ini"), _L("c:\\initest\\oom16.ini")));

				if (err != KErrNone)

					{

					CleanupStack::PopAndDestroy(iniTest);

					__UHEAP_SETFAIL(RHeap::ENone, 0);

					__UHEAP_MARKEND;

					continue;

					}

				test(result == aShouldBeSame);

				}

			}

		CleanupStack::PopAndDestroy(iniTest);

		//check we haven't leaked any heap memory

		__UHEAP_MARKEND;

		CheckResources(TheRFs, startThreadHandleCount);

		if (err != KErrNoMemory)

			{

			test(err == KErrNone);

			break;		// we reach here if we are unable to create the OOM condition.

			}

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		}

	__UHEAP_RESET;

	CleanupStack::PopAndDestroy(referenceDoc);

	test.Printf(_L("Completed consistency check."));

	}

void CIniParser16Test::CreateDeleteTest1L()

	{

	__UHEAP_MARK;

	CIniDocument16* ini=NULL;

	//note only support 16 bit Little Endian ini file

	ini=CIniDocument16::NewL(TheRFs,KIniFile16);

	delete ini;

	__UHEAP_MARKEND;

	}

void CIniParser16Test::CreateDeleteOOMTest2L()

	{

	TInt err;

	TInt tryCount = 0;

	do

		{

		__UHEAP_MARK;

		// find out the number of open handles

		TInt startProcessHandleCount;

		TInt startThreadHandleCount;

		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

		CIniFile16* ini=NULL;

		TRAP(err,ini=CIniFile16::NewL(TheRFs,KIniFile16));

		delete ini;

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		// check that no handles have leaked

		TInt endProcessHandleCount;

		TInt endThreadHandleCount;

		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

		test(startProcessHandleCount == endProcessHandleCount);

		test(startThreadHandleCount  == endThreadHandleCount);

		__UHEAP_MARKEND;

		} while(err == KErrNoMemory);

	test(err==KErrNone);

	test.Printf(_L("- succeeded at heap failure rate of %i\n"), tryCount);	

	}

void CIniParser16Test::CreateDeleteTest2L()

	{

	__UHEAP_MARK;

	CIniFile16* ini=NULL;

	//note only support 16 bit Little Endian ini file

	ini=CIniFile16::NewL(TheRFs,KIniFile16);

	delete ini;

	__UHEAP_MARKEND;

	}	

void CIniParser16Test::DoTest1L()

	{

	//Testing GetSectionList API

	RArray<TPtrC16> sectionNames;

	User::LeaveIfError(iIniDocument->GetSectionList(sectionNames));

	test(sectionNames.Count()==8);	

	//Testing the sectionNames in name order

	test(sectionNames[0].Compare(_L("1"))==0);

	test(sectionNames[1].Compare(_L("MAPPINGS"))==0);

	test(sectionNames[2].Compare(_L("MEDIA"))==0);

	test(sectionNames[3].Compare(_L("OUTPUT_CHANNELS"))==0);

	test(sectionNames[4].Compare(_L("SERVERS"))==0);

	test(sectionNames[5].Compare(_L("SWTRACER"))==0);

	test(sectionNames[6].Compare(_L("test_section"))==0);

	test(sectionNames[7].Compare(_L("test_twosection"))==0);	

	sectionNames.Reset();

	}

void CIniParser16Test::DoTest2L()

	{

	//Test GetKeyValue API

	TPtrC16 value;

	User::LeaveIfError(iIniDocument->GetKeyValue(_L("MEDIA"),_L("RDebug"),value));

	test(value.Compare(_L("SwtRDebugPlugin.dll"))==0);

	User::LeaveIfError(iIniDocument->GetKeyValue(_L("OUTPUT_CHANNELS"),_L("1"),value));

	test(value.Compare(_L("RDebug"))==0);

	User::LeaveIfError(iIniDocument->GetKeyValue(_L("1"),_L("new_setting"),value));

	test(value.Compare(_L("value \\n value1\\t value2"))==0);

	//unknown section

	TInt ret=KErrNone;

	ret=iIniDocument->GetKeyValue(_L("mySection"),_L("mykey"),value);

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);

	//unknown key

	ret=iIniDocument->GetKeyValue(_L("MEDIA"),_L("mykey"),value);

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);	

	//empty value

	ret=iIniDocument->GetKeyValue(_L("SERVERS"),_L("SWTRACER"),value);

	LeaveIfNoMemory(ret);

	test(value.Length()==0);	

	}

void CIniParser16Test::DoTest3L()

	{

	//Test AddSection API

	RArray<TPtrC16> sectionNames;

	CleanupClosePushL(sectionNames);

	User::LeaveIfError(iIniDocument->AddSection(_L("NEW-SECTION")));

	User::LeaveIfError(iIniDocument->GetSectionList(sectionNames));

	test(sectionNames.Count()==9);

	//case sensitive

	User::LeaveIfError(iIniDocument->AddSection(_L("NeW-SECTION")));	

	User::LeaveIfError(iIniDocument->GetSectionList(sectionNames));

	test(sectionNames.Count()==10);	

	//adding existing section, no duplicate allowed

	TInt ret=iIniDocument->AddSection(_L("NEW-SECTION"));

	LeaveIfNoMemory(ret);

	test(ret==KErrAlreadyExists);

	CleanupStack::PopAndDestroy();	

	}

void CIniParser16Test::DoTest4L()

	{

	//Test RemoveSection API

	RArray<TPtrC16> sectionNames;

	CleanupClosePushL(sectionNames);	

	//known section

	User::LeaveIfError(iIniDocument->RemoveSection(_L("SERVERS")));

	User::LeaveIfError(iIniDocument->GetSectionList(sectionNames));

	test(sectionNames.Count()==7);

	//check key inside section is also deleted

	TPtrC16 value;

	TInt ret=iIniDocument->GetKeyValue(_L("SERVERS"),_L("SWTRACER"),value);

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);	

	//unknown section	

	ret=iIniDocument->RemoveSection(_L("AnySection"));

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);

	CleanupStack::PopAndDestroy();		

	}

void CIniParser16Test::DoTest5L()

	{

	//Testing SetKey API

	TPtrC16 value;

	//Modifying existing value

	User::LeaveIfError(iIniDocument->SetKey(_L("MEDIA"),_L("RDebug"),_L("NewPlugin.dll")));

	User::LeaveIfError(iIniDocument->GetKeyValue(_L("MEDIA"),_L("RDebug"),value));

	test(value.Compare(_L("NewPlugin.dll"))==0);

	//nonexist key should be created

	User::LeaveIfError(iIniDocument->SetKey(_L("MEDIA"),_L("newplug"),_L("")));

	User::LeaveIfError(iIniDocument->GetKeyValue(_L("MEDIA"),_L("newplug"),value));		

	test(value.Compare(_L(""))==0);	

	//nonexist section should be created

	User::LeaveIfError(iIniDocument->SetKey(_L("unknown_section"),_L("unknown_key"),_L("unknown_value")));

	User::LeaveIfError(iIniDocument->GetKeyValue(_L("unknown_section"),_L("unknown_key"),value));

	test(value.Compare(_L("unknown_value"))==0);	

	//Testing Externalise to a New file

	User::LeaveIfError(iIniDocument->Externalise(_L("c:\\initest\\output16_1.ini")));

	//Try opening the written ini file now to ensure no corruption in writing

	CIniDocument16* iniReRead=CIniDocument16::NewL(TheRFs,_L("c:\\initest\\output16_1.ini"));

	CleanupStack::PushL(iniReRead);

	User::LeaveIfError(iniReRead->GetKeyValue(_L("unknown_section"),_L("unknown_key"),value));

	test(value.Compare(_L("unknown_value"))==0);	

	User::LeaveIfError(iniReRead->GetKeyValue(_L("MEDIA"),_L("newplug"),value));		

	test(value.Compare(_L(""))==0);	

	CleanupStack::PopAndDestroy(iniReRead);

	}

void CIniParser16Test::DoTest6L()

	{

	//Testing RemoveKey API

	TPtrC16 value;

	//remove existing key

	User::LeaveIfError(iIniDocument->RemoveKey(_L("OUTPUT_CHANNELS"),_L("1")));

	TInt ret=iIniDocument->GetKeyValue(_L("OUTPUT_CHANNELS"),_L("1"),value);

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);	

	//remove non-exist key

	ret=iIniDocument->RemoveKey(_L("OUTPUT_CHANNELS"),_L("1"));

	LeaveIfNoMemory(ret);