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