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

 	}