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

#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));