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

 // t_oomcenrep.cpp

 // 

 //

 #include "t_cenrep_helper.h"

 #include <e32test.h>

 #include <f32file.h>

 #include <utf.h>

 #include "srvsess.h"

 #include "sessmgr.h"

 #include "srvres.h"

 #include "srvreqs.h"

 #include "cachemgr.h"

 #include "clientrequest.h"

 #include "install.h"

 #include <bautils.h>

 LOCAL_D RFs					TheFs;

 LOCAL_D RTest				TheTest (_L ("t_oomcenrep.exe"));

 #ifdef __SECURE_DATA__

 _LIT(KInstallDirFile,			"c:\\private\\10202BE9\\persists\\installdir.bin");

 _LIT(KPersistsFile,				"c:\\private\\10202BE9\\persists\\11111111.cre");

 _LIT(KInstallPersistsFile,		"c:\\private\\10202BE9\\persists\\11111110.cre");

 _LIT(KPersistsFileNoUpgrade,	"c:\\private\\10202BE9\\bur\\11111111.crn");

 _LIT(KPersistsFileUpgraded,		"c:\\private\\10202BE9\\bur\\11111111.cru");

 _LIT(KRomUpgradeRev1File,		"z:\\private\\10202BE9\\11111111.txu");

 _LIT(KRomUpgradeRev2File,		"z:\\private\\10202BE9\\11111112.txu");

 _LIT(KUpgradeFile,				"c:\\private\\10202BE9\\11111111.txt");

 _LIT(KInstallOnlyFile,			"z:\\private\\10202BE9\\11111110.cri");

 _LIT(KInstallOnlyUpgradeFile,	"z:\\private\\10202BE9\\11111110.cru");

 _LIT(KInstallFile,				"c:\\private\\10202BE9\\11111110.cre");

 #else

 _LIT(KPersistsFiles, 			"c:\\system\\data\\cenrep\\persists\\*.*");

 #endif

 //Test repositories Uid

 const TUid KTestRepositoryUid={0x11111111};

 const TUid KCorruptRepositoryUid={0xBADBADBB};

 static TUid KCurrentTestUid;

 ///////////////////////////////////////////////////////////////////////////////////////

 //Test macroses and functions

 LOCAL_C void CheckL(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		RDebug::Print(_L("Error\r\n"));

 		CleanupCDriveL();

 		TheTest(EFalse, aLine);

 		}

 	}

 LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if(aValue != aExpected)

 		{

 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

 		CleanupCDriveL();

 		TheTest(EFalse, aLine);

 		}

 	}

 #define TESTL(arg) ::CheckL((arg), __LINE__)

 #define TEST2L(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)

 #define TESTKErrNoneL(aValue) ::CheckL(aValue,0,__LINE__);

 /////////////////////////////////////////////////////////////////////////////////////////

 class CenrepSrvOOMTest :public CBase

 {

 public:

 	void GetL();

 	void FindL();

 	void ResetL();

 	void NotifyL();

 	void SetL();

 	void CreateL();

 	void DeleteL();

 	void MoveL();

 	CenrepSrvOOMTest();

 	~CenrepSrvOOMTest();

 	static CenrepSrvOOMTest* NewL();

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 	void DoHeapRepositoryContentCheckL();

 #endif

 private:

 	void ConstructL();

 public:

 	CServerRepository* iServerRepo;

 	CSessionNotifier* iSessionNotif;

 };

 //////////////////////////////////////////////////////////////////////////////////////////////////

 class CenrepSwiOOMTest :public CBase

 {

 public:

 	void UpgradeROMRev1L(TBool aIsSetup);

 	void UpgradeROMRev2L(TBool aIsSetup);

 	void UninstallROMUpgradeL(TBool aIsSetup);

 	void InstallL(TBool aIsSetup);

 	void UpgradeInstallL(TBool aIsSetup);

 	void UninstallL(TBool aIsSetup);

 	CenrepSwiOOMTest();

 	~CenrepSwiOOMTest();

 	static CenrepSwiOOMTest* NewL();

 private:

 	void ConstructL();

 	CCentRepSWIWatcher* iSwiWatcher;

 public:

 };

 //////////////////////////////////////////////////////////////////////////////////////////////////

 CenrepSrvOOMTest::CenrepSrvOOMTest(){}

 CenrepSrvOOMTest::~CenrepSrvOOMTest()

 	{

 	if (iServerRepo)

 		{

 		if (iSessionNotif)

 			{

 			iServerRepo->Close();

 			}

 		delete iServerRepo;

 		}

 	if (iSessionNotif)

 		delete iSessionNotif;

 	// Cache must be disabled here. Otherwise, if any idle repositories exists, they will

 	// still be open (have their pointers in the iOpenRepositories list) and the list will leak.

 	TServerResources::iCacheManager->DisableCache();

 	TServerResources::iObserver->CloseiOpenRepositories();

 	}

 CenrepSrvOOMTest* CenrepSrvOOMTest::NewL()

 	{

 	CenrepSrvOOMTest* self=new (ELeave)CenrepSrvOOMTest;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CenrepSrvOOMTest::ConstructL()

 	{

 	iServerRepo=new (ELeave)CServerRepository();

 	iSessionNotif=new (ELeave) CSessionNotifier();

 	iServerRepo->OpenL(KCurrentTestUid,*iSessionNotif);

 	}

 //////////////////////////////////////////////////////////////////////////////////////////////////

 CenrepSwiOOMTest::CenrepSwiOOMTest(){}

 CenrepSwiOOMTest::~CenrepSwiOOMTest()

 	{

 	delete iSwiWatcher;

 	}

 CenrepSwiOOMTest* CenrepSwiOOMTest::NewL()

 	{

 	CenrepSwiOOMTest* self=new (ELeave)CenrepSwiOOMTest;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CenrepSwiOOMTest::ConstructL()

 	{

 	iSwiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);

 	}

 //Getting various information and security policy from the repository

 //TInt 				CServerRepository::Get(TUint32 aId,T& aVal)

 //TServerSetting* 	CServerRepository::GetSetting(TUint32 aId)

 void CenrepSrvOOMTest::GetL()

 	{

 	TInt err=KErrNone;

 	TInt keyInt=0;

 	TServerSetting* srvsetting;

 	//----------Getting the TInt(1-15)-----------------------------

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

 		{

 		err=iServerRepo->Get(i,keyInt);

 		//Remember the policy check is done at the session level

 		TESTKErrNoneL(err);

 		TESTL(i==keyInt);

 		srvsetting=iServerRepo->GetSetting(i);

 		TESTL(srvsetting->Key()==static_cast<TUint32>(i));

 		}

 	//---------Getting the TReal(16-19)---------------------------

 	TReal keyValue;

 	err=iServerRepo->Get(16,keyValue);

 	TESTKErrNoneL(err);

 	TESTL(keyValue==10.1010);

 	srvsetting=iServerRepo->GetSetting(16);

 	TESTL(srvsetting->Key()==16);

 	err=iServerRepo->Get(19,keyValue);

 	TESTKErrNoneL(err);

 	TESTL(keyValue==13.1313);

 	//----------Getting the String(20-23)-----------------------

 	TBuf8<50> keyString;

 	_LIT(KFourteen,"fourteen");

 	err=iServerRepo->Get(20,keyString);

 	TESTKErrNoneL(err);

 	//Even ascii(8 bytes) are stored as 16 bytes!!!

 	TPtr16 str16((TUint16*) keyString.Ptr(),keyString.Length()/2,keyString.Length()/2);

 	TESTL(str16.Compare(KFourteen)==0);

 	srvsetting=iServerRepo->GetSetting(20);

 	TESTL(srvsetting->Key()==20);

 	//---------Getting the String8(0x79)------------------------

 	TBuf8<50> keyString8;

 	_LIT8(KString8,"string8");

 	err=iServerRepo->Get(0x79,keyString8);

 	TESTKErrNoneL(err);

 	TESTL(keyString8.Compare(KString8)==0);

 	srvsetting=iServerRepo->GetSetting(0x79);

 	TESTL(srvsetting->Key()==0x79);

 	//---------Getting the binary(0x82)-------------------------

 	TBuf8<50> keyBinary;

 	_LIT8(KBinary8,"\x12\x34\xAB\xCD");

 	err=iServerRepo->Get(0x82,keyBinary);

 	TESTKErrNoneL(err);

 	//temporarily added to solve coverage problem in WINSCW

 #ifdef __EPOC32__

 	TESTL(keyBinary.Compare(KBinary8)==0);

 #endif

 	srvsetting=iServerRepo->GetSetting(0x82);

 	TESTL(srvsetting->Key()==0x82);

 	//----------Getting individual policy-----------------------

 	//Current Exe has caps AllFiles+WriteDeviceData+ReadDeviceData

 	RThread currentThread;

 	TSecurityPolicy secPolicy;

 	//default policy

 	secPolicy=iServerRepo->GetDefaultReadAccessPolicy();

 	TESTL(secPolicy.CheckPolicy(currentThread)==1);

 	secPolicy=iServerRepo->GetDefaultWriteAccessPolicy();

 	TESTL(secPolicy.CheckPolicy(currentThread)==1);

 	//check settings policies

 	//0x2 int 2 1 cap_rd=CommDD cap_wr=WriteDeviceData

 	//0x19 int 25 0 //defined in range policies with cap_rd=NetworkServices

 	secPolicy=iServerRepo->GetReadAccessPolicy(2);

 	TESTL(secPolicy.CheckPolicy(currentThread)==0);

 	secPolicy=iServerRepo->GetWriteAccessPolicy(2);

 	TESTL(secPolicy.CheckPolicy(currentThread)==1);

 	secPolicy=iServerRepo->GetReadAccessPolicy(25);

 	TESTL(secPolicy.CheckPolicy(currentThread)==0);

 	}

 // now that write operations must be done in transactions, setting up this helper

 // function to perform single Sets for the purpose of this test.

 template<class T>

 static TInt RepositorySingleSetL(CServerRepository& aRep, TUint32 aKey, const T& aValue)

 	{

 	aRep.StartTransaction(EConcurrentReadWriteTransaction);

 	aRep.CleanupCancelTransactionPushL();

 	aRep.TransactionSetL(aKey, aValue);

 	CleanupStack::Pop();

 	TUint32 keyInfo;

 	return User::LeaveIfError(aRep.CommitTransaction(keyInfo));

 	};

 //Setting OOM testing

 void CenrepSrvOOMTest::SetL()

 	{

 	TInt ret=KErrNone;

 	TInt intValue=0;

 	TReal realValue=0;

 	//---------------SetL-----------------------------------

 	//Setting an integer key

 	ret = RepositorySingleSetL(*iServerRepo, 0x60, 600);

 	TESTKErrNoneL(ret);

 	ret=iServerRepo->Get(0x60,intValue);

 	TESTL(intValue== 600);

 	//Setting a real key

 	ret = RepositorySingleSetL(*iServerRepo, 0x66, 99.99);

 	TESTKErrNoneL(ret);

 	ret=iServerRepo->Get(0x66,realValue);

 	TESTL(realValue==99.99);

 	//Setting a string key

 	//Even ascii(8 bytes) are stored as 16 bytes!!!

 	_LIT8(KString,"sixhundred");

 	TBuf8<50> stringChangeValue=KString();

 	ret = RepositorySingleSetL(*iServerRepo, 0x69, stringChangeValue);

 	TESTKErrNoneL(ret);

 	TBuf8<50> keyString;

 	ret=iServerRepo->Get(0x69,keyString);

 	TESTKErrNoneL(ret);

 	TESTL(keyString.Compare(KString)==0);

 	}

 // now that write operations must be done in transactions, setting up this helper

 // function to perform single Creates for the purpose of this test.

 template<class T>

 static TInt RepositorySingleCreateL(CServerRepository& aRep, TUint32 aKey, const T& aValue, TUint32* aMeta)

 	{

 	aRep.StartTransaction(EConcurrentReadWriteTransaction);

 	aRep.CleanupCancelTransactionPushL();

 	aRep.TransactionCreateL(aKey, aValue, aMeta);

 	CleanupStack::Pop();

 	TUint32 keyInfo;

 	return User::LeaveIfError(aRep.CommitTransaction(keyInfo));

 	};

 void CenrepSrvOOMTest::CreateL()

 	{

 	TInt ret=KErrNone;

 	TInt intValue=0;

 	TReal realValue=0;

 	//--------------CreateL-----------------------------------

 	//Creating an integer key

 	TInt intRetValue;

 	intValue=9000;

 	RepositorySingleCreateL(*iServerRepo, 0x90, intValue, NULL);

 	TESTKErrNoneL(ret);

 	ret=iServerRepo->Get(0x90,intRetValue);

 	TESTKErrNoneL(ret);

 	TESTL(intRetValue==intValue);

 	//Creating a real key

 	TReal realRetValue;

 	realValue=33.3333;

 	RepositorySingleCreateL(*iServerRepo, 0x92, realValue, NULL);

 	TESTKErrNoneL(ret);

 	ret=iServerRepo->Get(0x92,realRetValue);

 	TESTKErrNoneL(ret);

 	TESTL(realValue==realRetValue);

 	//Creating a string key

 	_LIT8(KStringValue,"creatingkey");

 	TBuf8<50> stringCreateValue=KStringValue();

 	RepositorySingleCreateL(*iServerRepo, 0x93, stringCreateValue, NULL);

 	TESTKErrNoneL(ret);

 	}

 // now that write operations must be done in transactions, setting up this helper

 // function to perform single Creates for the purpose of this test.

 static TInt RepositorySingleDeleteL(CServerRepository& aRep, TUint32 aKey)

 	{

 	aRep.StartTransaction(EConcurrentReadWriteTransaction);

 	aRep.CleanupCancelTransactionPushL();

 	aRep.TransactionDeleteL(aKey);

 	CleanupStack::Pop();

 	TUint32 keyInfo;

 	return User::LeaveIfError(aRep.CommitTransaction(keyInfo));

 	};

 void CenrepSrvOOMTest::DeleteL()

 	{

 	TInt ret=KErrNone;

 	//--------------Delete-----------------------------------

 	//Find the settings 0x10A-0x10C to ensure it is still there

 	RSettingPointerArray matchingArray;

 	TUint32 partialId=0x100;

 	TUint32 idMask=0xFFFFFFF0;

 	ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);

 	if (ret==KErrNoMemory)

 		{

 		matchingArray.Close();

 		User::LeaveNoMemory();

 		}

 	TESTKErrNoneL(ret);

 	TESTL(matchingArray.Count()==3);

 	matchingArray.Close();

 	//Deleting settings 0x10A to 0x10C

 	for (TInt i=0x10A;i<=0x10C;i++)

 		{

 		RepositorySingleDeleteL(*iServerRepo, i);

 		TESTKErrNoneL(ret);

 		}

 	//After deleting try to find the persistent settings again

 	ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);

 	if (ret==KErrNoMemory)

 		{

 		matchingArray.Close();

 		User::LeaveNoMemory();

 		}

 	TESTKErrNoneL(ret);

 	TESTL(matchingArray.Count()==0);

 	matchingArray.Close();

 	//-------------DeleteRange---------------------------------

 	//Deleting settings 0x1 to 0xF

 	TClientRequest dummyrequest;

 	TUint32 errId=0;

 	partialId=0;

 	idMask=0xFFFFFFF0;

 	ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);

 	if (ret==KErrNoMemory)

 		{

 		matchingArray.Close();

 		User::LeaveNoMemory();

 		}

 	TESTKErrNoneL(ret)	;

 	TESTL(matchingArray.Count()==15);

 	matchingArray.Close();

 	//Deleting settings using the DeleteRange

 	dummyrequest.SetParam(0,partialId);

 	dummyrequest.SetParam(1,idMask);

 	dummyrequest.SetPolicyCheck(ETrue);

 	// write operation must take place in a transaction

 	iServerRepo->StartTransaction(EConcurrentReadWriteTransaction);

 	iServerRepo->CleanupCancelTransactionPushL();

 	iServerRepo->TransactionDeleteRangeL(dummyrequest,errId);

 	CleanupStack::Pop();

 	TUint32 keyInfo;

 	User::LeaveIfError(iServerRepo->CommitTransaction(keyInfo));

 	//Now try to find the key being deleted

 	ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);

 	if (ret==KErrNoMemory)

 		{

 		matchingArray.Close();

 		User::LeaveNoMemory();

 		}

 	TESTKErrNoneL(ret);

 	TESTL(matchingArray.Count()==0);

 	matchingArray.Close();

 	}

 //Setting existing key value then follow by commit

 void CenrepSrvOOMTest::MoveL()

 	{

 	RSettingPointerArray matchingArray;

 	TUint32 idMask=0xFFFFFFF0;

 	/*---------------MoveL-------------------------------------

 	TUint32 sourcePartialId = aMessage.Int0();

 	TUint32 targetPartialId = aMessage.Int1();

 	TUint32 idMask = aMessage.Int2();

 	*/

 	TClientRequest dummyrequest;

 	TUint32 errId=0;

 	TUint32 sourcePartialId=0x110;

 	TUint32 targetPartialId=0x120;

 	idMask=0xFFFFFFF0;

 	TKeyFilter srcKeyIdentifier = {sourcePartialId, idMask};

 	TPckg<TKeyFilter> pSrcIdentifier(srcKeyIdentifier);

 	TKeyFilter tgtKeyIdentifier = {targetPartialId, idMask};

 	TPckg<TKeyFilter> pTgtIdentifier(tgtKeyIdentifier);

 	//First check to ensure the target key before move does not exist

 	User::LeaveIfError(iServerRepo->FindSettings(targetPartialId,idMask,matchingArray));

 	TESTL(matchingArray.Count()==0);

 	matchingArray.Close();

 	//moving from 0x110(0x11B,0x11C,0x11E) to 0x120

 	dummyrequest.SetParam(0, &pSrcIdentifier);

 	dummyrequest.SetParam(1, &pTgtIdentifier);

 	dummyrequest.SetPolicyCheck(ETrue);

 	// write operation must take place in a transaction

 	iServerRepo->StartTransaction(EConcurrentReadWriteTransaction);

 	iServerRepo->CleanupCancelTransactionPushL();

 	iServerRepo->TransactionMoveL(dummyrequest,errId);

 	CleanupStack::Pop();

 	TUint32 keyInfo;

 	User::LeaveIfError(iServerRepo->CommitTransaction(keyInfo));

 	//Now try to find the key being moved

 	User::LeaveIfError(iServerRepo->FindSettings(targetPartialId,idMask,matchingArray));

 	TESTL(matchingArray.Count()==3);

 	matchingArray.Close();

 	}

 //Finding keys from the settings

 //TInt FindSettings(TUint32 aPartialId,TUint32 aIdMask,RSettingPointerArray& aMatches)

 //Guarantees the heap free in aMatches if this function fail

 void CenrepSrvOOMTest::FindL()

 	{

 	TInt ret=KErrNone;

 	RSettingPointerArray foundIdArray;

 	TUint32 partialId=0;

 	TUint32 idMask=0;

 	//-----------Finding settings array using partial id & mask------

 	//------------------Real type---------------------------------

 	//0x42,0x44,0x45,0x48

 	partialId=0x40;

 	idMask=0xFFFFFFF0;

 	User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray));

 	TESTKErrNoneL(ret);

 	TESTL(foundIdArray.Count()==4);

 	foundIdArray.Close();

 	//-----------------String type-------------------------------

 	//0x51,0x54,0x5B

 	partialId=0x50;

 	idMask=0xFFFFFFF0;

 	User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray));

 	TESTKErrNoneL(ret);

 	TESTL(foundIdArray.Count()==3);

 	foundIdArray.Close();

 	//--------------------Int type----------------------------------------------------

 	partialId=0x30;

 	idMask=0xFFFFFFF0;

 	//This should return only 0x30,0x34,0x35,0x39,0x3B( 5 items)

 	User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray));

 	TESTKErrNoneL(ret);

 	TESTL(foundIdArray.Count()==5);

 	//----------------Find comparison using EEqual & ENotEqual------------------------

 	TInt searchValue=100;

 	TClientRequest dummyrequest;

 	RArray<TUint32> idArray;

 	//Set the policycheck to always pass

 	dummyrequest.SetPolicyCheck(ETrue);

 	//Comparison using Equal

 	TRAP(ret,iServerRepo->FindCompareL(foundIdArray,searchValue,EEqual,idArray));

 	if (ret==KErrNoMemory)

 		{

 		//do not need to reset idArray as it is done inside the function itself when it returns not KErrNone

 		foundIdArray.Close();

 		User::LeaveNoMemory();

 		}

 	TESTL(idArray.Count()==2);

 	TESTL((idArray[0]==0x30 && idArray[1]==0x34) || (idArray[0]==0x34 && idArray[1]==0x30));

 	idArray.Close();

 	//Comparison using ENotEqual

 	TRAP(ret,iServerRepo->FindCompareL(foundIdArray,searchValue,ENotEqual,idArray));

 	if (ret==KErrNoMemory)

 		{

 		//do not need to reset idArray as it is done inside the function itself when it returns not KErrNone

 		foundIdArray.Close();

 		User::LeaveNoMemory();

 		}

 	TESTL(idArray.Count()==3);

 	idArray.Close();

 	foundIdArray.Close();

 	}

 //Resetting settings

 void CenrepSrvOOMTest::ResetL()

 	{

 	TInt ret=KErrNone;

 	TInt retValue=0;

 	TReal realValue=0;

 	//-------------Single key reset----------------------------

 	ret = RepositorySingleSetL(*iServerRepo, 1, 500);

 	TESTKErrNoneL(ret);

 	ret=iServerRepo->Get(1,retValue);

 	TESTL(retValue==500);

 	//Resetting individual settings

 	ret=iServerRepo->ResetL(1);

 	TESTKErrNoneL(ret);

 	//Check for value once being reset

 	ret=iServerRepo->Get(1,retValue);

 	TESTL(retValue==1);

 	//------------All keys reset------------------------------

 	ret = RepositorySingleSetL(*iServerRepo, 17, 3.1343424);

 	TESTKErrNoneL(ret);

 	//Reset all settings from Rom

 	User::LeaveIfError(iServerRepo->ResetAllL());

 	TESTKErrNoneL(ret);

 	//Check for value once all being reset

 	ret=iServerRepo->Get(17,realValue);

 	TESTL(realValue==11.1111);

 	}

 void CenrepSrvOOMTest::NotifyL()

 	{

 	TInt err=KErrNone;

 	//addding individual requests

 	for (TInt i=0;i<10;i++)

 		{

 		TClientRequest dummyRequest;

 		User::LeaveIfError(iSessionNotif->AddRequest(i,dummyRequest));

 		}

 	//adding group requests

 	for (TInt i=0;i<10;i++)

 		{

 		TClientRequest dummyRequest;

 		TUint32 partialId=100*i;

 		TUint32 idMask=0xFFFFFFF0;

 		User::LeaveIfError(iSessionNotif->AddRequest(partialId,idMask,dummyRequest));

 		}

 	//cancelling individual requests

 	User::LeaveIfError(iSessionNotif->CancelRequest(5));

 	//Check to ensure that it has been deleted so calling cancel again will return KErrNotFound

 	err=iSessionNotif->CancelRequest(5);

 	TESTL(err==KErrNotFound);

 	//cancelling group requests

 	User::LeaveIfError(iSessionNotif->CancelRequest(500,0xFFFFFFF0));

 	err=iSessionNotif->CancelRequest(500,0xFFFFFF0);

 	TESTL(err==KErrNotFound);

 	//Finally cancel ALL requests

 	iSessionNotif->CancelAllRequests();

 	}

 //Deletes the CServerRepository object properly

 LOCAL_C void ReleaseRepository(TAny* aServerRepository)

 	{

 	CServerRepository* serverRepository = static_cast<CServerRepository*>(aServerRepository);

 	TServerResources::iCacheManager->DisableCache();

 	TServerResources::iObserver->CloseiOpenRepositories();

 	delete serverRepository;

 	TServerResources::iCacheManager->EnableCache();

 	}

 //Opening a repository and closing the repository

 LOCAL_C void CreateDeleteL(TBool /*aOOMMode*/)

 {

 	CServerRepository* serverRepo=new (ELeave)CServerRepository();

 	TCleanupItem cleanupItem(&ReleaseRepository, serverRepo);

 	CleanupStack::PushL(cleanupItem);

 	CSessionNotifier* sessNotif=new (ELeave)CSessionNotifier();

 	CleanupStack::PushL(sessNotif);

 // 	test access to a valid repository

 	serverRepo->OpenL(KCurrentTestUid,*sessNotif);

 	serverRepo->Close();

 	CleanupStack::PopAndDestroy(sessNotif);

 	CleanupStack::PopAndDestroy(1);

 }

 LOCAL_C void CreateDeleteCorruptL(TBool /*aOOMMode*/)

 {

 	CServerRepository* serverRepo=new (ELeave)CServerRepository();

 	TCleanupItem cleanupItem(&ReleaseRepository, serverRepo);

 	CleanupStack::PushL(cleanupItem);

 	CSessionNotifier* sessNotif=new (ELeave)CSessionNotifier();

 	CleanupStack::PushL(sessNotif);

 // 	test access to a corrupt repository

 	// trap KErrCorrupt

 	TRAPD(err, serverRepo->OpenL(KCorruptRepositoryUid,*sessNotif));

 	// leave if not KErrCorrupt

 	User::LeaveIfError((err == KErrCorrupt) ? KErrNone : err);

 	serverRepo->Close();

 	CleanupStack::PopAndDestroy(sessNotif);

 	CleanupStack::PopAndDestroy(1);

 }

 void CenrepSwiOOMTest::UpgradeROMRev1L(TBool aIsSetup)

 	{

 	if(aIsSetup)

 		{

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Copy rev 1 file into install dir & Reset read-only bit

 		User::LeaveIfError(fm->Copy(KRomUpgradeRev1File, KUpgradeFile));

 		User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);

 		}

 	}

 LOCAL_C void ModifyTimeStampL(RFs &fs, TDesC *fileName, TTime aTime)

 	{

 	// Reset read-only bit

 	User::LeaveIfError(fs.SetAtt(*fileName, 0, KEntryAttReadOnly));

 	TTimeIntervalHours interval(1);

 	TTime newTime=aTime+interval;

 	User::LeaveIfError(fs.SetModified(*fileName, newTime));

 	}

 void CenrepSwiOOMTest::UpgradeROMRev2L(TBool aIsSetup)

 	{

 	if(aIsSetup)

 		{

 		// Set up rev 1

 		UpgradeROMRev1L(ETrue);

 		UpgradeROMRev1L(EFalse);

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Get modification time

 		TTime time;

 		TBuf<50> fileName(KUpgradeFile);

 		fs.Modified(fileName, time);

 		// Copy rev2 file into install dir & Reset read-only bit

 		User::LeaveIfError(fm->Copy(KRomUpgradeRev2File, KUpgradeFile));

 		User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));

 		// Modify timestamp to cause upgrade

 		ModifyTimeStampL(fs,&fileName, time);

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);

 		}

 	}

 void CenrepSwiOOMTest::UninstallROMUpgradeL(TBool aIsSetup)

 	{

 	if(aIsSetup)

 		{

 		// Install rev 2

 		UpgradeROMRev2L(ETrue);

 		UpgradeROMRev2L(EFalse);

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Delete file from install dir

 		User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));

 		TInt err=fs.Delete(KUpgradeFile);

 		if((err!=KErrNone)&&(err!=KErrNotFound))

 			User::Leave(err);

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		iSwiWatcher->HandleSWIEventL(ESASwisUninstall | ESASwisStatusSuccess);

 		}

 	}

 void CenrepSwiOOMTest::InstallL(TBool aIsSetup)

 	{

 	if(aIsSetup)

 		{

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Copy rev 1 file into install dir & Reset read-only bit

 		User::LeaveIfError(fm->Copy(KInstallOnlyFile, KInstallFile));

 		User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);

 		}

 	}

 void CenrepSwiOOMTest::UpgradeInstallL(TBool aIsSetup)

 	{

 	if(aIsSetup)

 		{

 		// Install file

 		InstallL(ETrue);

 		InstallL(EFalse);

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Get modification time

 		TTime time;

 		TBuf<50> fileName(KInstallFile);

 		fs.Modified(fileName, time);

 		// Copy upgrade file into install dir & Reset read-only bit

 		User::LeaveIfError(fm->Copy(KInstallOnlyUpgradeFile, KInstallFile));

 		User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));

 		// Modify timestamp to cause upgrade

 		ModifyTimeStampL(fs,&fileName, time);

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);

 		}

 	}

 void CenrepSwiOOMTest::UninstallL(TBool aIsSetup)

 	{

 	if(aIsSetup)

 		{

 		// Install upgrade

 		UpgradeInstallL(ETrue);

 		UpgradeInstallL(EFalse);

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Delete file from install dir

 		User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));

 		TInt err=fs.Delete(KInstallFile);

 		if((err!=KErrNone)&&(err!=KErrNotFound))

 			User::Leave(err);

 		// Create a cre persists file, doesn't matter what's in it, it should be deleted

 		User::LeaveIfError(fm->Copy(KPersistsFileUpgraded, KInstallPersistsFile));

 		User::LeaveIfError(fm->Attribs(KInstallPersistsFile,0,KEntryAttReadOnly,TTime(0)));

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		iSwiWatcher->HandleSWIEventL(ESASwisUninstall | ESASwisStatusSuccess);

 		}

 	}

 LOCAL_C void StartupUpgradeL(TBool aIsSetup)

 {

 	if(aIsSetup)

 		{

 		// Set up files for test

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Clean out files

 		TInt err=fs.Delete(KInstallDirFile);

 		if((err!=KErrNone)&&(err!=KErrNotFound))

 			User::Leave(err);

 		// Cause directory listing with no files to be written

 		CCentRepSWIWatcher*	swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);

 		delete swiWatcher;

 		User::LeaveIfError(fm->Copy(KPersistsFileNoUpgrade, KPersistsFile));

 		User::LeaveIfError(fm->Attribs(KPersistsFile,0,KEntryAttReadOnly,TTime(0)));

 		User::LeaveIfError(fm->Copy(KRomUpgradeRev1File, KUpgradeFile));

 		User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		CCentRepSWIWatcher*	swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);

 		delete swiWatcher;

 		}

 }

 LOCAL_C void StartupDowngradeL(TBool aIsSetup)

 {

 	if(aIsSetup)

 		{

 		StartupUpgradeL(ETrue);

 		StartupUpgradeL(EFalse);

 		// Set up files for test

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TInt err=fs.Delete(KUpgradeFile);

 		if((err!=KErrNone)&&(err!=KErrNotFound))

 			User::Leave(err);

 		CleanupStack::PopAndDestroy(); // fs

 		}

 	else

 		{

 		CCentRepSWIWatcher*	swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);

 		delete swiWatcher;

 		}

 }

 LOCAL_C void StartupUninstallL(TBool aIsSetup)

 {

 	if(aIsSetup)

 		{

 		RFs fs;

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		CFileMan* fm = CFileMan::NewL(fs);

 		CleanupStack::PushL(fm);

 		// Copy rev 1 file into install dir & Reset read-only bit

 		User::LeaveIfError(fm->Copy(KInstallOnlyFile, KInstallFile));

 		User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));

 		// Cause directory listing to be written and file to be installed

 		CCentRepSWIWatcher*	swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);

 		delete swiWatcher;

 		// Create a persists file that will be deleted

 		User::LeaveIfError(fm->Copy(KPersistsFileUpgraded, KInstallPersistsFile));

 		User::LeaveIfError(fm->Attribs(KInstallPersistsFile,0,KEntryAttReadOnly,TTime(0)));

 		TInt err=fs.Delete(KInstallFile);

 		if((err!=KErrNone)&&(err!=KErrNotFound))

 			User::Leave(err);

 		CleanupStack::PopAndDestroy(2); // fs and fm

 		}

 	else

 		{

 		CCentRepSWIWatcher*	swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);

 		delete swiWatcher;

 		}

 }

 // Type definition for pointer to function

 // Used for functions that can't use CenrepSrvOOMTest::ConstructL

 typedef void (*FuncPtrL) (TBool);

 /**

 Wrapper function to call all OOM test functions

 @param		testFuncL pointer to OOM test function

 @param		aTestDesc test function name

 */

 LOCAL_C void DoOOMNoServReposL( FuncPtrL atestFuncL, const TDesC& aTestDesc, TBool aOOMMode)

 	{

 	TheTest.Next(aTestDesc);

 	TInt err;

 	TInt tryCount = 0;

 	do

 		{

 		__UHEAP_MARK;

 		//Initializing the server resources

 		TServerResources::InitialiseL ();

 		//Clear any files in the persist directory

 		CleanupCDriveL();

 		// find out the number of open handles

 		TInt startProcessHandleCount;

 		TInt startThreadHandleCount;

 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		(*atestFuncL)(ETrue);

 		if (aOOMMode)

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

 		TRAP(err, (*atestFuncL)(EFalse));

 		if (err!=KErrNoMemory)

 			TESTKErrNoneL(err);

 		if (aOOMMode)

 			__UHEAP_SETFAIL(RHeap::ENone, 0);

 		// check that no handles have leaked

 		TInt endProcessHandleCount;

 		TInt endThreadHandleCount;

 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 		TEST2L(startProcessHandleCount, endProcessHandleCount);

 		TEST2L(startThreadHandleCount, endThreadHandleCount);

 		//Freeing the server resources

 		TServerResources::Close();

 		__UHEAP_MARKEND;

 		} while(err == KErrNoMemory);

  	TESTKErrNoneL(err);

  	if (aOOMMode)

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

 	}

 // Type definition for pointer to member function.

 // Used in calling the CRegistryDataTest member function for testing.

 typedef void (CenrepSrvOOMTest::*ClassFuncPtrL) (void);

 /**

 Wrapper function to call all OOM test functions

 @param		testFuncL pointer to OOM test function

 @param		aTestDesc test function name

 @param		aOOMMode to enable/disable the OOM environment

 */

 LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc,TBool aOOMMode)

 	{

 	TheTest.Next(aTestDesc);

 	TInt err=KErrNone;

 	TInt tryCount = 0;

 	do

 		{

 		__UHEAP_MARK;

 		//Initializing the server resources

 		TServerResources::InitialiseL ();

 		//Clear any files in the persist directory

 		CleanupCDriveL();

 		CenrepSrvOOMTest* theTest=CenrepSrvOOMTest::NewL();

 		CleanupStack::PushL(theTest);

 		TInt startProcessHandleCount;

 		TInt startThreadHandleCount;

 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		if (aOOMMode)

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

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

 		if (aOOMMode)

 			__UHEAP_SETFAIL(RHeap::ENone, 0);

 		if (err!=KErrNoMemory)

 			TESTKErrNoneL(err);

 		CleanupStack::PopAndDestroy(theTest);

 		// check that no handles have leaked

 		TInt endProcessHandleCount;

 		TInt endThreadHandleCount;

 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 		TEST2L(startProcessHandleCount, endProcessHandleCount);

 		TEST2L(startThreadHandleCount, endThreadHandleCount);

 		//Freeing the server resources

 		TServerResources::Close();

 		__UHEAP_MARKEND;

 		} while(err == KErrNoMemory);

  	TESTKErrNoneL(err);

  	if (aOOMMode)

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

 	}

 // Type definition for pointer to member function.

 // Used in calling the CRegistryDataTest member function for testing.

 typedef void (CenrepSwiOOMTest::*ClassSwiFuncPtrL) (TBool);

 /**

 Wrapper function to call all OOM test functions

 @param		testFuncL pointer to OOM test function

 @param		aTestDesc test function name

 @param		aOOMMode to enable/disable the OOM environment

 */

 LOCAL_C void DoOOMSwiTestL(ClassSwiFuncPtrL aTestFuncL, const TDesC& aTestDesc,TBool aOOMMode)

 	{

 	TheTest.Next(aTestDesc);

 	TInt err=KErrNone;

 	TInt tryCount = 0;

 	do

 		{

 		__UHEAP_MARK;

 		//Initializing the server resources

 		TServerResources::InitialiseL ();

 		//Clear any files in the persist directory

 		CleanupCDriveL();

 		TInt startProcessHandleCount;

 		TInt startThreadHandleCount;

 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		CenrepSwiOOMTest* theTest=CenrepSwiOOMTest::NewL();

 		CleanupStack::PushL(theTest);

 		// Set up test

 		(theTest->*aTestFuncL)(ETrue);

 		if (aOOMMode)

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

 		TRAP(err, (theTest->*aTestFuncL)(EFalse));

 		if (aOOMMode)

 			__UHEAP_SETFAIL(RHeap::ENone, 0);

 		if (err!=KErrNoMemory)

 			TESTKErrNoneL(err);

 		CleanupStack::PopAndDestroy(theTest);

 		// check that no handles have leaked

 		TInt endProcessHandleCount;

 		TInt endThreadHandleCount;

 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 		TEST2L(startProcessHandleCount, endProcessHandleCount);

 		TEST2L(startThreadHandleCount, endThreadHandleCount);

 		//Freeing the server resources

 		TServerResources::Close();

 		__UHEAP_MARKEND;

 		} while(err == KErrNoMemory);

  	TESTKErrNoneL(err);

  	if (aOOMMode)

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

 	}

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 void CenrepSrvOOMTest::DoHeapRepositoryContentCheckL()

 	{

 	CServerRepository* srv=iServerRepo;

 	//check setting and its meta

 	TServerSetting* setting=NULL;

 	setting=srv->GetSetting(1);

 	TESTL(setting->iKey==1);

 	TESTL(setting->iMeta==0x80000010);

 	//points to global default policy here

 	TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==1);

 	setting=srv->GetSetting(2);

 	TESTL(setting->iKey==2);

 	TESTL(setting->iMeta==0xA0000010);

 	//points to global default policy here

 	TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==1);

 	setting=srv->GetSetting(3);

 	TESTL(setting->iKey==3);

 	TESTL(setting->iMeta==0x800000FF);

 	//points to global default policy here

 	TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==1);

 	setting=srv->GetSetting(4);

 	TESTL(setting->iKey==4);

 	TESTL(setting->iMeta==0x80000010);

 	TESTL(setting->iAccessPolicy->LowKey()==4);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==0);

 	setting=srv->GetSetting(5);

 	TESTL(setting->iKey==5);

 	TESTL(setting->iMeta==0xC0000063);

 	//points to global default policy here

 	TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==1);

 	setting=srv->GetSetting(6);

 	TESTL(setting->iKey==6);

 	TESTL(setting->iMeta==0x90000010);

 	TESTL(setting->iAccessPolicy->LowKey()==6);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==0);

 	setting=srv->GetSetting(7);

 	TESTL(setting->iKey==7);

 	TESTL(setting->iMeta==0x80000010);

 	TESTL(setting->iAccessPolicy->LowKey()==7);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==0);

 	setting=srv->GetSetting(9);

 	TESTL(setting->iKey==9);

 	TESTL(setting->iMeta==0x80000010);

 	TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==1);

 	setting=srv->GetSetting(10);

 	TESTL(setting->iKey==10);

 	TESTL(setting->iMeta==0x80000010);

 	TESTL(setting->iAccessPolicy->LowKey()==10);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==0);

 	setting=srv->GetSetting(300);

 	TESTL(setting->iKey==300);

 	TESTL(setting->iMeta==0x900003E7);

 	TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);

 	TESTL(setting->iAccessPolicy->HighKey()==1);

 	TESTL(setting->iAccessPolicy->KeyMask()==1);

 	}

 LOCAL_C void DoAdditionalCheckingL()

 	{

 	TServerResources::InitialiseL ();

 	CenrepSrvOOMTest* test=CenrepSrvOOMTest::NewL();

 	CleanupStack::PushL(test);

 	test->DoHeapRepositoryContentCheckL();

 	CleanupStack::PopAndDestroy();

 	TServerResources::Close();

 	}

 /**

 @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4050

 @SYMTestCaseDesc Verifying that CRE generated will have the latest CRE version which is currently 2

 @SYMTestPriority High

 @SYMTestActions  Validating that CRE files generated with post PREQ2112 code will always contain version 2.

 				 The unit test will load a txt repository and then modify some settings so that it gets persisted

 				 in the persists directory. The test then read the cre files to verify that the version persisted

 				 is the latest which is 2.

 @SYMTestExpectedResults The correct file version is returned.

 @SYMREQ REQ11282

 */

 LOCAL_C void DoPersistedVersionCheckingL()

 	{

 	TheTest.Next (_L (" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4050 Verifying CRE generated will always be version 2 "));

 	TServerResources::InitialiseL ();

 	const TUid KTestUid={0x88880000};

 	KCurrentTestUid=KTestUid;

 	CenrepSrvOOMTest* test=CenrepSrvOOMTest::NewL();

 	CleanupStack::PushL(test);

 	//persist immediately

 	test->iServerRepo->CommitChangesL();

 	//now check the version of the CRE file

 	CHeapRepository* heap=CHeapRepository::NewL(KTestUid);

 	CleanupStack::PushL(heap);

 	TUint8 creVersion;

 	heap->CreateRepositoryFromCreFileL(TServerResources::iFs,_L("c:\\private\\10202be9\\persists\\88880000.cre"),creVersion);

 	TESTL(creVersion==KPersistFormatSupportsIndMetaIndicator);

 	CleanupStack::PopAndDestroy(2,test);

 	TServerResources::Close();

 	}

 /**

 @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4051

 @SYMTestCaseDesc Server side OOM loading of a multiple repository files

 @SYMTestPriority High

 @SYMTestActions  Create the server class CServerRepository and used it to load the multi ROFS keyspace.

 				 Test are repeated for the following keyspace combination such as TXT/TXT, CRE/TXT or TXT/CRE and CRE/CRE.

 				 Test will also verify the resulting merged settings which includes checking

 				 individual metadata bits and security policy bits

 @SYMTestExpectedResults Server loading of the multi rofs keypsace should not fail and leak memory under OOM condition.

 @SYMREQ REQ11282

 */

 LOCAL_C void DoOOMMultiRofsTestL()

 	{

 	TheTest.Next (_L (" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4051 CENREPSRV MultiROFS OOM Test "));

 	const TUid KMultiRofsRepositoryUid1={0xFFFF0000};

 	const TUid KMultiRofsRepositoryUid2={0xEEEE0000};

 	const TUid KMultiRofsRepositoryUid3={0xDDDD0000};

 	const TUid KMultiRofsRepositoryUid4={0xCCCC0000};

 	//First Testuid=KMultiRofsRepositoryUid

 	//Testing the OOM of multi rofs processing

 	KCurrentTestUid=KMultiRofsRepositoryUid1;

 	DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);

 	DoAdditionalCheckingL();

 	KCurrentTestUid=KMultiRofsRepositoryUid2;

 	DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);

 	DoAdditionalCheckingL();

 	KCurrentTestUid=KMultiRofsRepositoryUid3;

 	DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);

 	DoAdditionalCheckingL();

 	KCurrentTestUid=KMultiRofsRepositoryUid4;

 	DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);

 	DoAdditionalCheckingL();

 	}

 #endif

 LOCAL_C void DoOOMTestsL()

 	{

 	TheTest.Next (_L (" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-LEGACY-T_OOMCENREP-0001 Starting CENREPSRV OOM Test "));

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	CFileMan* fm = CFileMan::NewL(fs);

 	CleanupStack::PushL(fm);

 	//Clear any files in the persist directory

 	CleanupCDriveL();

 	//First Testuid=KTestRepositoryUid

 	KCurrentTestUid=KTestRepositoryUid;

 	DoOOMTestL(&CenrepSrvOOMTest::GetL,_L("Get Basic Test"),EFalse);

 	DoOOMTestL(&CenrepSrvOOMTest::FindL,_L("FindL Basic Test"),EFalse);

 	DoOOMTestL(&CenrepSrvOOMTest::NotifyL,_L("NotifyL Basic Test"),EFalse);

 	DoOOMTestL(&CenrepSrvOOMTest::ResetL,_L("ResetL Basic Test"),EFalse);

 	// Save file without timestamp

 	User::LeaveIfError(fm->Copy(KPersistsFile, KPersistsFileNoUpgrade));

 	DoOOMTestL(&CenrepSrvOOMTest::SetL,_L("SetL Basic Test"),EFalse);

 	DoOOMTestL(&CenrepSrvOOMTest::CreateL,_L("CreateL Basic Test"),EFalse);

 	DoOOMTestL(&CenrepSrvOOMTest::DeleteL,_L("DeleteL Basic Test"),EFalse);

 	DoOOMTestL(&CenrepSrvOOMTest::MoveL,_L("MoveL Basic Test"),EFalse);

 	//Clear any files in the persist directory

 	CleanupCDriveL();

 	// Simulate response to SWI rom-upgrade and downgrade events

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev1L,_L("SwiUpgradeROMRev1L Basic Test"),EFalse);

 	// Save file with timestamp

 	User::LeaveIfError(fm->Copy(KPersistsFile, KPersistsFileUpgraded));

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev2L,_L("SwiUpgradeROMRev2L Basic Test"),EFalse);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallROMUpgradeL,_L("SwiUninstallROMUpgradeL Basic Test"),EFalse);

 	// Simulate response to SWI new rep install/uninstall event events

 	DoOOMSwiTestL(&CenrepSwiOOMTest::InstallL,_L("SwiInstallL Basic Test"),EFalse);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeInstallL,_L("SwiUpgradeInstallL Basic Test"),EFalse);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallL,_L("SwiUninstallL Basic Test"),EFalse);

 	// Simulate SWI events before server startup

 	DoOOMNoServReposL(&StartupUpgradeL, _L("Startup Upgrade Basic Test"), EFalse);

 	DoOOMNoServReposL(&StartupDowngradeL, _L("Startup Downgrade Basic Test"), EFalse);

 	DoOOMNoServReposL(&StartupUninstallL,_L("Startup Uninstall Basic Test"), EFalse);

 	//OOM Test aOOMMode=ETrue

 	DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Test"),ETrue);

 	DoOOMNoServReposL(&CreateDeleteCorruptL, _L("Create Delete Corrupt OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::GetL,_L("Get OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::FindL,_L("FindL OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::NotifyL,_L("NotifyL OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::ResetL,_L("ResetL OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::SetL,_L("SetL OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::CreateL,_L("CreateL OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::DeleteL,_L("DeleteL OOM Test"),ETrue);

 	DoOOMTestL(&CenrepSrvOOMTest::MoveL,_L("MoveL OOM Test"),ETrue);

 	//Clear any files in the persist directory

 	CleanupCDriveL();

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev1L,_L("SwiUpgradeROMRev1L OOM Test"),ETrue);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev2L,_L("SwiUpgradeROMRev2L OOM Test"),ETrue);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallROMUpgradeL,_L("SwiUninstallROMUpgradeL OOM Test"),ETrue);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::InstallL,_L("SwiInstallL OOM Test"),ETrue);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeInstallL,_L("SwiUpgradeInstallL OOM Test"),ETrue);

 	DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallL,_L("SwiUninstallL OOM Test"),ETrue);

 	DoOOMNoServReposL(&StartupUpgradeL, _L("Startup Upgrade OOM Test"), ETrue);

 	DoOOMNoServReposL(&StartupDowngradeL, _L("Startup Downgrade OOM Test"), ETrue);

 	DoOOMNoServReposL(&StartupUninstallL, _L("Startup Uninstall OOM Test"), ETrue);

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 	DoPersistedVersionCheckingL();

 	DoOOMMultiRofsTestL();

 #endif

 	// Delete files from bur dir

 	User::LeaveIfError(fm->Attribs(KPersistsFileNoUpgrade,0,KEntryAttReadOnly,TTime(0)));

 	TInt err=fs.Delete(KPersistsFileNoUpgrade);

 	if((err!=KErrNone)&&(err!=KErrNotFound))

 		User::Leave(err);

 	User::LeaveIfError(fm->Attribs(KPersistsFileUpgraded,0,KEntryAttReadOnly,TTime(0)));

 	err=fs.Delete(KPersistsFileUpgraded);

 	if((err!=KErrNone)&&(err!=KErrNotFound))

 		User::Leave(err);

 	//Clear any files in the persist directory

 	CleanupCDriveL();

 	CleanupStack::PopAndDestroy (2);	// fs and fm

 	}

 LOCAL_C void MainL()

 	{

 	TheTest.Title ();

 	TheTest.Start (_L("OOM Cenrepserv Test"));

 	CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;

 	CActiveScheduler::Install(scheduler);

 	DoOOMTestsL();

 	//Clear any files in the persist directory

 	CleanupCDriveL();

 	TheFs.Close ();

 	delete scheduler;

 	TheTest.End ();

 	TheTest.Close ();

 	}

 TInt E32Main ()

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if(!cleanup)

 		return KErrNoMemory;

 	TRAPD(err, MainL());

 	if (err != KErrNone)

 		User::Panic(_L("Testing failed: "), err);

 	delete cleanup;

 	__UHEAP_MARKEND;

 	return KErrNone;

 	}