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

 	}