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

	test(ret==KErrNotFound);	

	//remove non-exist section

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

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);	

	}

void CIniParser16Test::DoTest7L()

	{

	//Testing iterator class

	CIniSecIter16* iIniSecIter=NULL;

	TInt ret=KErrNone;

	//unknown section

	TRAP(ret,iIniSecIter=CIniSecIter16::NewL(_L("Unknown"),iIniDocument));

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);

	//null document

	TRAP(ret,iIniSecIter=CIniSecIter16::NewL(_L("Unknown"),NULL));

	LeaveIfNoMemory(ret);

	test(ret==KErrArgument);				

	//known section

	iIniSecIter=CIniSecIter16::NewL(_L("test_section"),iIniDocument);

	TPtrC16 key;

	TPtrC16 value;

	//test Next() and End();

	test(!iIniSecIter->End());

	test(iIniSecIter->Next(key,value));

	test(key.Compare(_L("key1"))==0);

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

	test(!iIniSecIter->End());	

	test(iIniSecIter->Next(key,value));

	test(key.Compare(_L("key2"))==0);

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

	test(!iIniSecIter->End());	

	test(iIniSecIter->Next(key,value));

	test(key.Compare(_L("key3"))==0);

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

	test(!iIniSecIter->End());	

	test(iIniSecIter->Next(key,value));

	test(key.Compare(_L("key4"))==0);

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

	test(!iIniSecIter->End());	

	test(iIniSecIter->Next(key,value));

	test(key.Compare(_L("key5"))==0);

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

	test(iIniSecIter->End());	

	test(iIniSecIter->Next(key,value)==EFalse);

	//test Reset()

	iIniSecIter->Reset();

	test(!iIniSecIter->End());	

	test(iIniSecIter->Next(key,value));

	test(key.Compare(_L("key1"))==0);

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

	delete iIniSecIter;

	iIniSecIter=NULL;	

	}

void CIniParser16Test::DoTest8L()

	{

	//Testing Externalise to ROM drive

	TInt ret=iIniDocument->Externalise(_L("z:\\output16.ini"));

	LeaveIfNoMemory(ret);

	test(ret==KErrAccessDenied);

	//Testing Externalise to a New file

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

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

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

	CleanupStack::PushL(output);

	User::LeaveIfError(output->SetKey(_L("Test"),_L("Test"),_L("Test")));

	//Testing Externaliseing to the already exist file

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

	CleanupStack::PopAndDestroy();	

	//Opening an empty file and Externaliseing an empty file

	output=CIniDocument16::NewL(TheRFs,_L("c:\\initest\\unknown16.ini"));

	CleanupStack::PushL(output);

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

	CleanupStack::PopAndDestroy();	

	// Read  it back in and find the additions put in above.

	CIniDocument16* iniReRead=NULL;

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

	CleanupStack::PushL(iniReRead);	

	TPtrC16 value;

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

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

	CleanupStack::PopAndDestroy(iniReRead);

	}

void CIniParser16Test::DoTest9L()

{

	//Test for no leakage when handling corrupt file

	CIniDocument16* ini=NULL;

	TRAPD(err,ini=CIniDocument16::NewL(TheRFs,_L("z:\\resource\\corruptconfig16.ini")));

	LeaveIfNoMemory(err);

	test(err==KErrCorrupt);

	delete ini;

}

void CIniParser16Test::DoTest10L()

{

	TPtrC16 value;

	//open existing ini file

	CIniFile16* ini=CIniFile16::NewL(TheRFs, _L16("z:\\resource\\testconfig16.ini"));

	CleanupStack::PushL(ini);

	//mid section

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key1"),value));

	test(value.Compare(_L16("value1"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key2"),value));

	test(value.Compare(_L16("value2"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key3"),value));

	test(value.Compare(_L16("value3"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key4"),value));

	test(value.Compare(_L16("value4"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key5"),value));

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

	//first section

	User::LeaveIfError(ini->FindVar(_L16("SERVERS"),_L16("SWTRACER"),value));

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

	//last section

	User::LeaveIfError(ini->FindVar(_L16("1"),_L16("timestamps"),value));

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

	User::LeaveIfError(ini->FindVar(_L16("1"),_L16("setting"),value));

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

	CleanupStack::PopAndDestroy();

	//open a non existing file

	TInt ret=KErrNone;

	TRAP(ret,ini=CIniFile16::NewL(TheRFs,_L16("z:\\resource\\nonexist.ini")));	

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);

	//open an empty ini file

	ini=CIniFile16::NewL(TheRFs,_L16("z:\\resource\\empty16.ini"));

	CleanupStack::PushL(ini);	

	ret=ini->FindVar(_L16("empty"),_L16("empty"),value);

	LeaveIfNoMemory(ret);

	test(ret==KErrNotFound);	

	CleanupStack::PopAndDestroy();	

}

void CIniParser16Test::DoTest11L()

	{

	TPtrC16 value;

	//open existing 8 bit ini file with 16 bit reader

	CIniFile16* ini;

	TInt err;

	TRAP(err,ini=CIniFile16::NewL(TheRFs,_L16("z:\\resource\\testconfig8.ini")));

	test(err==KErrCorrupt || err==KErrNoMemory);

	//open existing 8 bit ini file, but allow conversion to 16 bits

	ini=CIniFile16::NewL(TheRFs,_L16("z:\\resource\\testconfig8.ini"),ETrue);

	CleanupStack::PushL(ini);

	//mid section

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key1"),value));

	test(value.Compare(_L16("value1"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key2"),value));

	test(value.Compare(_L16("value2"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key3"),value));

	test(value.Compare(_L16("value3"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key4"),value));

	test(value.Compare(_L16("value4"))==0);

	User::LeaveIfError(ini->FindVar(_L16("test_section"),_L16("key5"),value));

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

	//first section

	User::LeaveIfError(ini->FindVar(_L16("SERVERS"),_L16("SWTRACER"),value));

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

	//last section

	User::LeaveIfError(ini->FindVar(_L16("1"),_L16("timestamps"),value));

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

	User::LeaveIfError(ini->FindVar(_L16("1"),_L16("setting"),value));

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

	CleanupStack::PopAndDestroy();	

	}

void CIniParser16Test::DoTest12L()

	{

	TPtrC16 value;

	// We are trying to invoke an OOM condition for a single operation to test that the operation is atomic. 

	// Under that condition the object should be rolled back to the original state. The resulting document should be the same 

	// as before the condition was invoked. If the test succeeded, a new section should be created at end 

	// (which is nice but not the real focus of the test).

	User::LeaveIfError(iIniDocument->SetKey(_L16("unknown_section3"),_L16("unknown_key3"),_L16("unknown_value3")));

	}

static void DeleteFilesL()

	{

	CFileMan* fileman=CFileMan::NewL(TheRFs);

	fileman->Delete(_L("c:\\initest\\*"));

	delete fileman;

	}

/**

@SYMTestCaseID		SYSLIB-BAFL-CT-1559

@SYMTestCaseDesc 	Test CIniParser16Test

@SYMTestPriority 	High

@SYMTestActions  	Perform component tests on CIniParser16Test (includes OOM)

			Testing all the exported apis.

@SYMTestExpectedResults The test must not fail.

@SYMREQ PREQ505

*/		

static void DoTestL()

	{

	TTime startTime(0), stopTime(0);

	TTimeIntervalMicroSeconds timeTaken;

	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-1559 "));

	DeleteFilesL();

	//16 bit basic testing

	CIniParser16Test::CreateDeleteTest1L();

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest1L,_L("GetSectionList16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest2L,_L("GetKeyValue16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest3L,_L("AddSection16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest4L,_L("RemoveSection16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest5L,_L("SetKeyValue16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest6L,_L("RemoveKey16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest7L,_L("IniSecIter16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest8L,_L("Externalise16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest9L,_L("Corrupt file16"));							

	//16 bit OOM testing

	CIniParser16Test::CreateDeleteOOMTestL();	

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest1L,_L("GetSectionList16-OOM"));

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest2L,_L("GetKeyValue16-OOM"));

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest3L,_L("AddSection16-OOM"));	

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest4L,_L("RemoveSection16-OOM"));

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest5L,_L("SetKeyValue16-OOM"));				

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest6L,_L("RemoveKey16-OOM"));

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest7L,_L("IniSecIter16-OOM"));	

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest8L,_L("Externalise16-OOM"));	

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest9L,_L("Corrupt file16-OOM"));

	//16 bit light basic testing

	CIniParser16Test::CreateDeleteTest2L();

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest10L,_L("Light FindVar16"));

	CIniParser16Test::DoBasicTestL(&CIniParser16Test::DoTest11L,_L("Load 16"));

	//16 bit light OOM testing	

	CIniParser16Test::CreateDeleteOOMTest2L();

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest10L,_L("Light FindVar-OOM16"));

	CIniParser16Test::DoOOMTestL(&CIniParser16Test::DoTest11L,_L("Load 16-OOM"));

	stopTime.UniversalTime();

	timeTaken = stopTime.MicroSecondsFrom(startTime);

	test.Printf(_L("Time taken for Heavy= %d microseconds\n"), timeTaken.Int64() );	

	startTime.UniversalTime();	

	// Consistency checks

	CIniParser16Test::DoOOMWithConsistencyCheckTestL(&CIniParser16Test::DoTest12L,_L("Consistency16-OOMC"), FALSE);

	stopTime.UniversalTime();

	timeTaken = stopTime.MicroSecondsFrom(startTime);

	test.Printf(_L("Time taken for consistency checks= %d microseconds\n"), timeTaken.Int64() );	

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* trapCleanup=CTrapCleanup::New();

	test(TheRFs.Connect()==KErrNone);

	test.Start(_L("Ini File Parser Test"));

	TRAPD(error, DoTestL());

	test(error == KErrNone);

	TheRFs.Close();

	test.End();

	test.Close();

	delete trapCleanup;

	__UHEAP_MARKEND;

	return error;

	}