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

#include <f32file.h>
#include "../../test/t_cenrep_helper.h"
#include <e32test.h>

#ifdef __TOOLS2__
#define CENREP_PC_TEST
#endif

#ifdef CENREP_PC_TEST
	#include <x86tool/centralrepository.h>
#else
	#include <centralrepository.h>
#endif

_LIT( KCentralRepositoryServerName, "Centralrepositorysrv");


//DEFINED IN THE TEST MAIN CPP
extern void SetupEnv(const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode);
extern void InitialiseLC(CRepository*& aRepository,TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode);
extern RFs TheFs;
extern RTest TheTest;

LOCAL_C void Check(TInt aValue, TInt aLine)
	{
	if(!aValue)
		{
		TheTest(EFalse, aLine);
		}
	}

LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine)
	{
	if(aValue != aExpected)
		{
		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
		TheTest(EFalse, aLine);
		}
	}

#define TEST(arg) ::Check((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////
TInt CopyFile(const TDesC& aSource, const TDesC& aTarget)
	{
	RFile file;
	TInt ret=file.Open(TheFs,aSource,EFileRead);
	if (ret!=KErrNone)
		return ret;
	TInt fileSize;
	file.Size(fileSize);
	HBufC8* buf=HBufC8::New(fileSize);
	if (!buf)
		{
		file.Close();
		return KErrNoMemory;
		}
	TPtr8 mod(buf->Des());
	file.Read(mod);
	file.Close();
	ret=file.Replace(TheFs,aTarget,EFileWrite);
	if (ret==KErrNone)
		{
		file.Write(*buf);
		}
	file.Close();
	delete buf;
	return ret;
	}

void OomTest(void (*testFuncL)(CRepository* aRepository),TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode)
	{	
	TInt error;
	TInt count = 0;

	do
		{
		SetupEnv(aInFilePath,aOutFilePath,aTestMode);
		//for CRE testing we need to ensure we have a fresh copy of CRE(sourced from the TXT template)

		__UHEAP_MARK;
		CRepository* repository=NULL;
		
#ifndef CENREP_PC_TEST
		//for CS testing, we want to kill server to start with fresh repos, otherwise might still use
		//cache version from previous test		
		KillProcess(KCentralRepositoryServerName);		
#endif		
		InitialiseLC(repository,aUid,aInFilePath,aOutFilePath,aTestMode);
		if (repository)
			CleanupStack::Pop();		
		// This is supported by symuser but still have problem, so skiped
//		User::__DbgSetAllocFail(RHeap::EUser, RHeap::EDeterministic, ++count);

		
  		// find out the number of open handles
  		// TOOLS2 somehow not supporting RThread().HandleCount()?
#ifndef __TOOLS2__  		
		TInt startProcessHandleCount;
		TInt startThreadHandleCount;
		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
#endif
		
		TRAP(error, (testFuncL)(repository));
		
		// check that no handles have leaked
#ifndef __TOOLS2__		
		TInt endProcessHandleCount;
		TInt endThreadHandleCount;
		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
		
		TEST2(endProcessHandleCount, startProcessHandleCount);
		TEST2(endThreadHandleCount, startThreadHandleCount);
#endif
//		User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1);
		
		delete repository;
		
		__UHEAP_MARKEND;
		
		} while(error == KErrNoMemory);
	_LIT(KTestFailed, "Out of memory test failure on iteration %d\n");
	__ASSERT_ALWAYS(error==KErrNone, TheTest.Panic(error, KTestFailed, count));
 	}

void ObjectCreateDeleteOOM(TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode)
	{
//	TInt count=0;
	TInt error=KErrNone;
	do
		{
		SetupEnv(aInFilePath,aOutFilePath,aTestMode);
		
		__UHEAP_MARK;
#ifndef __TOOLS2__		
		TInt startProcessHandleCount;
		TInt startThreadHandleCount;
		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
#endif		
		// This is supported by symuser but still has problems, so skipped.
//		User::__DbgSetAllocFail(RHeap::EUser, RHeap::EDeterministic, ++count);
		
		CRepository* repository=NULL;
		
		TRAP(error,InitialiseLC(repository,aUid,aInFilePath,aOutFilePath,aTestMode);CleanupStack::Pop());
		
		delete repository;

//		User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1);

#ifndef __TOOLS2__		
		// check that no handles have leaked
		TInt endProcessHandleCount;
		TInt endThreadHandleCount;
		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
		
		TEST2(endProcessHandleCount, startProcessHandleCount);
		TEST2(endThreadHandleCount, startThreadHandleCount);
#endif		
		
		__UHEAP_MARKEND;
		} while(error == KErrNoMemory);
	}

void GetFunctionL(CRepository* aRepository)
	{
	//[GET]
	TInt intVal;
	TReal realVal;
	User::LeaveIfError(aRepository->Get(6,intVal));
	TEST(intVal==12);
	User::LeaveIfError(aRepository->Get(8,realVal));
	TEST(realVal==1.5);
	TBuf<255> stringVal;
	User::LeaveIfError(aRepository->Get(0x300,stringVal));
	TEST(stringVal.Compare(_L("Hello World"))==0);	

	TBuf<5> shortBuffer;
	TInt actualLength=0;
	TInt ret=aRepository->Get(0x300,shortBuffer,actualLength);
	TEST(ret==KErrOverflow);
	TEST(actualLength==11);
	TEST(shortBuffer.Compare(_L("Hello"))==0);
		
	//[GETMETA]
	TUint32 metaValue;
	User::LeaveIfError(aRepository->GetMeta(2,metaValue));
	TEST(metaValue==0xa);
	//range based
	User::LeaveIfError(aRepository->GetMeta(0x204,metaValue));
	TEST(metaValue==0x20);
	//default based
	User::LeaveIfError(aRepository->GetMeta(0x10000,metaValue));
	TEST(metaValue==0x10);
	}

void FindFunctionL(CRepository* aRepository)
	{
	RArray<TUint32> keyList;
	CleanupClosePushL(keyList);
	//Find all settings
	TInt ret=aRepository->FindL(0xFFFFFFFF,0,keyList);
	User::LeaveIfError(ret);	
	TEST(ret==KErrNone);
	TEST(keyList.Count()==33);
	keyList.Reset();
	//Find match EQ specific value
	ret=aRepository->FindEqL(0xFFFFFFFF,0,10,keyList);
	User::LeaveIfError(ret);	
	TEST(ret==KErrNone);	
	TEST(keyList.Count()==3);
	keyList.Reset();
	//Find match NEQ specific value
	ret=aRepository->FindNeqL(0xFFFFFFFF,0,10,keyList);
	TEST(ret==KErrNone);
	TEST(keyList.Count()==30);
	keyList.Reset();		
	//Find using string matching instead
	_LIT(KString,"empty");
	ret=aRepository->FindEqL(0xFFFFFFFF,0,KString(),keyList);
	User::LeaveIfError(ret);
	TEST(ret==KErrNone);
	TEST(keyList.Count()==1);	
	CleanupStack::PopAndDestroy();
	}

void SetFunctionL(CRepository* aRepository)
	{
	//[SET]
	//int
	TUint32 metaValue;
	TInt value;
	User::LeaveIfError(aRepository->Get(1,value));
	TEST(value==1);
	User::LeaveIfError(aRepository->Set(1,100));
	User::LeaveIfError(aRepository->Get(1,value));
	TEST(value==100)	;
	//real
	TReal realValue;
	User::LeaveIfError(aRepository->Get(2,realValue));
	TEST(realValue==2.732);
	TReal newrealValue(5.464);
	User::LeaveIfError(aRepository->Set(2,newrealValue));
	User::LeaveIfError(aRepository->Get(2,realValue));
	TEST(realValue==5.464);
	//string
	TBuf<255> stringValue;
	User::LeaveIfError(aRepository->Get(0x10000,stringValue));
	TEST(stringValue.Compare(_L("empty"))==0);
	User::LeaveIfError(aRepository->Set(0x10000,_L("full")));
	stringValue.Zero();
	User::LeaveIfError(aRepository->Get(0x10000,stringValue));
	TEST(stringValue.Compare(_L("full"))==0);		
	
	//use set to create new setting and also check the meta
	TInt newIntegerKeyValue=205;
	User::LeaveIfError(aRepository->Set(0x205,newIntegerKeyValue));
	User::LeaveIfError(aRepository->Get(0x205,value));
	TEST(value==205);
	User::LeaveIfError(aRepository->GetMeta(0x205,metaValue));
	//as the key 0x205 is within range, expect use of range meta
	TEST(metaValue==0x20);	
	}

void CreateFunctionL(CRepository* aRepository)
	{
	TUint32 metaValue;
	TInt value=206;
	User::LeaveIfError(aRepository->Create(0x206,value));
	User::LeaveIfError(aRepository->Get(0x206,value));
	TEST(value==206);
	User::LeaveIfError(aRepository->GetMeta(0x206,metaValue));
	//within meta range
	TEST(metaValue==0x20);			
	
	TReal realValue=207.207;
	User::LeaveIfError(aRepository->Create(0x407,realValue));
	User::LeaveIfError(aRepository->Get(0x407,realValue));
	TEST(realValue==207.207);
	User::LeaveIfError(aRepository->GetMeta(0x407,metaValue));
	//default meta
	TEST(metaValue==0x10);
	
	//create already existing setting
	TInt ret=aRepository->Create(1,value);
	TEST(ret==KErrAlreadyExists);	
	}

void DeleteFunctionL(CRepository* aRepository)
	{
	//delete single
	TInt value;
	User::LeaveIfError(aRepository->Delete(6));
	TInt ret=aRepository->Get(6,value);
	TEST(ret==KErrNotFound);
	
	//delete range
	RArray<TUint32> keyList;
	CleanupClosePushL(keyList);
	//make sure that the list of keys are there first
	ret=aRepository->FindL(0x03010000,0xFFFFF0FF,keyList);
	User::LeaveIfError(ret);
	TEST(keyList.Count()==5);
	TUint32 error;
	User::LeaveIfError(aRepository->Delete(0x03010000,0xFFFFF0FF,error));
	//check that key no longer exist
	keyList.Reset();
	ret=aRepository->FindL(0x03010000,0xFFFFF0FF,keyList);
	if (ret!=KErrNotFound)
		User::LeaveIfError(ret);
	TEST(ret==KErrNotFound);
	TEST(keyList.Count()==0);
	CleanupStack::PopAndDestroy();	
	}

void MoveFunctionL(CRepository* aRepository)
	{
	RArray<TUint32> keyList;
	CleanupClosePushL(keyList);
	TUint32 errorKey;
	//check source key exists first
	keyList.Reset();
	TInt ret=aRepository->FindL(0x02010000,0xFFFFF0FF,keyList);
	User::LeaveIfError(ret);
	TEST(keyList.Count()==5);
	
	User::LeaveIfError(aRepository->Move(0x02010000,0x06010000,0xFFFFF0FF,errorKey));
	
	keyList.Reset();
	//check target now exists
	ret=aRepository->FindL(0x06010000,0xFFFFF0FF,keyList);
	User::LeaveIfError(ret);

	TEST(keyList.Count()==5);
	//check source now deleted
	keyList.Reset();
	ret=aRepository->FindL(0x02010000,0xFFFFF0FF,keyList);
	TEST(ret==KErrNotFound);
	TEST2(keyList.Count(),0);
	
	CleanupStack::PopAndDestroy();	
	}

/**
*/
void BasicFunctionL(TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode)
	{
	//TEST SETUP
	SetupEnv(aInFilePath,aOutFilePath,aTestMode);
	
	__UHEAP_MARK;
	CRepository* repository=NULL;
	
	InitialiseLC(repository,aUid,aInFilePath,aOutFilePath,aTestMode);

#ifdef CENREP_PC_TEST
	//testing transaction
	TInt r= repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
	TEST2(r, KErrNone);
	repository->CleanupCancelTransactionPushL();
#endif

	GetFunctionL(repository);
	FindFunctionL(repository);
	SetFunctionL(repository);
	CreateFunctionL(repository);
	DeleteFunctionL(repository);
	MoveFunctionL(repository);

#ifdef CENREP_PC_TEST
	CleanupStack::PopAndDestroy();
#endif

	CleanupStack::PopAndDestroy();	
	
	__UHEAP_MARKEND;
	}

void OomBasicFunction(TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode)
	{
	__UHEAP_MARK;

	OomTest(GetFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode);
	OomTest(FindFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode);
	OomTest(SetFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode);
	OomTest(CreateFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode);
	OomTest(DeleteFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode);
	OomTest(MoveFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode);
	
	__UHEAP_MARKEND;
	}

void DEF130394L(TUid aUid)
	{
	CRepository* repos=NULL;
	
	repos = CRepository::NewL(aUid);
	
	TInt err = repos->Create(1,1);
	TEST(err==KErrNone);
	
	delete repos;
	
	repos = CRepository::NewL(aUid);
	
	err = repos->Create(1,1);
	TEST(err==KErrAlreadyExists);
	
	delete repos;
	}

void DoFileCompL(const TDesC& aGenerated, const TDesC& aReference, TUint32& aCrcValue)
	{
	RFile genFile;
	RFile refFile;
	TInt err = genFile.Open(TheFs,aGenerated,EFileRead);
	User::LeaveIfError(err);
	err = refFile.Open(TheFs,aReference,EFileRead);
	User::LeaveIfError(err);
	
	TInt sizeOfGen;
	genFile.Size(sizeOfGen);
	TInt sizeOfRef;
	refFile.Size(sizeOfRef);
	TEST(sizeOfGen == sizeOfRef);
	
	TUint32 crcGen = 0;
	TUint32 crcRef = 0;

	HBufC8* buf = HBufC8::New(sizeOfGen);
	if (!buf)
		{
		genFile.Close();
		refFile.Close();
		User::Leave(KErrNoMemory);
		}
	TPtr8 data(buf->Des());
	
	err = genFile.Read(data);
	User::LeaveIfError(err);
	Mem::Crc32(crcGen, buf, sizeOfGen);
	err = refFile.Read(data);
	User::LeaveIfError(err);
	Mem::Crc32(crcRef, buf, sizeOfRef);

	TEST(crcGen == crcRef);
	
	aCrcValue = crcGen;
	
	delete buf;
	genFile.Close();
	refFile.Close();
	
	return;
	}

void DoCrcCompL(const TUint32& aCrcValue, const TDesC& aCrcRecord, TBool aCreOrTxt)
	{
	RFile file;
	TInt err = file.Open(TheFs, aCrcRecord, EFileRead);
	User::LeaveIfError(err);
	
	TBuf8<100> buf;
	file.Read(buf);
	
	TBuf8<1> breaker(_L8("-"));
	TInt pos = buf.Find(breaker);
	
	TInt length = buf.Length();
	
	const TPtrC8 crePtr = buf.Right(length - pos -1);
	const TPtrC8 txtPtr = buf.Left(pos);
	
	TUint32 crc = 0;
	
	if (aCreOrTxt)
		{
		TLex8 lex (crePtr);
		lex.Val(crc, EDecimal);
		}
	else
		{
		TLex8 lex (txtPtr);
		lex.Val(crc, EDecimal);
		}
	TEST2(crc, aCrcValue);
	file.Close();
	}