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

//

#include "t_cenrep_helper.h"

#include <e32test.h>

#include <f32file.h>

#include "srvrepos_noc.h"

#include "srvres.h"

#include "cachemgr.h"

#include <bautils.h>

#include "setting.h"

//Forward declarations

class CTestObserver;

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

// Globals

static RTest TheTest(_L("T_CenRepTrans"));

const TUid KTestRepositoryId = {0x00000010};

//CentralRepository server UID

static const TUid KCenRepServerUID = {0x10202BE9};

static CTestObserver* TheObserver = NULL;

static CServerRepository* TheServerRepository = NULL;

static const TUint32 KIntSettingID = 843;

static const TInt KIntSettingVal = 25;

static const TUint32 KRealSettingID = 844;

static const TReal KRealSettingVal = 8.76;

static const TReal KRealSettingVal2 = 19.234;

static const TUint32 KStringSettingID = 845;

_LIT8(KStringSettingVal, "a test string");

_LIT8(KStringSettingVal2, "another string");

_LIT8(KEmptyString, "");

_LIT(KTestFile1,	"C:\\PRIVATE\\10202BE9\\PERSISTS\\00000010.TXT");

_LIT(KCreTestFile1,	"C:\\PRIVATE\\10202BE9\\PERSISTS\\00000010.CRE");

_LIT(KTmpTestFile1,	"C:\\PRIVATE\\10202BE9\\PERSISTS\\00000010.TMP");

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

//

//Delete file function.

//Used by the test application to cleanup the C drive at the end of the test.

static void DeleteFile(const TDesC& aFullName)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

			if(err != KErrNone)

				{

				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

				}

			err = fsSession.Delete(aFullName);

			if(err != KErrNone)

				{

				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

				}

			}

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

		}

	}

static void DeleteFiles()

	{

	::DeleteFile(KTestFile1);

	::DeleteFile(KCreTestFile1);

	::DeleteFile(KTmpTestFile1);

	}

static TInt GetFileTimeStamp(const TDesC& aFullName, TTime& aTime)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

			aTime=entry.iModified;

			}

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

		}

	return err;

	}

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

// Test macros and functions.

static void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		::DeleteFiles();

		TheTest(EFalse, aLine);

		}

	}

static  void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		::DeleteFiles();

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

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

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

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

static void CheckTmpFileDeleted()

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		// Allow time for file to be deleted

		User::After(500*1000);

		TEST2 (BaflUtils::FileExists (fsSession, KTmpTestFile1), EFalse);

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session.\n"), err);

		}

	}

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

// CTestObserver class

//It is needed for the creation of CServerRepository object.

//Used also to track Get/Set/Create/Delete setting notifications, received

//from CServerRepository object.

class CTestObserver : public CBase, public MObserver

	{

public:

	CTestObserver();

	void Notify(TUint32 aId);

public:

	TBool iAssertNotification;

	};

CTestObserver::CTestObserver() :

	iAssertNotification(EFalse)

	{

	}

void CTestObserver::Notify(TUint32 aId)

	{

	RDebug::Print(_L("Notification! Id=%d.\n"), aId);

	if(iAssertNotification)

		{

		TEST(0);

		}

	}

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

//

//Deletes the global TheObserver object. Sets it to NULL.

static void ReleaseObserver(TAny*)

	{

	delete TheObserver;

	TheObserver = NULL;

	}

//Deletes the global TheServerRepository object. Sets it to NULL.

static void ReleaseRepository(TAny*)

	{

	TheServerRepository->Close();

	delete TheServerRepository;

	TheServerRepository = NULL;

	TServerResources::iCacheManager->DisableCache(ETrue);

	TServerResources::iObserver->CloseiOpenRepositories();

	TServerResources::iCacheManager->EnableCache();

	}

//This function is called from CreateSetting_OOMtestL().

//It creates an integer, real or string setting in the repository

//with ID=KTestRepositoryId. All this is done in an OOM loop.

//The output from this test is: the repository file with ID = KTestRepositoryId

//will be copied from Z to C drive;

// An integer, real or string setting will be created in that repository.

//Changes in the repository will be stored on C drive (in the related repository file)

static void DoCreateSettingL(TBool aTrapping,TServerSetting::TType aSettingType)

	{

	TheObserver = new (ELeave) CTestObserver;

	TCleanupItem clnItem1(&ReleaseObserver, NULL);

	CleanupStack::PushL(clnItem1);

	TheServerRepository = new (ELeave) CServerRepository;

	TCleanupItem clnItem2(&ReleaseRepository, NULL);

	CleanupStack::PushL(clnItem2);

	// Turn OOM trapping on Repository Open on/off for testing purposes.

	TServerResources::iObserver->iTrapOOMOnOpen=aTrapping;

	// Open the repository

	TheServerRepository->OpenL(KTestRepositoryId, *TheObserver);

	// All write operations, including CreateL must be done in a transaction

	TheServerRepository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TheServerRepository->CleanupCancelTransactionPushL();

	//Create the appropriate setting based on aValueType

	switch(aSettingType)

		{

		case TServerSetting::EInt:

			{

			// Create setting - fails if value already there (it must not be)

			User::LeaveIfError(TheServerRepository->TransactionCreateL(KIntSettingID, KIntSettingVal, NULL));

			// Try to get the value from the transaction cache

			TInt val = 0;

			User::LeaveIfError(TheServerRepository->Get(KIntSettingID, val));

			TEST2(val,KIntSettingVal);

			break;

			}

		case TServerSetting::EReal:

			{

			// Create setting - fails if value already there (it must not be)

			User::LeaveIfError(TheServerRepository->TransactionCreateL(KRealSettingID, KRealSettingVal, NULL));

			// Try to get the value from the transaction cache

			TReal val = 0;

			User::LeaveIfError(TheServerRepository->Get(KRealSettingID, val));

			TEST(val == KRealSettingVal);

			break;

			}

		case TServerSetting::EString:

			{

			// Create setting - fails if value already there (it must not be)

			User::LeaveIfError(TheServerRepository->TransactionCreateL(KStringSettingID, KStringSettingVal, NULL));

			// Try to get the value from the transaction cache

			TBuf8<16> bufVal(KEmptyString);

			User::LeaveIfError(TheServerRepository->Get(KStringSettingID, bufVal));

			TEST(bufVal == KStringSettingVal);

			break;

			}

		default:

			break;

		}

	// Commit the changes

	CleanupStack::Pop();

	TUint32 keyInfo;

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

	TServerResources::iObserver->iTrapOOMOnOpen=EFalse;

	// Close the repository

	TheServerRepository->Close();

	CleanupStack::PopAndDestroy(2);//TheObserver & TheServerRepository

	}

//This function is called from SetSetting_OOMtest().

//It expects that the previous test (CreateSetting_OOMtestL()) had completed successfully

//and there is a repository file (ID=0x10) on drive C and there is an integer setting

//in that repository (ID=KIntSettingID, Value=KIntSettingVal).

//The test will try to change the setting value in a transaction. Because the test is

//executed in an OOM loop, CommitChangesL() - will fail when called by SetL, leaving the

//repository content inconsistent - the in-memory repository content will be deleted

//(no settings), but in  the file the setting will exist and its value will still be KIntSettingVal.

static void DoSetIntSettingL()

	{

	TEST(TheObserver != NULL);

	TEST(TheServerRepository != NULL);

	// Check if the setting is there - and has (or is restored to) the original value

	TInt val = 0;

	User::LeaveIfError(TheServerRepository->Get(KIntSettingID, val));

	TEST2(val,KIntSettingVal);

	// Change the setting value

	// All write operations, including CreateL must be done in a transaction

	TheServerRepository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TheServerRepository->CleanupCancelTransactionPushL();

	// Change the setting value

	User::LeaveIfError(TheServerRepository->TransactionSetL(KIntSettingID, KIntSettingVal + 1));

	// Check if the setting is there - it should be in transaction cache now

	User::LeaveIfError(TheServerRepository->Get(KIntSettingID, val));

	TEST2(val,(KIntSettingVal + 1));

	// Commit the changes

	CleanupStack::Pop();

	TUint32 keyInfo;

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

	// Check if the setting is there. The transaction was successful so the new value

	// should be returned.

	val = 0;

	User::LeaveIfError(TheServerRepository->Get(KIntSettingID, val));

	TEST2(val,(KIntSettingVal + 1));

	}

//This function is called from SetSetting_OOMtest().

//It expects that the previous test (CreateSetting_OOMtestL()) had completed successfully

//and there is a repository file (ID=0x10) on drive C and there is an rea; setting

//in that repository (ID=KRealSettingID, Value=KRealSettingVal).

//The test will try to change the setting value in a transaction. Because the test is

//executed in an OOM loop, CommitChangesL() - will fail when called by SetL, leaving the

//repository content inconsistent - the in-memory repository content will be deleted

//(no settings), but in  the file the setting will exist and its value will still be KRealSettingVal.

static void DoSetRealSettingL()

	{

	TEST(TheObserver != NULL);

	TEST(TheServerRepository != NULL);

	// Check if the setting is there - and has (or is restored to) the original value

	TReal val = 0;

	User::LeaveIfError(TheServerRepository->Get(KRealSettingID, val));

	TEST(val == KRealSettingVal);

	// Change the setting value

	// All write operations, including CreateL must be done in a transaction

	TheServerRepository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TheServerRepository->CleanupCancelTransactionPushL();

	// Change the setting value

	User::LeaveIfError(TheServerRepository->TransactionSetL(KRealSettingID, KRealSettingVal2));

	// Check if the setting is there - it should be in transaction cache now

	User::LeaveIfError(TheServerRepository->Get(KRealSettingID, val));

	TEST(val == KRealSettingVal2);

	// Commit the changes

	CleanupStack::Pop();

	TUint32 keyInfo;

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

	// Check if the setting is there. The transaction was successful so the new value

	// should be returned.

	val = 0;

	User::LeaveIfError(TheServerRepository->Get(KRealSettingID, val));

	TEST(val == KRealSettingVal2);

	}

//This function is called from SetSetting_OOMtest().

//It expects that the previous test (CreateSetting_OOMtestL()) had completed successfully

//and there is a repository file (ID=0x10) on drive C and there is an string setting

//in that repository (ID=KStringSettingID, Value=KStringSettingVal).

//The test will try to change the setting value in a transaction. Because the test is

//executed in an OOM loop, CommitChangesL() - will fail when called by SetL, leaving the

//repository content inconsistent - the in-memory repository content will be deleted

//(no settings), but in  the file the setting will exist and its value will still

//be KStringSettingVal.

static void DoSetStringSettingL()

	{

	TEST(TheObserver != NULL);

	TEST(TheServerRepository != NULL);

	// Check if the setting is there - and has (or is restored to) the original value

	TBuf8<16> bufVal(KEmptyString);

	User::LeaveIfError(TheServerRepository->Get(KStringSettingID, bufVal));

	TEST(bufVal == KStringSettingVal);

	// Change the setting value

	// All write operations, including CreateL must be done in a transaction

	TheServerRepository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TheServerRepository->CleanupCancelTransactionPushL();

	// Change the setting value

	User::LeaveIfError(TheServerRepository->TransactionSetL(KStringSettingID, KStringSettingVal2));

	// Check if the setting is there - it should be in transaction cache now

	User::LeaveIfError(TheServerRepository->Get(KStringSettingID, bufVal));

	TEST(bufVal == KStringSettingVal2);

	// Commit the changes

	CleanupStack::Pop();

	TUint32 keyInfo;

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

	// Check if the setting is there. The transaction was successful so the new value

	// should be returned.

	bufVal = KEmptyString;

	User::LeaveIfError(TheServerRepository->Get(KStringSettingID, bufVal));

	TEST(bufVal == KStringSettingVal2);

	}

//This function is called from SetSetting_OOMtest()in the case where previous

//DoSetSettingL() call failed with KErrNoMemory, leaving the repository object

//in inconsisten state - the in-memory presentation of the repository differs from

//the repository file content. The function will try to repair the repository,

//as it would have to happen in a real situation. Then it will check that

//the repository content is consistent, which means the tested setting value should

//be the same as it was before DoSetSettingL() call.

static void DoRecoverRepositoryL(TServerSetting::TType aSettingType)

	{

	//Repair the repository as it happens in a real situation

	//AccessL calls RestoreConsistencyL() indirectly

	//RestoreConsistencyL() is called in the production code from the session object,

	//ServiceL() implementation. So, it will be called before any other repository call

	//and it should restore the repository content - it should repair the repository

	//consitency.

	TServerResources::iObserver->AccessL(KTestRepositoryId);

	//Check if the setting is there - the old, pre-transactional value should be

	//in-memory now.

	switch(aSettingType)

		{

		case TServerSetting::EInt:

			{

			TInt val = 0;

			User::LeaveIfError(TheServerRepository->Get(KIntSettingID, val));

			TEST2(val,KIntSettingVal);

			break;

			}

		case TServerSetting::EReal:

			{

			TReal val = 0;

			User::LeaveIfError(TheServerRepository->Get(KRealSettingID, val));

			TEST(val == KRealSettingVal);

			break;

			}

		case TServerSetting::EString:

			{

			TBuf8<16> bufVal(KEmptyString);

			User::LeaveIfError(TheServerRepository->Get(KStringSettingID, bufVal));

			TEST(bufVal == KStringSettingVal);

			break;

			}

		default:

			break;

		}

	}

//Inits TServerResources object.

//It should be called once, before the creation of CServerRepository object.

static void InitEnvL()

	{

	TServerResources::InitialiseL();

	delete TServerResources::iDataDirectory; TServerResources::iDataDirectory = NULL;

	delete TServerResources::iRomDirectory; TServerResources::iRomDirectory = NULL;

	delete TServerResources::iInstallDirectory; TServerResources::iInstallDirectory = NULL;

	TServerResources::iDataDirectory = HBufC::NewL(KMaxFileName);

	TServerResources::iRomDirectory = HBufC::NewL(KMaxFileName);

	TServerResources::iInstallDirectory = HBufC::NewL(KMaxFileName);

	TBuf<32> uidName;

	uidName.Format(_L("%08X"), KCenRepServerUID.iUid);

	TPtr ptr1(TServerResources::iDataDirectory->Des());

	ptr1.Append(_L("C:\\PRIVATE\\"));

	ptr1.Append(uidName);

	ptr1.Append(_L("\\PERSISTS\\"));

	TPtr ptr2(TServerResources::iRomDirectory->Des());

	ptr2.Append(_L("Z:\\PRIVATE\\"));

	ptr2.Append(uidName);

	ptr2.Append(_L("\\"));

	TPtr ptr3(TServerResources::iInstallDirectory->Des());

	ptr3.Append(_L("C:\\PRIVATE\\"));

	ptr3.Append(uidName);

	ptr3.Append(_L("\\"));

	}

//Destroys TServerResources object.

//It should be called after the CServerRepository object was destroyed.

static void ReleaseEnv()

	{

	TServerResources::Close();

	}

//Creates global TheServerRepository and TheObserver objects

//It is used in SetSetting_OOMtest()

static void InitEnv2L()

	{

	TheObserver = new CTestObserver;

	TEST(TheObserver != NULL);

	TheServerRepository = new CServerRepository;

	TEST(TheServerRepository != NULL);

	TheServerRepository->OpenL(KTestRepositoryId, *TheObserver);

	}

//Destroys global TheServerRepository and TheObserver objects

//It is used in SetSetting_OOMtest()

static void ReleaseEnv2()

	{

	::ReleaseRepository(NULL);

	::ReleaseObserver(NULL);

	}

//Central repository test: it creates a setting in OOM conditions.

static void CreateSetting_OOMtestL(TBool aTrapping,TServerSetting::TType aSettingType)

	{

	TInt err;

	TRAP(err, ::InitEnvL());

	TEST2(err, KErrNone);

	for(TInt count=1;;++count)

		{

		CleanupCDriveL();

		__UHEAP_FAILNEXT(count);

		__UHEAP_MARK;

		TRAP(err, ::DoCreateSettingL(aTrapping,aSettingType));

		TServerResources::iOwnerIdLookUpTable.Reset();

		TServerResources::iObserver->Reset();

		__UHEAP_MARKEND;

		if(err == KErrNone)

			{

			RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count);

			break;

			}

		else if(err != KErrNoMemory)

			{

			TEST2(err, KErrNone);

			}

		}

	::ReleaseEnv();

	__UHEAP_RESET;

	}

//Central repository test: it sets new setting value in OOM conditions.

//Then ComitChangesL() is called to store the new setting's value in the repository

//file. Because of the simulated OOM conditions ComitChangesL() can fail, leaving the

//repository in inconsistent state.

//DoRecoverRepositoryL() is called to repair the repository and restore the consistency.

static void SetSetting_OOMtest(TServerSetting::TType aSettingType)

	{

	TTime before;

	TTime after;

	// Check that cre file exists and get modification time

	TEST2 (GetFileTimeStamp(KCreTestFile1, before), KErrNone);

	after=before;

	TInt err;

	TRAP(err, ::InitEnvL());

	TEST2(err, KErrNone);

	TRAP(err, ::InitEnv2L());

	TEST2(err, KErrNone);	

	for(TInt count=1;;++count)

		{

		__UHEAP_FAILNEXT(count);

		__UHEAP_MARK;

	switch(aSettingType)

		{

		case TServerSetting::EInt:

			{

			TRAP(err, ::DoSetIntSettingL());

			break;

			}

		case TServerSetting::EReal:

			{

			TRAP(err, ::DoSetRealSettingL());

			break;

			}

		case TServerSetting::EString:

			{

			TRAP(err, ::DoSetStringSettingL());

			break;

			}

		default:

			break;

		}

		// Get timestamp of cre file. It is now possible for the commit to

		// fail with KErrNoMemory after a successful write. If filestamp

		// changes, the cre file has been written and the test is complete

		TEST2 (GetFileTimeStamp(KCreTestFile1, after), KErrNone);

		if(before!=after)

			{

			err=KErrNone;

			}

		if(err == KErrNoMemory)

			{

			__UHEAP_MARKEND;

			//DoSetSettingL() call failed (so the transaction). Try to recover.

			TInt err2;

			TRAP(err2, ::DoRecoverRepositoryL(aSettingType));

			TEST2(err2, KErrNone);

			}

		else if(err == KErrNone)

			{

			//The heap cannot be checked at this point because memory may have been

			//allocated which must be freed by a call to ReleaseEnv2.

			//It is checked outside the loop instead

			RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count);

			break;

			}

		else

			{

			__UHEAP_MARKEND;

			TEST2(err, KErrNone);

			}

		// Check that tmp file generated by attempted commit is deleted

		// by RestoreConsistencyL() in DoRecoverRepositoryL().

		::CheckTmpFileDeleted();

		}

	// Check that no tmp file is left over

	::ReleaseEnv2();

	::ReleaseEnv();

	//This __UHEAP_MARKEND checks the heap after the call to DoSetxSettings

	//succeeds as calls to CommitTRansactions can allocate memory which must be freed

	//by calling ReleaseEnv2

	__UHEAP_MARKEND;

	__UHEAP_RESET;

	}

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

void RunTestsL(TServerSetting::TType aSettingType)

	{

	TheTest.Next(_L("Create setting - OOM test - OOM Trapping off"));

	::CreateSetting_OOMtestL(EFalse,aSettingType);

	TheTest.Next(_L("Create setting - OOM test - OOM Trapping on"));

	::CreateSetting_OOMtestL(ETrue,aSettingType);

	TheTest.Next(_L("Set setting - transaction - OOM test"));

	::SetSetting_OOMtest(aSettingType);

	}

static void MainL()

	{

	// create and install the active scheduler we need for the cache manager in TServerResources::InitialiseL

	CActiveScheduler* cacheManagerAS=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(cacheManagerAS);

	CActiveScheduler::Install(cacheManagerAS);

	::DeleteFiles();

	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-LEGACY-T_CENREPTRANS-0001 Int Setting Tests "));

	RunTestsL(TServerSetting::EInt);

	TheTest.Next(_L("Real Setting Tests"));

	RunTestsL(TServerSetting::EReal);

	TheTest.Next(_L("String Setting Tests"));

	RunTestsL(TServerSetting::EString);

	TheTest.End();

	TheTest.Close();

	CleanupStack::PopAndDestroy(cacheManagerAS);

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* tc = CTrapCleanup::New();

	TEST(tc != NULL);

	TheTest.Title();

	TRAPD(err, ::MainL());

	TEST2(err, KErrNone);

	::DeleteFiles();

	delete tc;

	__UHEAP_MARKEND;

	User::Heap().Check();

	return KErrNone;

	}