--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/centralrepository/pccenrep/test/common.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,505 @@
+// 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();
+	}
+