// Copyright (c) 2004-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 <centralrepository.h>

 #include <e32property.h>

 #include <e32test.h>

 #include <f32file.h>

 #include <bautils.h>

 #include <cenrepnotifyhandler.h>

 #include "e32math.h"

 #include "srvparams.h"

 #include "srvreqs.h"

 #include "srvdefs.h"

 #include "transstate.h"

 #include "obsrvr_noc.h"

 #include "shrepos.h"

 #include "install.h"

 using namespace NCentralRepositoryConstants;

 RTest TheTest(_L("Central Repository Defect Tests"));

 _LIT( KCentralRepositoryServerName, "Centralrepositorysrv");

 const TUid KUidDEF060843LRepository1    = { 0x00000001 };

 const TUid KUidRep1						= { 0x00000100 };

 const TUid KUidDEF053500LTestRepository = { 0x00000102 };

 const TUid KUidDEF054368TestRepository  = { 0x00000103 };

 const TUid KUidINC054688TestRepository  = { 0x100058db };

 const TUid KUidDEF054632TestRepository  = { 0x10054632 };

 const TUid KUidDEF054633TestRepository  = { 0x10054633 };

 const TUid KUidLargeRepository          = { 0xCCCCCC01 };

 const TUid KUidDEF055661TestRepository  = { 0x10055661 };

 const TUid KUidINC056194TestRepository  = { 0x00056194 };

 const TUid KUidDEF057778TestRepository  = { 0x00057778 };

 const TUid KUidDEF057470TestRepository 	= { 0x10057470 };

 const TUid KUidDEF058900TestRepository 	= { 0x10058900 };

 const TUid KUidINC069013TestRepository 	= { 0x00000104 };

 const TUid KUidPDEF098500LRepository		= { 0x10098500 };

 const TUint32 KRangeDeletePartialKey 			= 0x04010000 ;

 const TUint32 KDeleteKeyDoesntExist  			= 0x07000000 ;

 const TUint32 KDeleteForbidden     				= 0x03010000 ;

 const TUint32 KTransactionRangeDeletePartialKey = 0x02010000 ;

 const TUint32 KRangeDeleteMask       			= 0x0F0F0000 ;

 const TUint32 KNullKey							= 0x00000000 ;

 const TUint32 KNotifyBannedKey					= static_cast<TUint32>(KRequestPending) ;

 const TUint32 KNotificationKey1					= 0x80000101;

 const TUint32 KNotificationKey2					= 0x80000201;

 const TUint32 KNotificationKey3					= 0x80000301;

 const TUint32 KNotificationKey4					= 0x80000401;

 //

 // Repository A

 //

 const TUint32 KNewInt = 1000;

 const TInt KIntValue = 1234;

 // Definitions for test DEF116629L()

 // The structure to construct a TServerSetting object with a TInt value.

 struct ServerSettingStruct

 	{

 	TUint32 key;

 	TUint32 meta;

 	TInt value;

 	};

 // The merge types to be tested

 const TMergeType KMergerTypes[] = {ETransactionMerge,ERestoreMerge, ESWIUpgradeMerge, ESWIDowngradeMerge, ERomFlash};

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

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

 //Test macroses and functions

 LOCAL_C void CheckL(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		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 TEST(arg) ::CheckL((arg), __LINE__)

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

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

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

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4015

 @SYMTestCaseDesc When having multiple connections to a particular repository, starting a

 transaction and then killing that connection, should not cause a reset.

 @SYMTestPriority High

 @SYMTestActions

 	Essentially - this deals with multiple connections, the lack of cancelling a transaction,

  	either by shutting the sub-session to the CR server directly (or by a crashing application

  	where all open sub-sessions to CR from that application are closed) and the cache manager

  	inside CR.

    Previously, CR's cache manager would reclaim repository memory regardless of the state

    of the repository (in transaction or not).  However, if a repository is closed and its

    no longer an open repository (cache manager reclaimed the memory), it would not remove

    references to the sub-session for this repository in the transaction queue.  Simply put,

    the sub-session's data would be deleted but there would still be references to that

    deleted data.  When you established a new connection (any operation would cause this) you'd

    walk down an invalid pointer.  Most of the time this would cause the server to crash.

    Now, if you're in an active transaction, the cache manager does not reclaim the data.

    Which means that there will always be valid references in the transaction queue.

    ThreadA                                   CR                        CR Cache Manager

    Connection 1.

    CRepository::NewLC(X) --------------->   EInitialize

    Connection 2.

    CRepository::NewLC(X) --------------->   EInitialize

    Connection 2, Start Transaction

    StartTransaction     ---------------->   ETransactionStart

    Before

    ----------------------------------------------------------------------------------

    Wait 10 seconds

                                                  <--------------------------- Evict(X)

    Connection 2. Close

    delete connection2 ------------------>   EClose (would leave invalid references)

    Connection 1.

    GetInt             ------------------>   EGetInt (would attach to repository, derefence

                                                      invalid pointer, CR would crash)

    -----------------------------------------------------------------------------------

    Now

    Wait 10 seconds

                                                                               Reschedule

                                                   (CR cache manager sees that Repository X

                                                    is in a transaction and just reschedules

                                                    it)

    Connection 2. Close

    delete connection2 --------------------> EClose (memory is now available so it cancels

                                                     the active transaction)

    GetInt             --------------------> EGetInt (attaches to the open repository, all is

                                                      fine)

    delete connection2 --------------------> EClose (repository X has no more observers so

                                                     it is scheduled to have its memory reclaimed

                                                     by CR cache manager)

 @SYMTestExpectedResults The test must not fail.

 @SYMDEF DEF111734

 */

 LOCAL_C void DEF111734L()

 	{

 	/* first establish a connection. this is important because if there are no observers

 	 * on a repository, the repository's shared data is deleted directly */

 	CRepository* rep;

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));

 	/* second establish a second connection.  this will be used to start a transaction */

 	CRepository* rep2;

 	User::LeaveIfNull(rep2 = CRepository::NewLC(KUidDEF054368TestRepository));

 	/* establish a transaction, this manipulates the transaction queue for this repository */

 	rep2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

 	/* now wait.  this should be plenty of time to allow cache manager in CR to reclaim

 	 * the data for this repository */

 	User::After(5050000 + 9500000);

 	TInt i = 0;

 	const TInt KInt1_InitialValue = 100;

 	const TUint32 KInt1 = 0x1;

 	/* destory the connection - this will cause a "close" operation in CR */

 	CleanupStack::PopAndDestroy(rep2);

 	/* attempt to reconnect to the repository. */

 	TInt r = rep->Get(KInt1, i);

 	/* if the fix is not in the build, then CR will crash.

 	 * Errcode will be KErrServerTerminated */

 	TEST2(r, KErrNone);

 	/* just for completion's sake, check the return value */

 	TEST(i == KInt1_InitialValue);

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void DEF053500L()

 	{

 	CRepository* rep;

 	// Open repository with hex key value setting

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF053500LTestRepository));

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void DEF054368L()

 	{

 	CRepository* rep;

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));

 	TInt i = 0;

 	const TInt KInt1_InitialValue = 100;

 	const TInt KInt2_InitialValue = 200;

 	const TInt KInt3_InitialValue = -100;

 	const TInt KInt4_InitialValue = -200;

 	const TInt KInt5_InitialValue = 0xc8;

 	const TUint32 KInt1 = 0x1;

 	const TUint32 KInt2 = 0x2;

 	const TUint32 KInt3 = 0x3;

 	const TUint32 KInt4 = 0x4;

     const TUint32 KInt5 = 0x5;

 	TInt r = rep->Get(KInt1, i);

 	TEST2(r, KErrNone);

 	TEST(i==KInt1_InitialValue);

 	r = rep->Get(KInt2, i);

 	TEST2(r, KErrNone);

 	TEST(i==KInt2_InitialValue);

 	r = rep->Get(KInt3, i);

 	TEST2(r, KErrNone);

 	TEST(i==KInt3_InitialValue);

 	r = rep->Get(KInt4, i);

 	TEST2(r, KErrNone);

 	TEST(i==KInt4_InitialValue);

 	r = rep->Get(KInt5, i);

 	TEST2(r, KErrNone);

 	TEST(i==KInt5_InitialValue);

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void DEF055680L()

 	{

 	CRepository* rep;

 	// Open repository

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

 	// Find setting whose value the test doesn't have permission to look at

 	RArray<TUint32> foundIds;

 	TInt r = KErrNone;

 	r = rep->FindL(0x810100, 0xFFFFFFFF, foundIds);

 	TEST2(r, KErrNone);

 	TEST2(foundIds.Count(), 1);

 	TInt val;

 	r = rep->Get(foundIds[0], val);

 	TEST2(r, KErrPermissionDenied);

 	foundIds.Reset();

 	r = rep->Create(KNewInt, KIntValue);

 	TEST2(r, KErrNone);

 	//Reset repository to remove any changes made during this test

 	r = rep->Reset();

 	TEST2(r, KErrNone);

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void DEF054632L()

 	{

 	CRepository* rep;

 	//----------Testing for correct default policy behaviour---------------

 	/*---------------------10054632.txt------------------------------------

 	[platsec]

 	cap_rd=ReadDeviceData cap_wr=WriteDeviceData

 	0x3 0x4 cap_wr=NetworkServices

 	[Main]

 	0x1 int 1 0 cap_rd=CommDD

 	0x2 int 2 1 cap_wr=CommDD

 	0x3 int 3 0

 	0x4 int 4 0

 	0x5 int 5 0 cap_rd=CommDD

 	---------------------------------------------------------------------*/

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054632TestRepository));

 	//testing single policies

 	TInt err=KErrNone;

 	const TInt key_2=2;

 	const TInt key_1=1;

 	TInt value=0;

 	err=rep->Get(key_2,value);

 	TEST2(err,KErrNone);

 	err=rep->Set(key_1,value);

 	TEST2(err,KErrNone);

 	//testing range policies

 	const TInt key_3=3;

 	err=rep->Get(key_3,value);

 	TEST2(err,KErrNone);

 	CleanupStack::PopAndDestroy(rep);

 	//------Testing for correct policy behaviour with no default policies-----

 	/*--------------------------10054633.txt----------------------------------

 	[platsec]

 	0x3 0x4 cap_rd=CommDD

 	[Main]

 	0x1 int 1 0 cap_rd=CommDD

 	0x2 int 2 1 cap_wr=CommDD

 	0x3 int 3 0

 	0x4 int 4 0

 	------------------------------------------------------------------------*/

 	User::LeaveIfNull(rep=CRepository::NewLC(KUidDEF054633TestRepository));

 	//testing single policies

 	err=rep->Get(key_1,value);

 	TEST2(err,KErrPermissionDenied);

 	err=rep->Set(key_1,value);

 	TEST2(err,KErrPermissionDenied);

 	err=rep->Set(key_2,value);

 	TEST2(err,KErrPermissionDenied);

 	err=rep->Get(key_2,value);

 	TEST2(err,KErrPermissionDenied);

 	//testing range policies

 	err=rep->Get(key_3,value);

 	TEST2(err,KErrPermissionDenied);

 	const TInt key_4=4;

 	err=rep->Set(key_4,value);

 	TEST2(err,KErrPermissionDenied);

 	err=rep->Get(key_4,value);

 	TEST2(err,KErrPermissionDenied);

 	CleanupStack::PopAndDestroy(rep);

 	}

 /**

 This test will be checking the robustness of the modified array structure

 for the single policies, range policies.

 */

 LOCAL_C void INC054688L()

 	{

 	CRepository* rep;

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));

 	//--------------CHECKING THE SINGLE POLICIES ARRAY----------------------

 	//The ini file has been structured so that the key will be equal to the

 	//key value so we can test it using a loop.

 	//and also to check some policy checking, we set all the even entries to

 	//be non accessible due to insufficient capabilities

 	//The key tested for the single policies are from 1 to 24

 	const TInt KMaxKeyEntry=24;

 	TInt err=KErrNone;

 	TInt key_value=0;

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

 		{

 		err=rep->Get(i,key_value);

 		//even entries alway not accessible due to insufficient caps

 		if (i%2==0)

 			TEST2(err,KErrPermissionDenied);

 		else

 			{

 			TEST2(err,KErrNone);

 			TEST2(i,key_value);

 			}

 		}

 	//--------------CHECKING THE RANGE POLICIES ARRAY----------------------

 	//The range policies in the [platsec] section are arranged in key pairs

 	//e.g 25-26,27-28.For testing purpose, the odd pairs(e.g 25-26 is the

 	//first pair) will require capabilities that the test lacks off hence

 	//causing KErrPermissionDenied when trying to read those range.

 	//The key tested for the arary policies are from 25-38 and the value

 	//matches the key

 	const TInt startRangeKey=25;

 	const TInt KMaxRangeKey=38;

 	TInt numberOfPairs=(KMaxRangeKey-startRangeKey+1)/2;

 	TInt key_value1=0;

 	TInt err1=KErrNone;

 	for (TInt j=0;j<numberOfPairs;j++)

 		{

 		//Get first key of the pair

 		err=rep->Get(startRangeKey+(2*j),key_value);

 		//Get second key of the pair

 		err1=rep->Get(startRangeKey+(2*j)+1,key_value1);

 		//start from j=0(first pair)

 		if ((j+1)%2==0)

 			{

 			TEST2(err,KErrNone);

 			TEST2(err1,KErrNone);

 			TEST2(startRangeKey+(2*j),key_value);

 			TEST2(startRangeKey+(2*j)+1,key_value1);

 			}

 		//only odd pairs are non-accessible due to insufficient caps

 		else

 			{

 			TEST2(err,KErrPermissionDenied);

 			TEST2(err1,KErrPermissionDenied);

 			}

 		}

 	//Before closing the repository, modify one of the key to see whether

 	//the policy array behaves similarly after a rewrite of the ini file

 	const TInt keyToChange=3;

 	const TInt modifiedValue=3;

 	err=rep->Set(keyToChange,modifiedValue);

 	TEST2(err,KErrNone);

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	User::After(KGeneralDelay);

 	//Reopen the repository again after that minor update which will cause

 	//all the entry in the ini file to be reversed

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));

 	//---------RECHECKING THE POLICY ARRAY AFTER UPDATE--------------------

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

 		{

 		err=rep->Get(i,key_value);

 		//even entries alway not accessible due to insufficient caps

 		if (i%2==0)

 			TEST2(err,KErrPermissionDenied);

 		else

 			{

 			TEST2(err,KErrNone);

 			TEST2(i,key_value);

 			}

 		}

 	//---------RECHECKING THE RANGE POLICY ARRAY AFTER UPDATE-------------

 	for (TInt j=0;j<numberOfPairs;j++)

 		{

 		//Get first key of the pair

 		err=rep->Get(startRangeKey+(2*j),key_value);

 		//Get second key of the pair

 		err1=rep->Get(startRangeKey+(2*j)+1,key_value1);

 		//start from j=0(first pair)

 		if ((j+1)%2==0)

 			{

 			TEST2(err,KErrNone);

 			TEST2(err1,KErrNone);

 			TEST2(startRangeKey+(2*j),key_value);

 			TEST2(startRangeKey+(2*j)+1,key_value1);

 			}

 		//only odd pairs are non-accessible due to insufficient caps

 		else

 			{

 			TEST2(err,KErrPermissionDenied);

 			TEST2(err1,KErrPermissionDenied);

 			}

 		}

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void DEF055661L()

 	{

 	/*--------------------10055661.txt----------------------------------------

 	[platsec]

 	cap_rd=ReadDeviceData cap_wr=AlwaysFail

 	0x3 0x4 cap_wr=NetworkServices

 	[Main]

 	0x1 int 1 0 cap_rd=AlwaysPass

 	0x2 int 2 1 cap_rd=AlwaysFail

 	0x3 int 3 0

 	0x4 int 4 0 cap_rd=AlwaysFail

 	0x5 int 5 0 cap_wr=AlwaysPass

 	-------------------------------------------------------------------------*/

 	CRepository* rep;

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF055661TestRepository));

 	TInt err=KErrNone;

 	TInt keyValue=0;

 	//Key 1

 	err=rep->Get(1,keyValue);

 	TEST2(err,KErrNone);

 	TEST2(keyValue,1);

 	err=rep->Set(1,keyValue);

 	TEST2(err,KErrPermissionDenied);

 	//Key 2

 	err=rep->Get(2,keyValue);

 	TEST2(err,KErrPermissionDenied);

 	err=rep->Set(2,keyValue);

 	TEST2(err,KErrPermissionDenied);

 	//Key 3

 	err=rep->Get(3,keyValue);

 	TEST2(err,KErrNone);

 	TEST2(keyValue,3);

 	err=rep->Set(3,keyValue);

 	TEST2(err,KErrPermissionDenied);

 	//Key 4

 	err=rep->Get(4,keyValue);

 	TEST2(err,KErrPermissionDenied);

 	err=rep->Set(4,keyValue);

 	TEST2(err,KErrPermissionDenied);

 	//Key 5

 	err=rep->Get(5,keyValue);

 	TEST2(err,KErrNone);

 	err=rep->Set(5,keyValue);

 	TEST2(err,KErrNone);

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void DEF055267L()

 	{

 	CRepository* rep;

 	// Open repository

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

 	TInt r;

 	TUint32 errorId;

 	// The following loop creates enough settings to blow the server heap

 	// when it's 1 M. If it passes it proves that the server heap is > 1M

 	// Increasing the server heap allows the messaging test to pass

 	_LIT(KString, "Long test string !!!!!!!!!!!");

 	const TInt KNumTransactions=25;

 	const TInt KNumSettingsInTrans=100;

 	for(TInt numTransactions=0; numTransactions<KNumTransactions;numTransactions++)

 		{

 		r = rep->StartTransaction(CRepository::EReadWriteTransaction);

 		TEST2(r, KErrNone);

 		for(TInt numSettingsInTrans=0; numSettingsInTrans<KNumSettingsInTrans; numSettingsInTrans++)

 			{

 			r = rep->Create((numTransactions*KNumSettingsInTrans)+numSettingsInTrans, KString);

 			TEST2(r, KErrNone);

 			}

 		r = rep->CommitTransaction(errorId);

 		TEST2(r, KErrNone);

 		}

 	//Reset repository to remove any changes made during this test

 	r = rep->Reset();

 	TEST2(r, KErrNone);

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	}

 LOCAL_C void INC056194L()

 	{

 	CRepository* repository;

 	// Open repository

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidINC056194TestRepository));

 	const TUint32 KInt1 = 1;

 	TRequestStatus intStatus;

 	TInt r = repository->NotifyRequest(KInt1, intStatus);

 	TEST2(r, KErrNone);

 	r = repository->NotifyCancel(KInt1);

 	TEST2(r, KErrNone);

 	User::WaitForAnyRequest();

 	TEST(intStatus==KUnspecifiedKey);

 	r = repository->NotifyRequest(KInt1, intStatus);

 	TEST2(r, KErrNone);

 	r = repository->NotifyCancelAll();

 	TEST2(r, KErrNone);

 	User::WaitForAnyRequest();

 	TEST(intStatus==KUnspecifiedKey);

 	r = repository->NotifyRequest(0, KInt1, intStatus);

 	TEST2(r, KErrNone);

 	r = repository->NotifyCancel(0, KInt1);

 	TEST2(r, KErrNone);

 	User::WaitForAnyRequest();

 	TEST(intStatus==KUnspecifiedKey);

 	RThread thisThread;

 	TEST(thisThread.RequestCount()==0);

 	// Close repository

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void DEF057145L()

 	{

 	TInt err=KErrNone;

 	const TUid testUid={0x10057145};

 	RArray<TUint32> idArray;

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(testUid));

 	//Start Transaction

 	err=repository->StartTransaction(CRepository::EReadWriteTransaction);

 	TEST2(err,KErrNone);

 	//Before creating new entries get the number of persistent settings

 	err=repository->FindL(0,0xFFFFF000,idArray);

 	TEST2(err,KErrNone);

 	TInt persistentSettingsCount=idArray.Count();

 	idArray.Close();

 	//Try creating new entries during transaction between the two extreme points

 	//ROM persistent file has low key of 1 and high key of 201

 	//We try creating new entries in between during transaction

 	for (TInt i=100;i<150;i++)

 		{

 		err=repository->Create(i,i);

 		TEST2(err,KErrNone);

 		}

 	//Now check the merge with the persistent settings is fine by checking

 	//the array count after the merge.

 	err=repository->FindL(0x000,0xFFFFF000,idArray);

 	TEST2(err,KErrNone);

 	TEST(idArray.Count()==(persistentSettingsCount+50));

 	idArray.Close();

 	TUint32 errId;

 	err=repository->CommitTransaction(errId);

 	TEST2(err,KErrNone);

 	idArray.Close();

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void DEF057778L()

 	{

 	TInt r;

 	CRepository* repository;

 	// Open repository

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057778TestRepository));

 	const TUint32 KInt14=14;

 	const TInt KInt14NewValue=0;

 	r=repository->Set(KInt14,KInt14NewValue);

 	TEST2(r, KErrNone);

 	// Reset setting that has a single policy

 	r=repository->Reset(KInt14);

 	TEST2(r, KErrNone);

 	// Attempt to access and write setting

 	r=repository->Set(KInt14,KInt14NewValue);

 	TEST2(r, KErrNone);

 	// Reset entire repository

 	r=repository->Reset();

 	TEST2(r, KErrNone);

 	// Attempt to access and write setting

 	r=repository->Set(KInt14,KInt14NewValue);

 	TEST2(r, KErrNone);

 	// Reset entire repository

 	r=repository->Reset();

 	TEST2(r, KErrNone);

 	// Close repository

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void DEF057999L()

  	{

  	TInt err=KErrNone;

  	TInt retValue=0;

  	const TUid testUid={0x10057145};

  	RArray<TUint32> idArray;

   	CRepository* repository;

  	User::LeaveIfNull(repository = CRepository::NewLC(testUid));

   	//--------------Start Transaction------------------------------------

  	err=repository->StartTransaction(CRepository::EReadWriteTransaction);

  	TEST2(err,KErrNone);

  	//--------------Create follow by delete-----------------------------

   	err=repository->Create(3400,3400);

  	TEST2(err,KErrNone);

  	err=repository->Delete(3400);

  	TEST2(err,KErrNone);

  	err=repository->Delete(3400);

  	TEST2(err,KErrNotFound);

 	//--------------Deleting existing romkey-----------------------------

   	err=repository->Delete(200);

   	TEST2(err,KErrNone);

    	err=repository->FindL(200,0xFFFFFFFF,idArray);

   	TEST2(err,KErrNotFound);

  	//--------------Commit Transaction------------------------------------

    	TUint32 errId;

    	err=repository->CommitTransaction(errId);

    	TEST2(err,KErrNone);

   	idArray.Close();

    	CleanupStack::PopAndDestroy(repository);

 	//--------------Reopen and check the deleted keys are gone-------------

    	User::LeaveIfNull(repository = CRepository::NewLC(testUid));

 	//Check for the key created and deleted during transaction

 	err=repository->FindL(3400,0xFFFFFFFF,idArray);

 	TEST2(err,KErrNotFound);

 	//Check for the rom key deleted during transaction

    	err=repository->Get(200,retValue);

 	TEST2(err,KErrNotFound);

 	//--------------Start Transaction------------------------------------

  	err=repository->StartTransaction(CRepository::EReadWriteTransaction);

  	TEST2(err,KErrNone);

  	//--------------Delete follow by create-----------------------------

   	err=repository->Delete(201);

  	TEST2(err,KErrNone);

  	err=repository->Create(201, 201);

  	TEST2(err,KErrNone);

  	//--------------Commit Transaction------------------------------------

    	err=repository->CommitTransaction(errId);

    	TEST2(err,KErrNone);

 	err=repository->Get(201,retValue);

 	TEST2(err,KErrNone);

 	TEST2(retValue, 201);

  	CleanupStack::PopAndDestroy(repository);

    	}

 LOCAL_C void DEF057522L()

 	{

 	TInt r=KErrNone;

 	CRepository* repository;

 	TUid testUidRepository={0x10057522};

 	//Opening a repository with Max number of capabilities supported should not return KErrCorrupt

 	User::LeaveIfNull(repository = CRepository::NewLC(testUidRepository));

 	//Test reading some of the settings with the max capabilities defined

 	TInt retVal=0;

 	r=repository->Get(17,retVal);

 	TEST2(r,KErrNone);

 	r=repository->Set(17,retVal);

 	TEST2(r,KErrNone);

 	r=repository->Get(18,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(18,retVal);

 	TEST2(r,KErrNone);

 	//Test that AlwaysPass and AlwaysFail behave as expected when not followed by sid

 	r=repository->Get(21,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(21,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Get(22,retVal);

 	TEST2(r,KErrNone);

 	r=repository->Set(22,retVal);

 	TEST2(r,KErrNone);

 	//Test that AlwaysPass and AlwaysFail behave as expected when followed by sid

 	r=repository->Get(19,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(19,retVal);

 	TEST2(r,KErrNone);

 	//Additional test cases

 	//Test single policies with max 3 caps for both read and write

 	r=repository->Get(28,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(28,retVal);

 	TEST2(r,KErrNone);

 	//Test single policies with max 7 caps for both read and write

 	r=repository->Get(33,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(33,retVal);

 	TEST2(r,KErrPermissionDenied);

 	//Test range policies with max 3 caps when followed by sid

 	r=repository->Get(201,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(201,retVal);

 	TEST2(r,KErrNone);

 	//Test range policies with max 7 caps not with sid

 	r=repository->Get(300,retVal);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Set(300,retVal);

 	TEST2(r,KErrPermissionDenied);

 	//Test behaviour when single policies are specified with just sid

 	r=repository->Get(400,retVal);

 	TEST2(r,KErrNone);

 	r=repository->Set(400,retVal);

 	TEST2(r,KErrPermissionDenied);		// default read cap for sid 0 is AlwaysFail

 	r=repository->Get(401,retVal);

 	TEST2(r,KErrNone);					// default write cap for sid 0 is AlwaysPass

 	r=repository->Set(401,retVal);

 	TEST2(r,KErrNone);

 	//Test that default policies are picked up when no policies are specified

 	r=repository->Get(500,retVal);

 	TEST2(r,KErrNone);

 	r=repository->Set(500,retVal);

 	TEST2(r,KErrPermissionDenied);

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void DEF057470L()

 	{

 	TInt r=KErrNone;

 	TUint32 errId=0;

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));

 	//-------------- 1. Simple Range Delete Operation-----------------------------

 	// Confirm that keys exist

 	RArray<TUint32> foundIds;

 	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);

 	TEST2(r, KErrNone);

 	TEST(foundIds.Count()==5);

 	foundIds.Reset();

 	// Delete a set of keys

 	r = repository->Delete(KRangeDeletePartialKey, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrNone);

 	// Confirm that deleted keys do not exist

 	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);

 	TEST2(r, KErrNotFound);

 	TEST(foundIds.Count()==0);

 	foundIds.Reset();

 	CleanupStack::PopAndDestroy(repository);

 	// Try to find keys again just to double check whether the changes have persisted

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));

 	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);

 	TEST2(r, KErrNotFound);

 	TEST(foundIds.Count()==0);

 	foundIds.Reset();

 	//--------------- 2. Range Delete Operation where keys don't exist--------------

 	// Confirm that keys don't exist.

 	r = repository->FindL(KDeleteKeyDoesntExist, KRangeDeleteMask, foundIds);

 	TEST2(r, KErrNotFound);

 	TEST(foundIds.Count()==0);

 	foundIds.Reset();

 	// Attempt delete and check result

 	r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrNotFound);

 	errId &= KRangeDeleteMask ;

 	TEST2(errId, KDeleteKeyDoesntExist) ;

 	//-------3. Range Delete Operation where client doesn't have write capabilities for key range.----

 	// Attempt delete and check result

 	r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrPermissionDenied);

 	errId &= KRangeDeleteMask ;

 	TEST2(errId, KDeleteForbidden) ;

 	// Close repository

 	CleanupStack::PopAndDestroy(repository);

 	//------ 4. Range Delete Operation which deletes all the keys and Resets the entire repository back its original state.

 	TInt numberOfIds;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository));

 	// Find how many keys are originally present

 	r = repository->FindL(KNullKey, KNullKey, foundIds);

 	TEST2(r, KErrNone);

 	numberOfIds = foundIds.Count();

 	TEST(foundIds.Count()!=0);

 	foundIds.Reset();

 	// Range delete all the keys in the repository

 	r = repository->Delete(KNullKey, KNullKey, errId);

 	TEST2(r, KErrNone);

 	// Check all the keys have been deleted from cache

 	r = repository->FindL(KNullKey, KNullKey, foundIds);

 	TEST2(r, KErrNotFound);

 	TEST(foundIds.Count()==0);

 	foundIds.Reset();

 	// Close and re-open the repository to check if the deleted keys have persisted.

 	CleanupStack::PopAndDestroy(repository);	

 	// Existance of caching functionality invalidates some tests and

 	// makes them fail, so kill the server to force clearing the cache

 	r = KillProcess(KCentralRepositoryServerName);

 	TEST2(r,KErrNone);

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository));

 	// Check all the deleted keys have persisted.

 	r = repository->FindL(KNullKey, KNullKey, foundIds);

 	TEST2(r, KErrNotFound);

 	TEST(foundIds.Count()==0);

 	foundIds.Reset();

 	// Reset repository back to its original state from ROM

 	r = repository->Reset();

 	TEST2(r, KErrNone);

 	// Check that number of keys is same as when we started.

 	r = repository->FindL(KNullKey, KNullKey, foundIds);

 	TEST2(r, KErrNone);

 	TEST(foundIds.Count()==numberOfIds);

 	foundIds.Reset();

 	// Close the repository

 	CleanupStack::PopAndDestroy(repository);

 	//**********************Delete Range within Transacrions**********************

 	//--------- 5. Range Delete within a transaction where key's don't exist.------------

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));

 	// Begin read write transaction.

 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

 	TEST2(r, KErrNone);

 	r = TransactionState(repository);

 	TEST2(r, EReadWriteTransaction);

 	r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrNotFound);

 	// Check that transaction hasn't failed.

 	r = TransactionState(repository);

 	TEST2(r, EReadWriteTransaction);

 	// Fail transaction.

 	repository->FailTransaction();

 	r = TransactionState(repository);

 	TEST2(r, EReadWriteTransaction | EFailedBit);

 	repository->RollbackTransaction();

 	r = TransactionState(repository);

 	TEST2(r, ENoTransaction);

 	//---------- 6. Range delete within a transaction where client doesn't have capabilities to write to key range.

 	// Begin read write transaction.

 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

 	TEST2(r, KErrNone);

 	r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrPermissionDenied);

 	errId &= KRangeDeleteMask ;

 	TEST2(errId, KDeleteForbidden) ;

 	// check that transaction has failed.

 	r = TransactionState(repository);

 	TEST2(r, EReadWriteTransaction | EFailedBit);

 	// Rollback the failed transaction.

 	repository->RollbackTransaction();

 	r = TransactionState(repository);

 	TEST2(r, ENoTransaction);

 	//---------- 7. Range delete while not in transaction fails other session's transaction with KErrLocked.

 	// Open another repository

 	CRepository* repository2;

 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidDEF057470TestRepository));

 	// Begin read write transaction

 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

 	TEST2(r, KErrNone);

 	r = TransactionState(repository);

 	TEST2(r, EReadWriteTransaction);

 	// Delete keys in the first session.

 	r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrNone);

 	// Delete keys in the second session.

 	r = repository2->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrNone);

 	// first session's transaction should have failed with KErrLocked

 	TInt state = TransactionState(repository);

 	TEST2(state, EReadWriteTransaction | EFailedBit);

 	// Commit transaction should report failure reason:

 	TUint32 keyInfo;

 	r = repository->CommitTransaction(keyInfo);

 	TEST2(r, KErrLocked);

 	TEST(keyInfo == KUnspecifiedKey);

 	r = TransactionState(repository);

 	TEST2(r, ENoTransaction);

 	// Close the repositories

 	CleanupStack::PopAndDestroy(repository2);

 	//----------- 8. Range Delete within a Transaction and Commit.-----------------------

 	//Before doing this we need to reset from the ROM first to restore the deleted keys in

 	//non transaction test earlier

 	r=repository->Reset();

 	TEST2(r,KErrNone);

 	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);

 	TEST2(r,KErrNone);

 	TEST(foundIds.Count()==5);

 	foundIds.Reset();

 	// Begin read write transaction

 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

 	TEST2(r, KErrNone);

 	r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;

 	TEST2(r, KErrNone);

 	// Commit transaction

 	r = repository->CommitTransaction(errId);

 	TEST2(r, KErrNone);

 	//The number of keys changed should be equal to the number of keys deleted

 	TEST(errId==5);

 	//Reset repository to remove any changes made during this test

 	r=repository->Reset();

 	TEST2(r, KErrNone);

 	// Close the repositories

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void INC058229L()

 	{

 	RFs fs;

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

 	CleanupClosePushL(fs);

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

 	CleanupStack::PushL(fm);

 	// Open repository to ensure server is running

 	CRepository* rep;

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	// Remove install dir

 	TInt r = fm->RmDir(KCInstallDir);

 	if(r!=KErrNone && r!=KErrNotFound && r!=KErrPathNotFound)

 		User::Leave(r);

 	// Wait so that watcher will see directory is gone

 	User::After(KGeneralDelay);

 	// Kill server so that next test will reconnect and recreate resources

 	r=KillProcess(KCentralRepositoryServerName);

 	TEST2(r,KErrNone);

 	// Open repository to ensure directories are restored

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

 	// Close repository

 	CleanupStack::PopAndDestroy(3);	// rep, fs, fm

 	}

 LOCAL_C void DEF058900L()

 	{

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF058900TestRepository));

 	TRequestStatus intStatus;

 	RThread thisThread;

 	//

 	// Basic notification to test notification for one banned key

 	//

 	TInt r = repository->NotifyRequest(KNotifyBannedKey, intStatus);

 	TEST2(r, KErrNone);

 	TEST(intStatus == KRequestPending);

 	// First change to setting should cause notification

 	r = repository->Set(KNotifyBannedKey, 100);

 	TEST2(r, KErrNone);

 	User::WaitForAnyRequest();

 	TEST(intStatus==KUnspecifiedKey);

 	//

 	// Group notification to test notification when the banned key is in a range

 	//

 	r = repository->NotifyRequest(KNullKey, KNullKey, intStatus);

 	TEST2(r, KErrNone);

 	r = repository->Set(KNotifyBannedKey, 50);

 	TEST2(r, KErrNone);

 	User::WaitForAnyRequest();

 	TEST(intStatus==KUnspecifiedKey);

 	TEST(thisThread.RequestCount()==0);

 	//

 	// Group notification to test notification when many keys including the banned key change

 	// i.e. a repository wide reset

 	//

 	// First change values for alot of the keys before a reset.

 	r = repository->Set(KNotificationKey1, 80);

 	TEST2(r, KErrNone);

 	r = repository->Set(KNotifyBannedKey, 50);

 	TEST2(r, KErrNone);

 	r = repository->Set(KNotificationKey2, 70);

 	TEST2(r, KErrNone);

 	r = repository->Set(KNotificationKey3, 60);

 	TEST2(r, KErrNone);

 	r = repository->Set(KNotificationKey4, 30);

 	TEST2(r, KErrNone);

 	r = repository->NotifyRequest(KNullKey, KNullKey, intStatus); // Request notification

 																  // for all keys in repository.

 	TEST2(r, KErrNone);

 	//Reset the whole repository to original settings

 	r = repository->Reset();

 	TEST2(r, KErrNone);

 	User::WaitForAnyRequest();

 	TEST(intStatus==KUnspecifiedKey);

 	TEST(thisThread.RequestCount()==0);

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void DEF061087L()

 	{

 	TInt r=KErrNone;

 	TUid testUid={0x10061087};

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(testUid));

 	/*--------------Scenario 1---------------------

 	100 300 cap_wr=ReadDeviceData

 	100 200 cap_wr=TCB */

 	r=repository->Create(150,100);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Create(201,201);

 	TEST2(r,KErrNone);

 	/*--------------Scenario 2---------------------

 	400 500 cap_wr=ReadDeviceData

 	400 500 cap_wr=TCB */

 	r=repository->Create(500,100);

 	TEST2(r,KErrPermissionDenied);

 	/*--------------Scenario 3---------------------

 	0x600 0x700 cap_wr=ReadDeviceData

 	# Odd entry from 600-700

 	0x601 mask=0xF01 cap_wr=TCB*/

 	r=repository->Create(0x601,601);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Create(0x657,647);

 	TEST2(r,KErrPermissionDenied);

 	//0x602 will be even so it will check agains the next matched range policies

 	//which is 0x600 0x700 cap_wr=ReadDeviceData

 	r=repository->Create(0x602,600);

 	TEST2(r,KErrNone);

 	/*--------------Scenario 4---------------------

 	# protected data

 	0x00000100 mask=0x00000100 cap_wr=NetworkControl

 	# private data

 	0x000000F0 mask=0x00000080 cap_rd=ReadDeviceData */

 	r=repository->Create(0x01000100,123);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Create(0x03450700,123);

 	TEST2(r,KErrPermissionDenied);

 	r=repository->Create(0x00450080,123);

 	TEST2(r,KErrNone);

 	r=repository->Create(0x06450081,123);

 	TEST2(r,KErrNone);

 	CleanupStack::PopAndDestroy(repository);

 	}

 LOCAL_C void DEF060843L()

     {

     CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));

     _LIT8(KString12_InitialValue, "string");

     TPtrC8 p8(KString12_InitialValue);

     TInt len8 = p8.Length();

     _LIT(KString11_InitialValue, "string");

     TPtrC p16(KString11_InitialValue);

     TInt len16 = p16.Length();

     //setting ids in a test repository

     const TUint32 KReal1 = 2;

     const TUint32 KString11 = 11;

     const TUint32 KString12 = 12;

     TInt r;

     TInt i(0);

     TBuf<15> str;

 	TInt strLen;

 	TBuf8<15> str8;

 	TInt strLen8;

     //================read real using int ========================

     r = repository->Get(KReal1, i);

 	TEST2(r, KErrArgument);

 	TEST(i==0);

 	//================read TDes16 using TDes8=====================

     r = repository->Get(KString11, str8);

 	TEST2(r, KErrNone);

 	//8-bit descriptor holding the same data as 16-bit descriptor

 	//should twice as long as 16-bit des.

 	strLen8 = str8.Length();

 	TEST2(strLen8,len16*2);

     const TUint16* p16a  = (TUint16*)str8.Ptr();

     const TUint16* p16b = p16.Ptr();

     //compares content of descriptors byte by byte

     r = Mem::Compare(p16a,strLen8/2,p16b,len16);

     TEST2(r,KErrNone);

     //=================read TDes8 using TDes16=====================

     r = repository->Get(KString12, str);

     TEST2(r, KErrNone);

     //16-bit descriptor holding the same data as 8-bit descriptor

     //should be half a length of a 8-bit desc

     strLen = str.Length();

     TEST2(strLen,len8/2);

 	const TUint8* p8a = (TUint8*)str.Ptr();

     const TUint8* p8b = p8.Ptr();

     //compares content of descriptors byte by byte

     r = Mem::Compare(p8a,strLen*2,p8b,len8);

     TEST2(r,KErrNone);

 	//================writting to TDes16 using TDes8===============

 	r = repository->Set(KString11,KString12_InitialValue);

 	TEST2(r, KErrNone);

 	CleanupStack::PopAndDestroy(repository);

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));

 	r = repository->Get(KString11, str8);

 	strLen8 = str8.Length();

 	TEST2(strLen8,len8);

 	TEST(str8==KString12_InitialValue);

 	//================writting to TDes8 using TDes16===============

 	r = repository->Set(KString12,KString11_InitialValue);

 	TEST2(r, KErrNone);

 	CleanupStack::PopAndDestroy(repository);

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));

 	r = repository->Get(KString12, str);

 	strLen = str.Length();

 	TEST2(strLen,len16);

 	TEST(str==KString11_InitialValue);

     CleanupStack::PopAndDestroy(repository);

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1433

 @SYMTestCaseDesc Central repository panics the client when trying to read 8-bit descriptor with uneven length

 @SYMTestPriority High

 @SYMTestActions  Read 8-bit descriptor with uneven length

 @SYMTestExpectedResults The test must not fail or panic .

 @SYMDEF INC069013

 */

 LOCAL_C void INC069013L()

 	{

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidINC069013TestRepository));

 	_LIT(KString16, "16BitString");

 	_LIT8(KString8Odd, "8BitOddString");

 	_LIT8(KString8Even, "8BitEvenString");

 	const TUint32 KString16ID = 1;

 	const TUint32 KString8OddID = 2;

 	const TUint32 KString8EvenID = 3;

 	TBuf<20> buf;

 	TInt r = KErrNone;

 	TInt actualLength = 0;

 	//test for string stored as 16 bit

 	r = repository->Get(KString16ID, buf);

 	TEST2(r, KErrNone);

 	r = repository->Get(KString16ID, buf, actualLength);

 	TEST2(r, KErrNone);

 	TEST2(actualLength, KString16().Length());

 	//test for string stored as 8 bit with odd length

 	r = repository->Get(KString8OddID, buf);

 	TEST2(r, KErrNone);

 	r = repository->Get(KString8OddID, buf, actualLength);

 	TEST2(r, KErrNone);

 	TEST2(actualLength, (KString8Odd().Length() + 1) / 2);

 	//test for string stored as 8 bit with even length

 	r = repository->Get(KString8EvenID, buf);

 	TEST2(r, KErrNone);

 	r = repository->Get(KString8EvenID, buf, actualLength);

 	TEST2(r, KErrNone);

 	TEST2(actualLength, (KString8Even().Length() + 1) / 2);

 	CleanupStack::PopAndDestroy(repository);

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1434

 @SYMTestCaseDesc Central repository doesn't handle corrupt .cre files correctly.

 @SYMTestPriority High

 @SYMTestActions  Open corrupt files from ROM and persists

 @SYMTestExpectedResults The test must not fail.

 @SYMDEF DEF070731

 */

 const TUid KUidCorruptEOF = { 0x00000e0f };

 const TUid KUidCorrupt    = { 0x00000bad };

 _LIT(KCRep1File,                                "c:\\private\\10202BE9\\persists\\00000100.cre");

 _LIT(KZCorruptEOFFile,                          "z:\\private\\10202BE9\\00000e0f.cre");

 _LIT(KZCorruptFile,                             "z:\\private\\10202BE9\\00000bad.cre");

 LOCAL_C void DEF070731L()

 	{

 	RFs fs;

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

 	CleanupClosePushL(fs);

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

 	CleanupStack::PushL(fm);

 	CRepository* rep;

 	// Open ROM cre file with EOF corruption

 	TheTest.Printf(_L("\nOpen ROM cre file with EOF corruption\n"));

 	TRAPD(errH, rep=CRepository::NewLC(KUidCorruptEOF));

 	TEST2(errH, KErrCorrupt);

 	// Open corrupt ROM file

 	TheTest.Printf(_L("\nOpen corrupt ROM file\n"));

 	TRAPD(errS,rep=CRepository::NewLC(KUidCorrupt));

 	TEST2(errS, KErrCorrupt);

 	// Edit repos with new setting

 	TheTest.Printf(_L("\nEdit repos with new setting\n"));

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));

 	TInt r = rep->Create(KNewInt, KIntValue);

 	TEST2(r, KErrNone);

 	CleanupStack::PopAndDestroy(rep);

 	// Reopen repos to read from persists file

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));

 	TInt newInt;

 	r=rep->Get(KNewInt, newInt);

 	TEST2(r, KErrNone);

 	CleanupStack::PopAndDestroy(rep);

 	// Existance of caching functionality invalidates some tests and

 	// makes them fail, so kill the server to force clearing the cache

 	r=KillProcess(KCentralRepositoryServerName);

 	TEST2(r,KErrNone);

 	// Copy corrupt EOF file into persists

 	TheTest.Printf(_L("\nCopy corrupt EOF file into persists dir\n"));

 	User::LeaveIfError(fm->Copy(KZCorruptEOFFile, KCRep1File));

 	// Reset read-only bit

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

 	User::After(KGeneralDelay);

 	// Open repos, should find corrupt file and use ROM file

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));

 	// If we can't find KNewInt, this proves that we are using ROM file

 	r=rep->Get(KNewInt, newInt);

 	TEST2(r, KErrNotFound);

 	// Test that persists file is deleted

 	TheTest.Printf(_L("\nCheck corrupt EOF file deleted from persists dir\n"));

 	TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse);

 	// Close repository

 	CleanupStack::PopAndDestroy(rep);

 	// Existance of caching functionality invalidates some tests and

 	// makes them fail, so kill the server to force clearing the cache

 	r=KillProcess(KCentralRepositoryServerName);

 	TEST2(r,KErrNone);

 	// Copy corrupt file into persists

 	TheTest.Printf(_L("\nCopy corrupt file into persists dir\n"));

 	User::LeaveIfError(fm->Copy(KZCorruptFile, KCRep1File));

 	// Reset read-only bit

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

 	User::After(KGeneralDelay);

 	// Open repos, should find corrupt file and use ROM file

 	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));

 	// Test that file is deleted

 	TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n"));

 	TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse);

 	// Close repository

 	CleanupStack::PopAndDestroy(3);// rep, fs,fm

 	}

 // Helper function for DEF084700L

 LOCAL_C void ConnectAndCommitSuicideL(void)

 	{

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));

 	RThread currentThread;

 	currentThread.Kill(KErrDied);

 	// Should never get executed

 	CleanupStack::PopAndDestroy(repository);

 	}

 // Helper function for DEF084700L

 LOCAL_C TInt SuicidalThread(TAny*)

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if(!cleanup)

 		return KErrNoMemory;

 	TRAP_IGNORE(ConnectAndCommitSuicideL());

 	// Should never get executed

 	delete cleanup;

 	return KErrNone;

 	}

 // Helper function for DEF084700L

 LOCAL_C void ConnectAndDisconnectL(void)

 	{

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));

 	CleanupStack::PopAndDestroy(repository);

 	}

 // Helper function for DEF084700L

 LOCAL_C TInt WellBehavedThread(TAny*)

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if(!cleanup)

 		return KErrNoMemory;

 	TRAP_IGNORE(ConnectAndDisconnectL());

 	delete cleanup;

 	return KErrNone;

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1683

 @SYMTestCaseDesc UIF automated tests crash H4 board

 @SYMTestPriority High

 @SYMTestActions  Open a repository, create a thread, open same repository from that thread, kill the thread

 				 before closing repository, update a setting from main body (trigger notifications). Do the same

 				 thing for a thread which terminates normally for making sure the previous behaviour is maintained

 @SYMTestExpectedResults The test must not panic or fail.

 @SYMDEF DEF084700

 */

 LOCAL_C void DEF084700L()

 	{

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));

 	RThread testThread;

 	_LIT(KThreadName1, "SuicidalTestThread");

 	testThread.Create(KThreadName1, SuicidalThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);

 	TRequestStatus requestStatus;

 	// Request notification when the thread kills itself

 	testThread.Logon(requestStatus);

 	// Let the thread execute

 	testThread.Resume();

 	// Wait for suicide

 	User::WaitForRequest(requestStatus);

 	// Make sure it's dead

 	TEST2(requestStatus.Int(), KErrDied);

 	const TUint32 KInt1 = 0x1;

 	TInt i, r = KErrNone;

 	r = repository->Get(KInt1, i);

 	TEST2(r, KErrNone);

 	r = repository->Set(KInt1, i+1);

 	// Fails here with KErrServerTerminated before fix because server crashes

 	TEST2(r, KErrNone);

 	// Create another thread which accesses the repository but terminates normally

 	_LIT(KThreadName2, "WellBehavedTestThread");

 	testThread.Create(KThreadName2, WellBehavedThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);

 	// Request notification when the thread terminates normally

 	testThread.Logon(requestStatus);

 	// Let the thread execute

 	testThread.Resume();

 	// Wait for old age

 	User::WaitForRequest(requestStatus);

 	// Make sure the cause of death is natural

 	TEST2(requestStatus.Int(), KErrNone);

 	r = repository->Get(KInt1, i);

 	TEST2(r, KErrNone);

 	r = repository->Set(KInt1, i+1);

 	TEST2(r, KErrNone);

 	//Reset repository to remove any changes made during this test

 	r = repository->Reset();

 	TEST2(r, KErrNone);

 	CleanupStack::PopAndDestroy(repository);

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1862

 @SYMTestCaseDesc [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM

 @SYMTestPriority High

 @SYMTestActions  Open a repository, start a transaction, then simulate a OOM failure in a TRAPPED

 				 FindL, this will result in client side error and this error should be the returned

 				 error of CommitTransaction.

 @SYMTestExpectedResults The test must not panic or fail.

 @SYMDEF DEF089945

 */

 LOCAL_C void DEF089945L()

 	{

  	TInt err=KErrNone;

  	const TUid testUid={0x10057145};

  	RArray<TUint32> idArray;

 	CRepository* repository;

  	User::LeaveIfNull(repository = CRepository::NewLC(testUid));

  	//-----------SIMULATE CLIENT SIDE TRANSACTION ERROR------------------------------

  	err=repository->StartTransaction(CRepository::EReadWriteTransaction);

  	TEST2(err,KErrNone);

  	//set the next allocation to fail in the FindL method

 	__UHEAP_FAILNEXT(1);

    	TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray));

  	__UHEAP_TOTAL_RESET;

  	//uheap failure only happens in debug build

 #ifdef _DEBUG

   	TEST2(err,KErrNoMemory);

 #else

 	TEST2(err,KErrNone);

 #endif

    	TUint32 errId;

    	//ensure that the returned code from Commit is same as the last failure error in client

    	err=repository->CommitTransaction(errId);

 #ifdef _DEBUG

    	TEST2(err,KErrNoMemory);

    	TEST2(errId,KUnspecifiedKey);

 #else

    	TEST2(err,KErrNone);

 #endif

    	idArray.Reset();

    	//----------SIMULATE CLIENT SIDE TRANSACTION ERROR FOLLOWED BY ADDITIONAL OPERATION-----

  	err=repository->StartTransaction(CRepository::EReadWriteTransaction);

  	TEST2(err,KErrNone);

  	//set the next allocation to fail in the FindL method

 	__UHEAP_FAILNEXT(1);

    	TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray));

  	__UHEAP_TOTAL_RESET;

 #ifdef _DEBUG

   	TEST2(err,KErrNoMemory);

 #else

 	TEST2(err,KErrNone);

 #endif

   	//now try to execute another operation following the failure

   	TReal realValue;

  	err=repository->Set(1,realValue);

 #ifdef _DEBUG

  	TEST2(err,KErrAbort);

 #else

 	TEST2(err,KErrArgument);

 #endif

     err=repository->CommitTransaction(errId);

     //confirms that the error returned is the last failure in client side

 #ifdef _DEBUG

    	TEST2(err,KErrNoMemory);

    	TEST2(errId,KUnspecifiedKey);

 #else

 	TEST2(err,KErrArgument);

 #endif

 	idArray.Reset();

 	//---------SIMULATE SERVER SIDE ERROR FOLLOWED BY CLIENT SIDE ERROR-------------------

  	err=repository->StartTransaction(CRepository::EReadWriteTransaction);

  	TEST2(err,KErrNone);

  	//server error

  	err=repository->Set(1,realValue);

  	TEST2(err,KErrArgument);

  	//client error

  	__UHEAP_FAILNEXT(1);

  	TInt ret=KErrNone;

    	TRAP(err,ret=repository->FindL(1,0xFFFFFFFF,idArray));

  	__UHEAP_TOTAL_RESET;

   	TEST2(ret,KErrAbort);

     err=repository->CommitTransaction(errId);

     //confirms that the error returned is the last failure in server side

    	TEST2(err,KErrArgument);

    	TEST2(errId,1);

 	idArray.Reset();

    	//clean up stuff

    	idArray.Close();

    	CleanupStack::PopAndDestroy(repository);

 	}

 /**

 @SYMTestCaseID 	 SYSLIB-CENTRALREPOSITORY-CT-3242

 @SYMTestCaseDesc Memory card: Backup to memory card causes phone freeze.

 @SYMTestPriority High

 @SYMTestActions  Open a repository with a corrupt ini file and check that

 				 the call to CRepository::NewLC leaves with KErrCorrupt and does not panic.

 @SYMTestExpectedResults The call to CRepository::NewLC should return with KErrCorrupt and

 				the test must not panic or fail.

 @SYMDEF PDEF098500

 */

 LOCAL_C void PDEF098500()

 	{

 	CRepository* repository = NULL;

 	TRAPD(err,repository = CRepository::NewLC(KUidPDEF098500LRepository));

 	//We expect the above call to leave with KErrCorrupt so repository should be NULL

 	TEST(repository == NULL);

 	TEST2(err, KErrCorrupt);

 	//No PopAndDestroy required as above call is expected to leave

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1884

 @SYMTestCaseDesc DEF093855: CenRep cancels transactions if they exceed 5 seconds...

 @SYMTestPriority High

 @SYMTestActions  Open a repository, start a transaction, then wait more than default cache timeout

 				 to let the normal eviction clean out the cache, call a function to reload the repository,

 				 check that the transaction is still valid, rollback the transaction to check the

 				 repository unload/reload during an open transaction doesn't cause a panic when transaction is rolled back.

 @SYMTestExpectedResults The test must not panic or fail.

 @SYMDEF DEF093855

 */

 LOCAL_C void DEF093855L()

 	{

  	TInt err=KErrNone;

 	// make sure no items are in the cache

  	KillProcess(KCentralRepositoryServerName);

 	// connect

 	CRepository* repository;

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1));

 	// Begin concurrent read write transaction

 	err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

 	TEST2(err, KErrNone);

 	TInt val;

 	const TInt KIntTestValue = 10;

 	// get test value, make sure it is KIntTestValue

     err = repository->Get(0x02010100,val);

 	TEST2(err, KErrNone);

 	TEST2(val, KIntTestValue);

     // change the value in transaction

 	TInt r = repository->Set(0x02010100, KIntValue);

 	TEST2(r, KErrNone);

 	// wait for the repository to be removed from memory

 	CleanupRepositoryCache();

 	// check that the transaction is not aborted, still in memory and keeps the value set during the transaction

     err = repository->Get(0x02010100,val);

 	TEST2(err, KErrNone);

 	TEST2(val, KIntValue);

 	// rollback to check if RollbackTransaction works, and to reset the value to KIntTestValue

     repository->RollbackTransaction();

 	// Begin another transaction

 	err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

 	TEST2(err, KErrNone);

 	// get test value, make sure it is still KIntTestValue (successfully rolled back)

     err = repository->Get(0x02010100,val);

 	TEST2(err, KErrNone);

 	TEST2(val, KIntTestValue);

     // change the value in transaction

 	r = repository->Set(0x02010100, KIntValue);

 	TEST2(r, KErrNone);

 	// wait for the repository to be removed from memory

 	CleanupRepositoryCache();

 	// check that the transaction is not aborted, still in memory and keeps the value set during the transaction

     err = repository->Get(0x02010100,val);

 	TEST2(err, KErrNone);

 	TEST2(val, KIntValue);

 	// commit to check if CommitTransaction works

 	TUint32 keyInfo;

     repository->CommitTransaction(keyInfo);

 	TEST2(err, KErrNone);

 	TEST2(keyInfo, 1);

 	// check that the value is set during the transaction (in shared rep settings)

     err = repository->Get(0x02010100,val);

 	TEST2(err, KErrNone);

 	TEST2(val, KIntValue);

 	// close repository

 	CleanupStack::PopAndDestroy(repository);

 	// make sure the repository is unloaded from cache

 	KillProcess(KCentralRepositoryServerName);

 	// reopen the repository

 	User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1));

 	// get test value, to check if it had been successfully persisted

     err = repository->Get(0x02010100,val);

 	TEST2(err, KErrNone);

 	TEST2(val, KIntValue);

     // reset the setting back to the original value

 	r = repository->Set(0x02010100, KIntTestValue);

 	TEST2(r, KErrNone);

 	//Reset repository to remove any changes made during this test

 	r = repository->Reset();

 	TEST2(r, KErrNone);

 	// close repository

 	CleanupStack::PopAndDestroy(repository);

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3477

 @SYMTestCaseDesc PDEF106507: Central repository doesn't handle corruption of the installdir.bin file properly

 @SYMTestPriority High

 @SYMTestActions  Replaces installdir.bin file with a corrupted version, then shuts down the server and restarts it (with CRepository::NewL)  This causes the file to be re-read, and as it is corrupt it should get deleted and re-created.  The test checks that the server does not panic.

 @SYMTestExpectedResults The Server should not panic when trying to read the corrupt file, and should return KErrNone

 @SYMDEF PDEF106507

 */

 LOCAL_C void PDEF106507L()

 	{

 	_LIT(KInstallDirFile, "C:\\private\\10202be9\\persists\\installdir.bin");

 	_LIT(KInstallDirFileBad1, "Z:\\private\\10202be9\\installdir_corrupt1.bin");

 	_LIT(KInstallDirFileBad2, "Z:\\private\\10202be9\\installdir_corrupt2.bin");

 	RFs fs;

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

 	CleanupClosePushL(fs);

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

 	CleanupStack::PushL(fm);

 	// copy first corrupt file into centrep private directory (this file has data area corrupted)

 	TheTest.Printf(_L("\nCopy first corrupt installdir.bin file into persists dir\n"));

 	User::LeaveIfError(fm->Copy(KInstallDirFileBad1, KInstallDirFile));

 	// Reset read-only bit

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

 	// Kill server so that next test will restart and internalize file

 	TInt error = KillProcess(KCentralRepositoryServerName);

 	TEST2(error, KErrNone);

 	// Start server and check it does not panic

 	CRepository* repository = NULL;

 	TRAP(error, repository = CRepository::NewL(KUidRep1));

 	TEST2(error, KErrNone);

 	delete repository;

 	// test the second corrupted file (this file has header information corrupted)

 	TheTest.Printf(_L("\nCopy second corrupt installdir.bin file into persists dir\n"));

 	User::LeaveIfError(fm->Copy(KInstallDirFileBad2, KInstallDirFile));

 	// Reset read-only bit

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

 	// Kill server so that next test will reconnect and recreate resources

 	error = KillProcess(KCentralRepositoryServerName);

 	TEST2(error, KErrNone);

 	// Start server and check it does not panic

 	TRAP(error, repository = CRepository::NewL(KUidRep1));

 	TEST2(error, KErrNone);

 	delete repository;

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

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3517

 @SYMTestCaseDesc R3.2 stability problems: CentralRepositorySrv crash

 @SYMTestPriority High

 @SYMTestActions  Attempt to open a .cre file which has a corrupt UID. Ensure that

 				 the error is dealt with properly.

 @SYMTestExpectedResults The test must not fail.

 @SYMDEF INC108803

 */

 _LIT(KZCorruptFile1, "z:\\private\\10202BE9\\101f8764.cre");

 _LIT(KCCorruptFile1, "c:\\private\\10202BE9\\persists\\101f8764.cre");

 _LIT(KCCorruptFile2, "c:\\private\\10202BE9\\persists\\101f8765.cre");

 const TUid KUidCorruptUid1 	= { 0x101f8764 };

 const TUid KUidCorruptUid2 	= { 0x101f8765 };

 LOCAL_C void INC108803L()

 	{

 	TInt err = KErrNone;

 	RFs fs;

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

 	CleanupClosePushL(fs);

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

 	CleanupStack::PushL(fm);

 	CRepository* rep = NULL;

 	// Attempt to open a repository from a .cre file which has a corrupt UID

 	// The .cre file exists on the Z drive only. This test ensures that

 	// the corruption of the .cre file is detected and that the correct error

 	// code, KErrCorrupt, is returned to the client.

 	// This test will

 	// 1. Look on c drive, be unable to find the file

 	// 2. Look in z drive, find the file with the specified UID,

 	// determine that the file is corrupt and return KErrCorupt.

 	TheTest.Printf(_L("\nAttempt to open ROM cre file with UID corruption\n"));

 	TRAP(err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep););

 	TEST2(err, KErrCorrupt);

 	// Copy the corrupt .cre file into the persists directory for the next test

  	User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile1 ));

  	// Reset read-only bit

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

 	User::After(KGeneralDelay);

 	// Attempt to open a repository which has a .cre file with a corrupt UID.

 	// The .cre file exists on the C and Z drives. (This test ensures that the

 	// corrupt .cre file on the C Drive is deleted).

 	// This test will

 	// 1.Look in the C Drive, find the file with the specified UID

 	// determine that the file is corrupt and delete the file

 	// 2. Look in the Z Drive, find the file with the specified UID,

 	// determine that the file is corrupt and return KErrCorupt.

  	TheTest.Printf(_L("\nAttempt to open persists cre file with UID corruption\n"));

 	TRAP (err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep););

 	TEST2(err, KErrCorrupt);

 	TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n"));

 	TEST2 (BaflUtils::FileExists (fs, KCCorruptFile1), EFalse);

  	// Copy a second corrupt .cre file into the persists directory

  	// (Note that an associated ini file

  	// z:\\private\\10202BE9\\101f8765.txt exists and is not corrupt)

  	User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile2));

  	TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), ETrue);

  	// Reset read-only bit

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

 	User::After(KGeneralDelay);

  	// Attempt to open a corrupt repository. This will fail and the .cre file on the

  	// C Drive will be deleted. Fall-back to the Z drive occurs. The associated ini file

  	// is found.

  	// Attempt to use the resulting repository by using a Reset operation. No panics should

  	// occur.

  	TheTest.Printf(_L("\nAttempt to open corrupt persists cre file, re-create from txt file\n"));

 	TRAP (err, rep = CRepository::NewLC(KUidCorruptUid2); CleanupStack::Pop(rep););

 	TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), EFalse);

  	TEST2(err, KErrNone);

   	ASSERT(rep != NULL);

 	rep->Reset();

  	// Clean up any files created on the C Drive

  	CleanupFileFromCDriveL(KUidCorruptUid1);

  	CleanupFileFromCDriveL(KUidCorruptUid2);

 	delete rep;

 	CleanupStack::PopAndDestroy(2, &fs); // fm, fs

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3545

 @SYMTestCaseDesc The corrupted Cache ini file should cause CentralRepositorySrv panic in debug mode

 				 but keep running with the default values in release mode.

 @SYMTestPriority High

 @SYMTestActions  Kill CentralRepositorySrv and restart it with the corrupted Cache ini file.

 				 Ensure that:

 				 . in debug mode, the client will fail to create a CRepository pointer because

 				 the server has panicked.

 				 . in release mode, the client will be able to create a CRepository pointer because

 				 the server keeps running with the default values.

 @SYMTestExpectedResults The test must not fail.

 @SYMDEF DEF109390

 */

 _LIT(KZCorruptIniFile, "z:\\private\\10202BE9\\cache_corrupt.ini");

 _LIT(KCCorruptIniFile, "c:\\private\\10202BE9\\centrep.ini");

 _LIT(KZRepFile, 	 "z:\\private\\10202BE9\\00000001.txt");

 _LIT(KCRepFile, 	 "c:\\private\\10202BE9\\persists\\00000001.txt");

 const TUid KTestRepUid 	= { 0x00000001};

 LOCAL_C void DEF109390L()

 	{

  	TInt err(KErrNone);

 	RFs fs;

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

 	CleanupClosePushL(fs);

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

 	CleanupStack::PushL(fm);

 	// Copy the corrupted Cache ini file to install directory.

 	TheTest.Printf(_L("\nCopy the corrupted Cache ini file to install directory.\n"));

  	User::LeaveIfError(fm->Copy(KZCorruptIniFile, KCCorruptIniFile));

 	// Reset read-only bit

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

 	// Copy a good repository file to persist directory to verify whether the cenrep server is

 	// able to start up.

 	TheTest.Printf(_L("\nCopy the repository file to persist directory.\n"));

  	User::LeaveIfError(fm->Copy(KZRepFile, KCRepFile));

 	// Reset read-only bit

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

 	// Kill server so that next test will restart it.

 	err=KillProcess(KCentralRepositoryServerName);

 	TEST2(err,KErrNone);

 	User::After(KGeneralDelay);

 	CRepository* rep = NULL;

 	TRAP(err, rep = CRepository::NewLC(KTestRepUid); CleanupStack::PopAndDestroy(rep););

 	#ifdef _DEBUG

 		// in debug mode, CRepository::NewLC should leave with leave code KErrGeneral.

 		TheTest.Printf(_L("Debug mode err = %d.\n"),err);

 		TEST2(err, KErrGeneral);

 	#else

 		// in release mode, CRepository::NewLC should return a valid CRepository pointer successfully.

 		TheTest.Printf(_L("Release mode err = %d.\n"),err);

 		TEST2(err, KErrNone);

 	#endif

  	// Clean up the repository files created on the C Drive

  	CleanupFileFromCDriveL(KTestRepUid);

  	// Clean up the corrupted ini file on the C Drive

  	User::LeaveIfError(fm->Delete(KCCorruptIniFile));

  	// pop the cleanup stack for fm & fs

 	CleanupStack::PopAndDestroy(2, &fs);

 	// Kill the Cenrep server so that it can it can be restarted by the client

 	// without the corrupted Cache ini file.

 	err=KillProcess(KCentralRepositoryServerName);

 	TEST2(err,KErrNone);

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4024

 @SYMTestCaseDesc

 Test that the UID compare function works properly with large UID's.  Since

 CObservable::CompareTUidValues() is a private function and cannot be accessed

 directly, CObservable::AddObserverL()and CObservable::FindConnectedRepository()

 are used to infer the correct operation.

 @SYMTestPriority High

 @SYMTestActions

 -Compare a large positive UID and a very negative UID

 -Compare a large positive UID and a large positive UID

 -Compare a very negative UID and a very negative UID

 -Compare two very large but equivalent UID's.

 @SYMTestExpectedResults All UID's added to a sorted list can be found later, regardless of size and sign.

 @SYMDEF DEF116043

 @SYMUnit CObservable::CompareTUidValues()

 */

 LOCAL_C void DEF116043L()

 	{

 	const TUid KLargePositive1 = {0x7FFFFFFF};

 	const TUid KLargePositive2 = {0x7FFFFFFE};

 	const TUid KLargeNegative = {0x8FFFFFFF};

 	CObservable* ob = CObservable::NewLC();

 	// Add a variety of UID's to work with, including large positives, a very negative,

 	// and duplicates

 	ob->AddObserverL(KLargePositive1, NULL);

 	ob->AddObserverL(KLargeNegative, NULL);

 	ob->AddObserverL(KLargePositive2, NULL);

 	ob->AddObserverL(KLargePositive1, NULL);

 	// Look for a large positive and expect a non-negative index

 	TEST(ob->FindConnectedRepository(KLargePositive1) >= 0);

 	// Look for another large positive and expect a non-negative index

 	TEST(ob->FindConnectedRepository(KLargePositive2) >= 0);

 	// Look for a very negative and expect a non-negative index.

 	// This will fail under 'UID1 - UID2' implementations.

 	TEST(ob->FindConnectedRepository(KLargeNegative) >= 0);

 	CleanupStack::PopAndDestroy(ob);

 	}

 /**

 @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4081

 @SYMTestCaseDesc

 Test that the Observer compare function works properly with large UID's

 @SYMTestPriority High

 @SYMTestActions The test will insert a set of pointers with very big and small unsigned address

 and ensure that the correct order is inserted in the list

 @SYMTestExpectedResults the pointer is inserted in the correct order

 @SYMDEF DEF132807

 */	

 LOCAL_C void DEF132807L()

 	{

 	CObservable* ob = CObservable::NewLC();

 	const TUid KReposUid={0x87654321};

 	ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFF);

 	ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFE);

 	ob->AddObserverL(KReposUid,(CServerRepository*)0x8FFFFFFF);

 	ob->AddObserverL(KReposUid,(CServerRepository*)0x00000001);		

 	TEST(ob->iObservers.Count()==4);

 	CObservable::TRepositoryObserverInfo pos1=ob->iObservers[0];

 	TEST(pos1.iRepositoryPointer==(CServerRepository*)0x00000001);

 	CObservable::TRepositoryObserverInfo pos2=ob->iObservers[1];

 	TEST(pos2.iRepositoryPointer==(CServerRepository*)0x7FFFFFFE);	

 	CObservable::TRepositoryObserverInfo pos3=ob->iObservers[2];

 	TEST(pos3.iRepositoryPointer==(CServerRepository*)0x7FFFFFFF);	

 	CObservable::TRepositoryObserverInfo pos4=ob->iObservers[3];

 	TEST(pos4.iRepositoryPointer==(CServerRepository*)0x8FFFFFFF);	

 	CleanupStack::PopAndDestroy(ob);

 	}

 //a test class notify handler

 //the notify handler will check the value for different test case

 static TInt currentTestCaseID=0;

 class CTestNotifyHandler : public CBase, public MCenRepNotifyHandlerCallback

 	{

 public:

 	static CTestNotifyHandler* NewL()

 		{

 		return new (ELeave)CTestNotifyHandler;

 		}

 	~CTestNotifyHandler(){}

 	// Notification handlers

 	void HandleNotifyInt(TUint32 aId, TInt aNewValue)

 		{

 		if (currentTestCaseID==0)

 			return;

 		else if(currentTestCaseID==1)

 			TEST(aId==1 && aNewValue==208);

 		}

 	void HandleNotifyReal(TUint32 aId, TReal /*aNewValue*/)

 		{

 		if (currentTestCaseID==2)

 			{

 			TEST(aId==1);

 			CActiveScheduler::Stop();

 			}

 		}

 	void HandleNotifyString(TUint32 /*aId*/, const TDesC16& /*aNewValue*/)

 		{

 		}

 	void HandleNotifyBinary(TUint32 /*aId*/, const TDesC8& /*aNewValue*/)

 		{

 		}

 	void HandleNotifyGeneric(TUint32 /*aId*/)

 		{

 		}

 	void HandleNotifyError(TUint32 aId, TInt error, CCenRepNotifyHandler* /*aHandler*/)

 		{

 		if (currentTestCaseID==0)

 			return;

 		else if (currentTestCaseID==1)

 			TEST((TInt)aId==-11 && error==KErrArgument);

 		else if (currentTestCaseID==2)

 			TEST(aId==1 && error==KErrArgument);

 		else if (currentTestCaseID==3)

 			TEST(aId== 10000 && error==KErrPermissionDenied);

 		CActiveScheduler::Stop();

 		}

 private:

 	CTestNotifyHandler(){}

 	};

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4035

 @SYMTestCaseDesc Notify Handling in centralrepository under different error conditions

 @SYMTestPriority High

 @SYMTestActions Testing the CRepository::NotifyRequest under different error condition

 				Testing the CCenrepNotifierHandler under different error condition

 @SYMTestExpectedResults Test should pass and exhibit the expected behaviour

 @SYMDEF DEF117987

 */

 LOCAL_C void DEF117987L()

 	{

 	__UHEAP_MARK;

 	CActiveScheduler* s=new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(s);

 	CActiveScheduler::Install(s);

 	const TUid KCDUid = {0xF0000001};

 	CRepository* rep=CRepository::NewL(KCDUid);

 	TRequestStatus ts,ts1;

 	//-----------------single notification test-----------------------

 	//Negative testing for Double notification on same setting

 	TInt ret=rep->NotifyRequest(1,ts);

 	TEST(ret==KErrNone);

 	ret=rep->NotifyRequest(1,ts1);

 	TEST(ret==KErrNone);

 	ret=rep->Set(1,123);

 	User::WaitForRequest(ts);

 	User::WaitForRequest(ts1);

 	TEST(ts==1);

 	TEST(ts1==KErrAlreadyExists);

 	//Negative testing for non-existent key---------------------------

 	ts=KRequestPending;

 	ret=rep->NotifyRequest(10303,ts);

 	TEST(ret==KErrNotFound);

 	TEST(ts==KRequestPending);

 	//Negative testing for key we dont have permission----------------

 	ret=rep->NotifyRequest(10000,ts);

 	TEST(ret==KErrPermissionDenied);

 	TEST(ts==KRequestPending);

 	//---------------------group notification test--------------------------

 	ts=KRequestPending;

 	ts1=KRequestPending;

 	//Negative testing for double notification on the same setting range

 	//set partial key 0 and mask 0xFFFFFF00 to filter only 0-255

 	ret=rep->NotifyRequest(0,0xFFFFFF00,ts);

 	TEST(ret==KErrNone);

 	//second notification request on the same partial key and mask should not fail

 	ret=rep->NotifyRequest(0,0xFFFFFF00,ts1);

 	TEST(ret==KErrNone);

 	ret=rep->Set(1,246);

 	User::WaitForRequest(ts);

 	User::WaitForRequest(ts1);

 	TEST(ts==1);

 	TEST(ts1==1);

 	//Negative testing for unknown range------------------------------

 	//this will not return error code for range notification as it is intended for

 	//to cover keys created later in the future.

 	ts=KRequestPending;

 	ret=rep->NotifyRequest(100000,0xFFFFFFFF,ts);

 	TEST(ret==KErrNone);

 	ret=rep->NotifyCancel(100000,0xFFFFFFFF);

 	User::WaitForAnyRequest();

 	TEST(ret==KErrNone);

 	TEST(ts==KUnspecifiedKey);

 	//Negative testing for key we dont have permission------------------------------

 	ts=KRequestPending;

 	ret=rep->NotifyRequest(10000,0xFFFFFFFF,ts);

 	TEST(ret==KErrNone);

 	User::WaitForRequest(ts);

 	TEST(ts==KErrPermissionDenied);

 	delete rep;

 	//----------------single notification using cenrepnotifhandler-----------

 	currentTestCaseID=1;

 	rep=CRepository::NewL(KCDUid);

 	//create the handler callback

 	CTestNotifyHandler* callback=CTestNotifyHandler::NewL();

 	//now setup the handler

 	CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EIntKey,1);

 	CCenRepNotifyHandler* handler2=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EIntKey,1);

 	handler->StartListeningL();

 	handler2->StartListeningL();

 	ret=rep->Set(1,208);

 	TEST(ret==KErrNone);

 	CActiveScheduler::Start();

 	User::After(1000000);

 	CleanupStack::PopAndDestroy(2);

 	delete callback;

 	delete rep;

 	CleanupStack::PopAndDestroy();

 	__UHEAP_MARKEND;

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4034

 @SYMTestCaseDesc Centrep notifier handler does not check return codes

 @SYMTestPriority High

 @SYMTestActions	 Test that error code encountered during handling of notification

 				 results in the HandleNotifyError being invoked

 @SYMTestExpectedResults Test should pass and exhibit the expected behaviour

 @SYMDEF DEF117848

 */

 LOCAL_C void DEF117848L()

 	{

 	__UHEAP_MARK;

 	CActiveScheduler* s=new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(s);

 	CActiveScheduler::Install(s);

 	const TUid KCDUid = {0xF0000001};

 	//create the handler callback

 	CTestNotifyHandler* callback=CTestNotifyHandler::NewL();

 	//----------------notify handle error test case------------------------------

 	currentTestCaseID=2;

 	CRepository* rep=CRepository::NewL(KCDUid);

 	//purposely set the notify handler for a key but specifying the wrong type

 	//this will only be detected during the notification

 	CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::ERealKey,1);

 	handler->StartListeningL();

 	TInt ret=rep->Set(1,199);

 	TEST(ret==KErrNone);

 	CActiveScheduler::Start();	

 	//handlenotify error will be called and validate the error code and then stop the scheduler

 	handler->StopListening();

 	CleanupStack::PopAndDestroy();

 	//test for other type of settings

 	handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EStringKey,1);

 	handler->StartListeningL();

 	ret=rep->Set(1,209);

 	TEST(ret==KErrNone);

 	CActiveScheduler::Start();

 	handler->StopListening();

 	CleanupStack::PopAndDestroy();

 	//test for other type of settings

 	handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EBinaryKey,1);

 	handler->StartListeningL();

 	ret=rep->Set(1,309);

 	TEST(ret==KErrNone);

 	CActiveScheduler::Start();

 	handler->StopListening();

 	CleanupStack::PopAndDestroy();	

 	delete callback;

 	delete rep;

 	CleanupStack::PopAndDestroy();

 	__UHEAP_MARKEND;			

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036

 @SYMTestCaseDesc  Central Repository Notification Handler flooded with notifications

 @SYMTestPriority High

 @SYMTestActions	Testing the CCenrepNotifierHandler when the client does not have

 				enough permission when setting up the whole repository notifier.

 @SYMTestExpectedResults Test should pass and exhibit the expected behaviour

 @SYMDEF DEF118107

 */

 LOCAL_C void DEF118107L()

 	{

 	__UHEAP_MARK;

 	currentTestCaseID = 3;

 	CActiveScheduler* s=new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(s);

 	CActiveScheduler::Install(s);

 	const TUid KCDUid = {0xF0000001};	

 	CRepository* rep=CRepository::NewL(KCDUid);

 	//create the handler callback

 	CTestNotifyHandler* callback=CTestNotifyHandler::NewL();	

 	//create a handler to listen to the whole repository

 	CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep);	

 	//Start listening as a fail should occur as one of repository entries does not

 	//have the correct capabilities

 	handler->StartListeningL();

 	//This causes the handlenotifyerror to be called which checks that 

 	//KErrPermissionDenied has occured and stops the scheduler.

 	CActiveScheduler::Start();

 	handler->StopListening();

 	//Cleanup

 	CleanupStack::PopAndDestroy();

 	delete callback;

 	delete rep;

 	CleanupStack::PopAndDestroy();

 	__UHEAP_MARKEND;		

 	}

 // This function creates TServerSetting objects with the data in the ServerSettingStruct array and then

 // appends them to the specified RSettingsArray object.

 LOCAL_C void SetupSettingsArrayL(RSettingsArray& aSettingsArray,const ServerSettingStruct aSettingStructArr[], TInt aSettingStructArrSize)

 	{

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

 		{

 		TServerSetting newSetting(aSettingStructArr[i].key);

 		TInt error;

 		newSetting.SetIntValue(aSettingStructArr[i].value);

 		newSetting.SetType(aSettingStructArr[i].meta);

 		newSetting.SetMeta(aSettingStructArr[i].meta);

 		error = aSettingsArray.OrderedInsert(newSetting);

 		if(KErrNone != error)

 			{

 			newSetting.Reset();	// for safety in case of newSetting is not TInt type.

 			User::Leave(error);

 			}

 		}

 	}

 // This function compares 2 RSettingsArray arrays. Panics if they are not identical

 LOCAL_C void CompareSettingsArrays(const RSettingsArray& aArr1, const RSettingsArray& aArr2)	

 	{

 	TEST2(aArr1.Count(), aArr2.Count());

 	for(TInt i = 0; i < aArr2.Count(); i++)

 		{

 		if(aArr1[i].IsDeleted())

 			{

 			TEST(aArr2[i].IsDeleted());	

 			}

 		else

 			{

 			TEST(aArr1[i] == aArr2[i]);				

 			}

 		}

 	}

 // This function compares 2 RArray<TUint32> arrays. Panics if they are not identical

 LOCAL_C void CompareUint32Arrays(const RArray<TUint32>& aArr1, const RArray<TUint32>& aArr2)	

 	{

 	TEST2(aArr1.Count(), aArr2.Count());

 	for(TInt i = 0; i < aArr2.Count(); i++)

 		{

 		TEST(aArr1[i] == aArr2[i]);				

 		}

 	}

 // This function calls MergerArray() with the pre-set parameters for each merge type and compares the results to 

 // the reference arrays.

 // Also used as the OOM test if aOOMMode is ETrue.

 LOCAL_C void MergerArrayTestL(const RSettingsArray aPersistRef[], const RSettingsArray aChangeRef[], const RArray<TUint32> aDeletedRef[], TBool aOOMMode)

 	{

 	// Data used to construct the persistence array for all merge types	

 	static const ServerSettingStruct settingStructPersist[] = {{1,0,1}, {3,KMetaBackup,3}, {5,0,5}, {7,0,7}, {9,KMetaDefaultValue,9}, {11,0,11}, {13,KMetaDefaultValue,13}};

 	// Data used to construct the changes array for merge type: ETransactionMerge. Some are marked as deleted.

 	static const ServerSettingStruct settingStructChangeTrans[] = {{1,TServerSetting::EDeleted,1}, {2,TServerSetting::EDeleted,2}, \

 		{3,TServerSetting::EDeleted,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};

 	// Data used to construct the changes array for all other merge types than ETransactionMerge. No deleted items.

 	static const ServerSettingStruct settingStructChange[] = {{1,0,1}, {2,0,2}, {3,0,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};

 	for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++)

 		{

 		RSettingsArray persist;

 		RSettingsArray change;

 		RArray<TUint32> deleted; 

 		TInt error = KErrNone ;

 		TInt count = 0;

 		do

 			{

 			__UHEAP_MARK;

 			// Sets up arrays passed into MergeArray()

 			SetupSettingsArrayL(persist,settingStructPersist, sizeof(settingStructPersist)/sizeof(ServerSettingStruct));

 			if( ETransactionMerge == KMergerTypes[i] )

 				{

 				SetupSettingsArrayL(change,settingStructChangeTrans, sizeof(settingStructChangeTrans)/sizeof(ServerSettingStruct));	

 				}

 			else

 				{

 				SetupSettingsArrayL(change,settingStructChange, sizeof(settingStructChange)/sizeof(ServerSettingStruct));	

 				}

 			deleted.InsertInUnsignedKeyOrderL(4);

 			if(aOOMMode)

 				{

 				__UHEAP_SETFAIL(RHeap::EFailNext, ++count);

 				}

 			error = persist.MergeArray(change, deleted, KMergerTypes[i]);

 			if (aOOMMode)

 				{

 				TEST(KErrNone == error || KErrNoMemory == error);

 				__UHEAP_SETFAIL(RHeap::ENone, 0);

 				}

 			else 

 				{

 				TEST(KErrNone == error);

 				// Verifies affected arrays.

 				CompareSettingsArrays(persist, aPersistRef[i]);

 				CompareSettingsArrays(change, aChangeRef[i]);

 				CompareUint32Arrays(deleted, aDeletedRef[i]);

 				} 

 			// Resets the arrays.			

 			persist.Reset();

 			change.Reset();		

 			deleted.Reset();

 			__UHEAP_MARKEND;

 			} while(KErrNoMemory == error);

 	 	if (aOOMMode)

 	 		{

 			TheTest.Printf(_L("- MergeArray for type %d succeeded at heap failure rate of %i\n"), KMergerTypes[i], count);	 		

 	 		}

 		}

 	}

 /**

 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4037

 @SYMTestCaseDesc This test case verifies the re-factored CentralRepository internal merge function (MergeArray).

 @SYMTestPriority High

 @SYMTestActions	 For each merger type, calls MergeArray() with the pre-defined arrays: this, aChanges, aDeleted, 

                  which would be changed by the function. Verifies these 3 arrays with the reference arrays as well as 

                  the return code after MergeArray() returns.

                  This case also carries out the OOM test for function MergeArray().

 @SYMTestExpectedResults MergeArray() should return no error and these 3 arrays should be identical with the reference

                         arrays. In OOM mode, only KErrNoMemory or KErrNone should be returned.

 @SYMDEF DEF116629

 */

 LOCAL_C void DEF116629L()

 	{

 	// Data used to construct the reference arrays of each merge type:

 	// ETransactionMerge

 	const ServerSettingStruct settingStructPersistAfterTrans[] = {{4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}};

 	const ServerSettingStruct settingStructChangeAfterTrans[] = {{1,TServerSetting::EDeleted,1}, 

 		{3,TServerSetting::EDeleted,3}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}};

 	// ERestoreMerge

 	const ServerSettingStruct settingStructPersistAfterRest[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}};

 	const ServerSettingStruct settingStructChangeAfterRest[] = {{2,0,2}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}};

 	// ESWIUpgradeMerge

 	const ServerSettingStruct settingStructPersistAfterSWIUp[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}, {13,0,13}};

 	const ServerSettingStruct settingStructChangeAfterSWIUp[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}};

 	// ESWIDowngradeMerge

 	const ServerSettingStruct settingStructPersistAfterSWIDown[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}};

 	const ServerSettingStruct settingStructChangeAfterSWIDown[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}, {13,0,0}};

 	// ERomFlash

 	const ServerSettingStruct settingStructPersistAfterRomFlash[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}};	

 	const ServerSettingStruct settingStructChangeAfterRomFlash[] = {{1,0,1}, {2,0,2}, {3,0,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};			

 	// Reference arrays

 	RSettingsArray persistAfter[5];

 	RSettingsArray changeAfter[5];

 	RArray<TUint32> deletedAfter[5]; 

 	// Sets up the reference arrays for each merge type:

 	// ETransactionMerge

 	SetupSettingsArrayL(persistAfter[0],settingStructPersistAfterTrans, sizeof(settingStructPersistAfterTrans)/sizeof(ServerSettingStruct));

 	SetupSettingsArrayL(changeAfter[0],settingStructChangeAfterTrans, sizeof(settingStructChangeAfterTrans)/sizeof(ServerSettingStruct));

 	deletedAfter[0].InsertInUnsignedKeyOrderL(3);

 	// ERestoreMerge

 	SetupSettingsArrayL(persistAfter[1],settingStructPersistAfterRest, sizeof(settingStructPersistAfterRest)/sizeof(ServerSettingStruct));

 	SetupSettingsArrayL(changeAfter[1],settingStructChangeAfterRest, sizeof(settingStructChangeAfterRest)/sizeof(ServerSettingStruct));

 	//deletedAfter[1] should be empty because Restore Merge should not delete any setting.

 	// ESWIUpgradeMerge

 	SetupSettingsArrayL(persistAfter[2],settingStructPersistAfterSWIUp, sizeof(settingStructPersistAfterSWIUp)/sizeof(ServerSettingStruct));

 	SetupSettingsArrayL(changeAfter[2],settingStructChangeAfterSWIUp, sizeof(settingStructChangeAfterSWIUp)/sizeof(ServerSettingStruct));

 	//deletedAfter[2] should be empty because SWIUpgrade Merge should not delete any setting.

 	// ESWIDowngradeMerge

 	SetupSettingsArrayL(persistAfter[3],settingStructPersistAfterSWIDown, sizeof(settingStructPersistAfterSWIDown)/sizeof(ServerSettingStruct));

 	SetupSettingsArrayL(changeAfter[3],settingStructChangeAfterSWIDown, sizeof(settingStructChangeAfterSWIDown)/sizeof(ServerSettingStruct));

 	//deletedAfter[3] should be empty because settings deleted by SWIDowngrade Merge are recorded in aChanges.

 	// ERomFlash

 	SetupSettingsArrayL(persistAfter[4],settingStructPersistAfterRomFlash, sizeof(settingStructPersistAfterRomFlash)/sizeof(ServerSettingStruct));

 	SetupSettingsArrayL(changeAfter[4],settingStructChangeAfterRomFlash, sizeof(settingStructChangeAfterRomFlash)/sizeof(ServerSettingStruct));

 	//deletedAfter[4] should be empty because settings deleted by RomFlash Merge are recorded in aChanges.

 	TheTest.Printf(_L("- Verification test for MergeArray.\n"));

 	MergerArrayTestL(persistAfter, changeAfter, deletedAfter, EFalse);

 	TheTest.Printf(_L("- OOM test for MergeArray.\n"));

 	MergerArrayTestL(persistAfter, changeAfter, deletedAfter, ETrue);

 	// Resets the reference arrays.		

 	for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++)

 		{

 		persistAfter[i].Reset();

 		changeAfter[i].Reset();

 		deletedAfter[i].Reset();

 		}

 	}

 /**

 @SYMTestCaseID 				PDS-CENTRALREPOSITORY-UT-4046	

 @SYMTestCaseDesc 			The centrep server panics when it reads a repository text file where 

 							the value of a binary settings is missing.

 @SYMTestPriority 			Medium

 @SYMTestActions  			- Provide a repository text file for this test which have a binary 

 							setting which value is missing. 

  							- Open the repository text file, 

 							this should return KErrCorrupt when parsing the repository text file.

 @SYMTestExpectedResults 	The test must not fail. 

 @SYMDEF 					PDEF126904 

 */    

 LOCAL_C void PDEF126904L()

    	{

    	const TUid KUidBinaryValueRepositoryFile ={0x1020506B};

    	const TInt KBinaryValueRepKey = 0xA;

    	TInt binaryValue = 0;

    	CRepository* repository = NULL;

    	TRAPD(res, repository = CRepository::NewL(KUidBinaryValueRepositoryFile));		

    	if (res == KErrNone)

  		{

  		TInt err = KErrNone;

  		CleanupStack::PushL(repository);

  		err = repository->Get(KBinaryValueRepKey, binaryValue);

 		User::LeaveIfError(err);

  		CleanupStack::PopAndDestroy(repository);

  		}

  	else if (res == KErrCorrupt)

  		{

  		//This is just to confirm that the err should be KErrCorrupt.

 		TheTest.Printf(_L("The error is KErrCorrupt as expected.\n"));

 		}

  	else

 		{

  		User::Leave(res);

  		}

 }	

 /**

 @SYMTestCaseID 				PDS-CENTRALREPOSITORY-UT-4084	

 @SYMTestCaseDesc 			Ensure that the timestamp in a TXT file is always zero when not specified

 							instead of arbitrary value

 @SYMTestPriority 			Medium

 @SYMTestActions  			Create the CHeapRepository object from a TXT keyspace file where no timestamp(legacy)

 							section is specified. The timestamp should be set to zero

 @SYMTestExpectedResults 	The test must not fail. 

 @SYMDEF 					DEF136161 

 */ 

 LOCAL_C void DEF136161L()

 	{

 	RFs fs;

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

 	//this is a TXT based ROM keyspace

 	const TUid KTestUid={0x00000001};

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

 	CIniFileIn* iniFile;

 	TInt ret=CIniFileIn::NewLC(fs,iniFile,_L("z:\\private\\10202be9\\00000001.txt"));

 	User::LeaveIfError(ret);

 	repos->ReloadContentL(*iniFile);

 	//check the timestamp is always set to zero

 	TEST(repos->TimeStamp()==TTime(0));

 	CleanupStack::PopAndDestroy(iniFile);

 	delete repos;

 	fs.Close();

 	}

 /**

 @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4085

 @SYMTestCaseDesc  Central Repository: Trying to configure Central Repository cache with centrep.in 

 @SYMTestPriority High

 @SYMTestActions	Testing that the SWIWatcher does nto leave when the cache configuration exists within

 the private data cate

 @SYMTestExpectedResults Test should pass and exhibit the expected behaviour