Symaptic: os/persistentdata/persistentstorage/centralrepository/test/t_cenrep

sl@0	1	// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	//
sl@0	15
sl@0	16	#include "t_cenrep_helper.h"
sl@0	17	#include <centralrepository.h>
sl@0	18	#include <e32property.h>
sl@0	19	#include <e32test.h>
sl@0	20	#include <f32file.h>
sl@0	21	#include <bautils.h>
sl@0	22	#include <cenrepnotifyhandler.h>
sl@0	23
sl@0	24	#include "e32math.h"
sl@0	25	#include "srvparams.h"
sl@0	26	#include "srvreqs.h"
sl@0	27	#include "srvdefs.h"
sl@0	28	#include "transstate.h"
sl@0	29	#include "obsrvr_noc.h"
sl@0	30	#include "shrepos.h"
sl@0	31	#include "install.h"
sl@0	32
sl@0	33	using namespace NCentralRepositoryConstants;
sl@0	34
sl@0	35	RTest TheTest(_L("Central Repository Defect Tests"));
sl@0	36
sl@0	37	_LIT( KCentralRepositoryServerName, "Centralrepositorysrv");
sl@0	38
sl@0	39	const TUid KUidDEF060843LRepository1 = { 0x00000001 };
sl@0	40	const TUid KUidRep1 = { 0x00000100 };
sl@0	41	const TUid KUidDEF053500LTestRepository = { 0x00000102 };
sl@0	42	const TUid KUidDEF054368TestRepository = { 0x00000103 };
sl@0	43	const TUid KUidINC054688TestRepository = { 0x100058db };
sl@0	44	const TUid KUidDEF054632TestRepository = { 0x10054632 };
sl@0	45	const TUid KUidDEF054633TestRepository = { 0x10054633 };
sl@0	46	const TUid KUidLargeRepository = { 0xCCCCCC01 };
sl@0	47	const TUid KUidDEF055661TestRepository = { 0x10055661 };
sl@0	48	const TUid KUidINC056194TestRepository = { 0x00056194 };
sl@0	49	const TUid KUidDEF057778TestRepository = { 0x00057778 };
sl@0	50	const TUid KUidDEF057470TestRepository = { 0x10057470 };
sl@0	51	const TUid KUidDEF058900TestRepository = { 0x10058900 };
sl@0	52	const TUid KUidINC069013TestRepository = { 0x00000104 };
sl@0	53	const TUid KUidPDEF098500LRepository = { 0x10098500 };
sl@0	54
sl@0	55	const TUint32 KRangeDeletePartialKey = 0x04010000 ;
sl@0	56	const TUint32 KDeleteKeyDoesntExist = 0x07000000 ;
sl@0	57	const TUint32 KDeleteForbidden = 0x03010000 ;
sl@0	58	const TUint32 KTransactionRangeDeletePartialKey = 0x02010000 ;
sl@0	59	const TUint32 KRangeDeleteMask = 0x0F0F0000 ;
sl@0	60	const TUint32 KNullKey = 0x00000000 ;
sl@0	61
sl@0	62	const TUint32 KNotifyBannedKey = static_cast<TUint32>(KRequestPending) ;
sl@0	63	const TUint32 KNotificationKey1 = 0x80000101;
sl@0	64	const TUint32 KNotificationKey2 = 0x80000201;
sl@0	65	const TUint32 KNotificationKey3 = 0x80000301;
sl@0	66	const TUint32 KNotificationKey4 = 0x80000401;
sl@0	67
sl@0	68	//
sl@0	69	// Repository A
sl@0	70	//
sl@0	71
sl@0	72	const TUint32 KNewInt = 1000;
sl@0	73	const TInt KIntValue = 1234;
sl@0	74
sl@0	75
sl@0	76	// Definitions for test DEF116629L()
sl@0	77	// The structure to construct a TServerSetting object with a TInt value.
sl@0	78	struct ServerSettingStruct
sl@0	79	{
sl@0	80	TUint32 key;
sl@0	81	TUint32 meta;
sl@0	82	TInt value;
sl@0	83	};
sl@0	84	// The merge types to be tested
sl@0	85	const TMergeType KMergerTypes[] = {ETransactionMerge,ERestoreMerge, ESWIUpgradeMerge, ESWIDowngradeMerge, ERomFlash};
sl@0	86
sl@0	87
sl@0	88	///////////////////////////////////////////////////////////////////////////////////////
sl@0	89	///////////////////////////////////////////////////////////////////////////////////////
sl@0	90	//Test macroses and functions
sl@0	91	LOCAL_C void CheckL(TInt aValue, TInt aLine)
sl@0	92	{
sl@0	93	if(!aValue)
sl@0	94	{
sl@0	95	CleanupCDriveL();
sl@0	96	TheTest(EFalse, aLine);
sl@0	97	}
sl@0	98	}
sl@0	99	LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)
sl@0	100	{
sl@0	101	if(aValue != aExpected)
sl@0	102	{
sl@0	103	RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0	104	CleanupCDriveL();
sl@0	105	TheTest(EFalse, aLine);
sl@0	106	}
sl@0	107	}
sl@0	108
sl@0	109	#define TEST(arg) ::CheckL((arg), __LINE__)
sl@0	110	#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)
sl@0	111
sl@0	112	///////////////////////////////////////////////////////////////////////////////////////
sl@0	113	///////////////////////////////////////////////////////////////////////////////////////
sl@0	114
sl@0	115	/**
sl@0	116	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4015
sl@0	117	@SYMTestCaseDesc When having multiple connections to a particular repository, starting a
sl@0	118	transaction and then killing that connection, should not cause a reset.
sl@0	119	@SYMTestPriority High
sl@0	120	@SYMTestActions
sl@0	121	Essentially - this deals with multiple connections, the lack of cancelling a transaction,
sl@0	122	either by shutting the sub-session to the CR server directly (or by a crashing application
sl@0	123	where all open sub-sessions to CR from that application are closed) and the cache manager
sl@0	124	inside CR.
sl@0	125
sl@0	126	Previously, CR's cache manager would reclaim repository memory regardless of the state
sl@0	127	of the repository (in transaction or not). However, if a repository is closed and its
sl@0	128	no longer an open repository (cache manager reclaimed the memory), it would not remove
sl@0	129	references to the sub-session for this repository in the transaction queue. Simply put,
sl@0	130	the sub-session's data would be deleted but there would still be references to that
sl@0	131	deleted data. When you established a new connection (any operation would cause this) you'd
sl@0	132	walk down an invalid pointer. Most of the time this would cause the server to crash.
sl@0	133
sl@0	134	Now, if you're in an active transaction, the cache manager does not reclaim the data.
sl@0	135	Which means that there will always be valid references in the transaction queue.
sl@0	136
sl@0	137	ThreadA CR CR Cache Manager
sl@0	138	Connection 1.
sl@0	139	CRepository::NewLC(X) ---------------> EInitialize
sl@0	140
sl@0	141	Connection 2.
sl@0	142	CRepository::NewLC(X) ---------------> EInitialize
sl@0	143
sl@0	144	Connection 2, Start Transaction
sl@0	145	StartTransaction ----------------> ETransactionStart
sl@0	146
sl@0	147	Before
sl@0	148	----------------------------------------------------------------------------------
sl@0	149	Wait 10 seconds
sl@0	150
sl@0	151	<--------------------------- Evict(X)
sl@0	152
sl@0	153	Connection 2. Close
sl@0	154	delete connection2 ------------------> EClose (would leave invalid references)
sl@0	155
sl@0	156	Connection 1.
sl@0	157	GetInt ------------------> EGetInt (would attach to repository, derefence
sl@0	158	invalid pointer, CR would crash)
sl@0	159
sl@0	160	-----------------------------------------------------------------------------------
sl@0	161	Now
sl@0	162
sl@0	163	Wait 10 seconds
sl@0	164
sl@0	165	Reschedule
sl@0	166	(CR cache manager sees that Repository X
sl@0	167	is in a transaction and just reschedules
sl@0	168	it)
sl@0	169	Connection 2. Close
sl@0	170	delete connection2 --------------------> EClose (memory is now available so it cancels
sl@0	171	the active transaction)
sl@0	172
sl@0	173	GetInt --------------------> EGetInt (attaches to the open repository, all is
sl@0	174	fine)
sl@0	175	delete connection2 --------------------> EClose (repository X has no more observers so
sl@0	176	it is scheduled to have its memory reclaimed
sl@0	177	by CR cache manager)
sl@0	178
sl@0	179	@SYMTestExpectedResults The test must not fail.
sl@0	180	@SYMDEF DEF111734
sl@0	181	*/
sl@0	182
sl@0	183	LOCAL_C void DEF111734L()
sl@0	184	{
sl@0	185	/* first establish a connection. this is important because if there are no observers
sl@0	186	* on a repository, the repository's shared data is deleted directly */
sl@0	187	CRepository* rep;
sl@0	188	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));
sl@0	189
sl@0	190	/* second establish a second connection. this will be used to start a transaction */
sl@0	191	CRepository* rep2;
sl@0	192	User::LeaveIfNull(rep2 = CRepository::NewLC(KUidDEF054368TestRepository));
sl@0	193
sl@0	194	/* establish a transaction, this manipulates the transaction queue for this repository */
sl@0	195	rep2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
sl@0	196
sl@0	197	/* now wait. this should be plenty of time to allow cache manager in CR to reclaim
sl@0	198	* the data for this repository */
sl@0	199	User::After(5050000 + 9500000);
sl@0	200
sl@0	201	TInt i = 0;
sl@0	202	const TInt KInt1_InitialValue = 100;
sl@0	203	const TUint32 KInt1 = 0x1;
sl@0	204
sl@0	205	/* destory the connection - this will cause a "close" operation in CR */
sl@0	206	CleanupStack::PopAndDestroy(rep2);
sl@0	207
sl@0	208	/* attempt to reconnect to the repository. */
sl@0	209	TInt r = rep->Get(KInt1, i);
sl@0	210
sl@0	211	/* if the fix is not in the build, then CR will crash.
sl@0	212	* Errcode will be KErrServerTerminated */
sl@0	213	TEST2(r, KErrNone);
sl@0	214
sl@0	215	/* just for completion's sake, check the return value */
sl@0	216	TEST(i == KInt1_InitialValue);
sl@0	217
sl@0	218	// Close repository
sl@0	219
sl@0	220	CleanupStack::PopAndDestroy(rep);
sl@0	221	}
sl@0	222
sl@0	223
sl@0	224	LOCAL_C void DEF053500L()
sl@0	225	{
sl@0	226	CRepository* rep;
sl@0	227	// Open repository with hex key value setting
sl@0	228	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF053500LTestRepository));
sl@0	229	// Close repository
sl@0	230	CleanupStack::PopAndDestroy(rep);
sl@0	231	}
sl@0	232
sl@0	233	LOCAL_C void DEF054368L()
sl@0	234	{
sl@0	235	CRepository* rep;
sl@0	236	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));
sl@0	237
sl@0	238	TInt i = 0;
sl@0	239	const TInt KInt1_InitialValue = 100;
sl@0	240	const TInt KInt2_InitialValue = 200;
sl@0	241	const TInt KInt3_InitialValue = -100;
sl@0	242	const TInt KInt4_InitialValue = -200;
sl@0	243	const TInt KInt5_InitialValue = 0xc8;
sl@0	244
sl@0	245	const TUint32 KInt1 = 0x1;
sl@0	246	const TUint32 KInt2 = 0x2;
sl@0	247	const TUint32 KInt3 = 0x3;
sl@0	248	const TUint32 KInt4 = 0x4;
sl@0	249	const TUint32 KInt5 = 0x5;
sl@0	250
sl@0	251	TInt r = rep->Get(KInt1, i);
sl@0	252	TEST2(r, KErrNone);
sl@0	253	TEST(i==KInt1_InitialValue);
sl@0	254
sl@0	255	r = rep->Get(KInt2, i);
sl@0	256	TEST2(r, KErrNone);
sl@0	257	TEST(i==KInt2_InitialValue);
sl@0	258
sl@0	259	r = rep->Get(KInt3, i);
sl@0	260	TEST2(r, KErrNone);
sl@0	261	TEST(i==KInt3_InitialValue);
sl@0	262
sl@0	263	r = rep->Get(KInt4, i);
sl@0	264	TEST2(r, KErrNone);
sl@0	265	TEST(i==KInt4_InitialValue);
sl@0	266
sl@0	267	r = rep->Get(KInt5, i);
sl@0	268	TEST2(r, KErrNone);
sl@0	269	TEST(i==KInt5_InitialValue);
sl@0	270
sl@0	271	// Close repository
sl@0	272	CleanupStack::PopAndDestroy(rep);
sl@0	273	}
sl@0	274
sl@0	275	LOCAL_C void DEF055680L()
sl@0	276	{
sl@0	277	CRepository* rep;
sl@0	278	// Open repository
sl@0	279	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
sl@0	280
sl@0	281	// Find setting whose value the test doesn't have permission to look at
sl@0	282	RArray<TUint32> foundIds;
sl@0	283	TInt r = KErrNone;
sl@0	284	r = rep->FindL(0x810100, 0xFFFFFFFF, foundIds);
sl@0	285	TEST2(r, KErrNone);
sl@0	286	TEST2(foundIds.Count(), 1);
sl@0	287
sl@0	288	TInt val;
sl@0	289	r = rep->Get(foundIds[0], val);
sl@0	290	TEST2(r, KErrPermissionDenied);
sl@0	291	foundIds.Reset();
sl@0	292
sl@0	293	r = rep->Create(KNewInt, KIntValue);
sl@0	294	TEST2(r, KErrNone);
sl@0	295
sl@0	296	//Reset repository to remove any changes made during this test
sl@0	297	r = rep->Reset();
sl@0	298	TEST2(r, KErrNone);
sl@0	299
sl@0	300	// Close repository
sl@0	301	CleanupStack::PopAndDestroy(rep);
sl@0	302
sl@0	303	}
sl@0	304
sl@0	305	LOCAL_C void DEF054632L()
sl@0	306	{
sl@0	307	CRepository* rep;
sl@0	308
sl@0	309	//----------Testing for correct default policy behaviour---------------
sl@0	310	/*---------------------10054632.txt------------------------------------
sl@0	311	[platsec]
sl@0	312	cap_rd=ReadDeviceData cap_wr=WriteDeviceData
sl@0	313	0x3 0x4 cap_wr=NetworkServices
sl@0	314	[Main]
sl@0	315	0x1 int 1 0 cap_rd=CommDD
sl@0	316	0x2 int 2 1 cap_wr=CommDD
sl@0	317	0x3 int 3 0
sl@0	318	0x4 int 4 0
sl@0	319	0x5 int 5 0 cap_rd=CommDD
sl@0	320	---------------------------------------------------------------------*/
sl@0	321	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054632TestRepository));
sl@0	322
sl@0	323	//testing single policies
sl@0	324	TInt err=KErrNone;
sl@0	325	const TInt key_2=2;
sl@0	326	const TInt key_1=1;
sl@0	327	TInt value=0;
sl@0	328
sl@0	329	err=rep->Get(key_2,value);
sl@0	330	TEST2(err,KErrNone);
sl@0	331
sl@0	332	err=rep->Set(key_1,value);
sl@0	333	TEST2(err,KErrNone);
sl@0	334
sl@0	335	//testing range policies
sl@0	336	const TInt key_3=3;
sl@0	337	err=rep->Get(key_3,value);
sl@0	338	TEST2(err,KErrNone);
sl@0	339
sl@0	340	CleanupStack::PopAndDestroy(rep);
sl@0	341
sl@0	342	//------Testing for correct policy behaviour with no default policies-----
sl@0	343	/*--------------------------10054633.txt----------------------------------
sl@0	344	[platsec]
sl@0	345	0x3 0x4 cap_rd=CommDD
sl@0	346	[Main]
sl@0	347	0x1 int 1 0 cap_rd=CommDD
sl@0	348	0x2 int 2 1 cap_wr=CommDD
sl@0	349	0x3 int 3 0
sl@0	350	0x4 int 4 0
sl@0	351	------------------------------------------------------------------------*/
sl@0	352	User::LeaveIfNull(rep=CRepository::NewLC(KUidDEF054633TestRepository));
sl@0	353
sl@0	354	//testing single policies
sl@0	355	err=rep->Get(key_1,value);
sl@0	356	TEST2(err,KErrPermissionDenied);
sl@0	357	err=rep->Set(key_1,value);
sl@0	358	TEST2(err,KErrPermissionDenied);
sl@0	359
sl@0	360	err=rep->Set(key_2,value);
sl@0	361	TEST2(err,KErrPermissionDenied);
sl@0	362	err=rep->Get(key_2,value);
sl@0	363	TEST2(err,KErrPermissionDenied);
sl@0	364
sl@0	365	//testing range policies
sl@0	366	err=rep->Get(key_3,value);
sl@0	367	TEST2(err,KErrPermissionDenied);
sl@0	368	const TInt key_4=4;
sl@0	369	err=rep->Set(key_4,value);
sl@0	370	TEST2(err,KErrPermissionDenied);
sl@0	371	err=rep->Get(key_4,value);
sl@0	372	TEST2(err,KErrPermissionDenied);
sl@0	373
sl@0	374	CleanupStack::PopAndDestroy(rep);
sl@0	375	}
sl@0	376
sl@0	377	/**
sl@0	378	This test will be checking the robustness of the modified array structure
sl@0	379	for the single policies, range policies.
sl@0	380	*/
sl@0	381	LOCAL_C void INC054688L()
sl@0	382	{
sl@0	383	CRepository* rep;
sl@0	384	User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));
sl@0	385
sl@0	386	//--------------CHECKING THE SINGLE POLICIES ARRAY----------------------
sl@0	387	//The ini file has been structured so that the key will be equal to the
sl@0	388	//key value so we can test it using a loop.
sl@0	389	//and also to check some policy checking, we set all the even entries to
sl@0	390	//be non accessible due to insufficient capabilities
sl@0	391	//The key tested for the single policies are from 1 to 24
sl@0	392	const TInt KMaxKeyEntry=24;
sl@0	393	TInt err=KErrNone;
sl@0	394	TInt key_value=0;
sl@0	395	for (TInt i=1;i<=KMaxKeyEntry;i++)
sl@0	396	{
sl@0	397	err=rep->Get(i,key_value);
sl@0	398	//even entries alway not accessible due to insufficient caps
sl@0	399	if (i%2==0)
sl@0	400	TEST2(err,KErrPermissionDenied);
sl@0	401	else
sl@0	402	{
sl@0	403	TEST2(err,KErrNone);
sl@0	404	TEST2(i,key_value);
sl@0	405	}
sl@0	406	}
sl@0	407
sl@0	408	//--------------CHECKING THE RANGE POLICIES ARRAY----------------------
sl@0	409	//The range policies in the [platsec] section are arranged in key pairs
sl@0	410	//e.g 25-26,27-28.For testing purpose, the odd pairs(e.g 25-26 is the
sl@0	411	//first pair) will require capabilities that the test lacks off hence
sl@0	412	//causing KErrPermissionDenied when trying to read those range.
sl@0	413	//The key tested for the arary policies are from 25-38 and the value
sl@0	414	//matches the key
sl@0	415
sl@0	416	const TInt startRangeKey=25;
sl@0	417	const TInt KMaxRangeKey=38;
sl@0	418	TInt numberOfPairs=(KMaxRangeKey-startRangeKey+1)/2;
sl@0	419	TInt key_value1=0;
sl@0	420	TInt err1=KErrNone;
sl@0	421	for (TInt j=0;j<numberOfPairs;j++)
sl@0	422	{
sl@0	423	//Get first key of the pair
sl@0	424	err=rep->Get(startRangeKey+(2*j),key_value);
sl@0	425	//Get second key of the pair
sl@0	426	err1=rep->Get(startRangeKey+(2*j)+1,key_value1);
sl@0	427	//start from j=0(first pair)
sl@0	428	if ((j+1)%2==0)
sl@0	429	{
sl@0	430	TEST2(err,KErrNone);
sl@0	431	TEST2(err1,KErrNone);
sl@0	432	TEST2(startRangeKey+(2*j),key_value);
sl@0	433	TEST2(startRangeKey+(2*j)+1,key_value1);
sl@0	434	}
sl@0	435	//only odd pairs are non-accessible due to insufficient caps
sl@0	436	else
sl@0	437	{
sl@0	438	TEST2(err,KErrPermissionDenied);
sl@0	439	TEST2(err1,KErrPermissionDenied);
sl@0	440	}
sl@0	441	}
sl@0	442
sl@0	443	//Before closing the repository, modify one of the key to see whether
sl@0	444	//the policy array behaves similarly after a rewrite of the ini file
sl@0	445	const TInt keyToChange=3;
sl@0	446	const TInt modifiedValue=3;
sl@0	447	err=rep->Set(keyToChange,modifiedValue);
sl@0	448	TEST2(err,KErrNone);
sl@0	449
sl@0	450	// Close repository
sl@0	451	CleanupStack::PopAndDestroy(rep);
sl@0	452	User::After(KGeneralDelay);
sl@0	453
sl@0	454	//Reopen the repository again after that minor update which will cause
sl@0	455	//all the entry in the ini file to be reversed
sl@0	456	User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));
sl@0	457
sl@0	458	//---------RECHECKING THE POLICY ARRAY AFTER UPDATE--------------------
sl@0	459	for (TInt i=1;i<=KMaxKeyEntry;i++)
sl@0	460	{
sl@0	461	err=rep->Get(i,key_value);
sl@0	462	//even entries alway not accessible due to insufficient caps
sl@0	463	if (i%2==0)
sl@0	464	TEST2(err,KErrPermissionDenied);
sl@0	465	else
sl@0	466	{
sl@0	467	TEST2(err,KErrNone);
sl@0	468	TEST2(i,key_value);
sl@0	469	}
sl@0	470	}
sl@0	471
sl@0	472
sl@0	473	//---------RECHECKING THE RANGE POLICY ARRAY AFTER UPDATE-------------
sl@0	474	for (TInt j=0;j<numberOfPairs;j++)
sl@0	475	{
sl@0	476	//Get first key of the pair
sl@0	477	err=rep->Get(startRangeKey+(2*j),key_value);
sl@0	478	//Get second key of the pair
sl@0	479	err1=rep->Get(startRangeKey+(2*j)+1,key_value1);
sl@0	480	//start from j=0(first pair)
sl@0	481	if ((j+1)%2==0)
sl@0	482	{
sl@0	483	TEST2(err,KErrNone);
sl@0	484	TEST2(err1,KErrNone);
sl@0	485	TEST2(startRangeKey+(2*j),key_value);
sl@0	486	TEST2(startRangeKey+(2*j)+1,key_value1);
sl@0	487	}
sl@0	488	//only odd pairs are non-accessible due to insufficient caps
sl@0	489	else
sl@0	490	{
sl@0	491	TEST2(err,KErrPermissionDenied);
sl@0	492	TEST2(err1,KErrPermissionDenied);
sl@0	493	}
sl@0	494	}
sl@0	495
sl@0	496	CleanupStack::PopAndDestroy(rep);
sl@0	497	}
sl@0	498
sl@0	499	LOCAL_C void DEF055661L()
sl@0	500	{
sl@0	501	/*--------------------10055661.txt----------------------------------------
sl@0	502	[platsec]
sl@0	503	cap_rd=ReadDeviceData cap_wr=AlwaysFail
sl@0	504	0x3 0x4 cap_wr=NetworkServices
sl@0	505	[Main]
sl@0	506	0x1 int 1 0 cap_rd=AlwaysPass
sl@0	507	0x2 int 2 1 cap_rd=AlwaysFail
sl@0	508	0x3 int 3 0
sl@0	509	0x4 int 4 0 cap_rd=AlwaysFail
sl@0	510	0x5 int 5 0 cap_wr=AlwaysPass
sl@0	511	-------------------------------------------------------------------------*/
sl@0	512	CRepository* rep;
sl@0	513	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF055661TestRepository));
sl@0	514
sl@0	515	TInt err=KErrNone;
sl@0	516	TInt keyValue=0;
sl@0	517
sl@0	518	//Key 1
sl@0	519	err=rep->Get(1,keyValue);
sl@0	520	TEST2(err,KErrNone);
sl@0	521	TEST2(keyValue,1);
sl@0	522	err=rep->Set(1,keyValue);
sl@0	523	TEST2(err,KErrPermissionDenied);
sl@0	524
sl@0	525	//Key 2
sl@0	526	err=rep->Get(2,keyValue);
sl@0	527	TEST2(err,KErrPermissionDenied);
sl@0	528	err=rep->Set(2,keyValue);
sl@0	529	TEST2(err,KErrPermissionDenied);
sl@0	530
sl@0	531	//Key 3
sl@0	532	err=rep->Get(3,keyValue);
sl@0	533	TEST2(err,KErrNone);
sl@0	534	TEST2(keyValue,3);
sl@0	535	err=rep->Set(3,keyValue);
sl@0	536	TEST2(err,KErrPermissionDenied);
sl@0	537
sl@0	538	//Key 4
sl@0	539	err=rep->Get(4,keyValue);
sl@0	540	TEST2(err,KErrPermissionDenied);
sl@0	541	err=rep->Set(4,keyValue);
sl@0	542	TEST2(err,KErrPermissionDenied);
sl@0	543
sl@0	544	//Key 5
sl@0	545	err=rep->Get(5,keyValue);
sl@0	546	TEST2(err,KErrNone);
sl@0	547	err=rep->Set(5,keyValue);
sl@0	548	TEST2(err,KErrNone);
sl@0	549
sl@0	550	CleanupStack::PopAndDestroy(rep);
sl@0	551	}
sl@0	552
sl@0	553	LOCAL_C void DEF055267L()
sl@0	554	{
sl@0	555	CRepository* rep;
sl@0	556	// Open repository
sl@0	557	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
sl@0	558
sl@0	559	TInt r;
sl@0	560	TUint32 errorId;
sl@0	561	// The following loop creates enough settings to blow the server heap
sl@0	562	// when it's 1 M. If it passes it proves that the server heap is > 1M
sl@0	563	// Increasing the server heap allows the messaging test to pass
sl@0	564	_LIT(KString, "Long test string !!!!!!!!!!!");
sl@0	565	const TInt KNumTransactions=25;
sl@0	566	const TInt KNumSettingsInTrans=100;
sl@0	567	for(TInt numTransactions=0; numTransactions<KNumTransactions;numTransactions++)
sl@0	568	{
sl@0	569	r = rep->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	570	TEST2(r, KErrNone);
sl@0	571	for(TInt numSettingsInTrans=0; numSettingsInTrans<KNumSettingsInTrans; numSettingsInTrans++)
sl@0	572	{
sl@0	573	r = rep->Create((numTransactions*KNumSettingsInTrans)+numSettingsInTrans, KString);
sl@0	574	TEST2(r, KErrNone);
sl@0	575	}
sl@0	576	r = rep->CommitTransaction(errorId);
sl@0	577	TEST2(r, KErrNone);
sl@0	578	}
sl@0	579
sl@0	580	//Reset repository to remove any changes made during this test
sl@0	581	r = rep->Reset();
sl@0	582	TEST2(r, KErrNone);
sl@0	583
sl@0	584	// Close repository
sl@0	585	CleanupStack::PopAndDestroy(rep);
sl@0	586	}
sl@0	587
sl@0	588	LOCAL_C void INC056194L()
sl@0	589	{
sl@0	590	CRepository* repository;
sl@0	591	// Open repository
sl@0	592	User::LeaveIfNull(repository = CRepository::NewLC(KUidINC056194TestRepository));
sl@0	593
sl@0	594	const TUint32 KInt1 = 1;
sl@0	595	TRequestStatus intStatus;
sl@0	596
sl@0	597	TInt r = repository->NotifyRequest(KInt1, intStatus);
sl@0	598	TEST2(r, KErrNone);
sl@0	599	r = repository->NotifyCancel(KInt1);
sl@0	600	TEST2(r, KErrNone);
sl@0	601	User::WaitForAnyRequest();
sl@0	602	TEST(intStatus==KUnspecifiedKey);
sl@0	603
sl@0	604	r = repository->NotifyRequest(KInt1, intStatus);
sl@0	605	TEST2(r, KErrNone);
sl@0	606	r = repository->NotifyCancelAll();
sl@0	607	TEST2(r, KErrNone);
sl@0	608	User::WaitForAnyRequest();
sl@0	609	TEST(intStatus==KUnspecifiedKey);
sl@0	610
sl@0	611	r = repository->NotifyRequest(0, KInt1, intStatus);
sl@0	612	TEST2(r, KErrNone);
sl@0	613	r = repository->NotifyCancel(0, KInt1);
sl@0	614	TEST2(r, KErrNone);
sl@0	615	User::WaitForAnyRequest();
sl@0	616	TEST(intStatus==KUnspecifiedKey);
sl@0	617
sl@0	618	RThread thisThread;
sl@0	619	TEST(thisThread.RequestCount()==0);
sl@0	620
sl@0	621	// Close repository
sl@0	622	CleanupStack::PopAndDestroy(repository);
sl@0	623	}
sl@0	624
sl@0	625	LOCAL_C void DEF057145L()
sl@0	626	{
sl@0	627	TInt err=KErrNone;
sl@0	628	const TUid testUid={0x10057145};
sl@0	629	RArray<TUint32> idArray;
sl@0	630	CRepository* repository;
sl@0	631	User::LeaveIfNull(repository = CRepository::NewLC(testUid));
sl@0	632
sl@0	633	//Start Transaction
sl@0	634	err=repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	635	TEST2(err,KErrNone);
sl@0	636
sl@0	637	//Before creating new entries get the number of persistent settings
sl@0	638	err=repository->FindL(0,0xFFFFF000,idArray);
sl@0	639	TEST2(err,KErrNone);
sl@0	640	TInt persistentSettingsCount=idArray.Count();
sl@0	641	idArray.Close();
sl@0	642
sl@0	643	//Try creating new entries during transaction between the two extreme points
sl@0	644	//ROM persistent file has low key of 1 and high key of 201
sl@0	645	//We try creating new entries in between during transaction
sl@0	646	for (TInt i=100;i<150;i++)
sl@0	647	{
sl@0	648	err=repository->Create(i,i);
sl@0	649	TEST2(err,KErrNone);
sl@0	650	}
sl@0	651
sl@0	652	//Now check the merge with the persistent settings is fine by checking
sl@0	653	//the array count after the merge.
sl@0	654	err=repository->FindL(0x000,0xFFFFF000,idArray);
sl@0	655	TEST2(err,KErrNone);
sl@0	656	TEST(idArray.Count()==(persistentSettingsCount+50));
sl@0	657	idArray.Close();
sl@0	658
sl@0	659	TUint32 errId;
sl@0	660	err=repository->CommitTransaction(errId);
sl@0	661	TEST2(err,KErrNone);
sl@0	662
sl@0	663	idArray.Close();
sl@0	664	CleanupStack::PopAndDestroy(repository);
sl@0	665	}
sl@0	666
sl@0	667
sl@0	668	LOCAL_C void DEF057778L()
sl@0	669	{
sl@0	670	TInt r;
sl@0	671	CRepository* repository;
sl@0	672	// Open repository
sl@0	673	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057778TestRepository));
sl@0	674
sl@0	675	const TUint32 KInt14=14;
sl@0	676	const TInt KInt14NewValue=0;
sl@0	677
sl@0	678	r=repository->Set(KInt14,KInt14NewValue);
sl@0	679	TEST2(r, KErrNone);
sl@0	680
sl@0	681	// Reset setting that has a single policy
sl@0	682	r=repository->Reset(KInt14);
sl@0	683	TEST2(r, KErrNone);
sl@0	684
sl@0	685	// Attempt to access and write setting
sl@0	686	r=repository->Set(KInt14,KInt14NewValue);
sl@0	687	TEST2(r, KErrNone);
sl@0	688
sl@0	689	// Reset entire repository
sl@0	690	r=repository->Reset();
sl@0	691	TEST2(r, KErrNone);
sl@0	692
sl@0	693	// Attempt to access and write setting
sl@0	694	r=repository->Set(KInt14,KInt14NewValue);
sl@0	695	TEST2(r, KErrNone);
sl@0	696
sl@0	697	// Reset entire repository
sl@0	698	r=repository->Reset();
sl@0	699	TEST2(r, KErrNone);
sl@0	700
sl@0	701	// Close repository
sl@0	702	CleanupStack::PopAndDestroy(repository);
sl@0	703	}
sl@0	704
sl@0	705
sl@0	706	LOCAL_C void DEF057999L()
sl@0	707	{
sl@0	708
sl@0	709	TInt err=KErrNone;
sl@0	710	TInt retValue=0;
sl@0	711	const TUid testUid={0x10057145};
sl@0	712	RArray<TUint32> idArray;
sl@0	713
sl@0	714	CRepository* repository;
sl@0	715	User::LeaveIfNull(repository = CRepository::NewLC(testUid));
sl@0	716
sl@0	717	//--------------Start Transaction------------------------------------
sl@0	718	err=repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	719	TEST2(err,KErrNone);
sl@0	720
sl@0	721	//--------------Create follow by delete-----------------------------
sl@0	722	err=repository->Create(3400,3400);
sl@0	723	TEST2(err,KErrNone);
sl@0	724	err=repository->Delete(3400);
sl@0	725	TEST2(err,KErrNone);
sl@0	726	err=repository->Delete(3400);
sl@0	727	TEST2(err,KErrNotFound);
sl@0	728
sl@0	729	//--------------Deleting existing romkey-----------------------------
sl@0	730	err=repository->Delete(200);
sl@0	731	TEST2(err,KErrNone);
sl@0	732
sl@0	733	err=repository->FindL(200,0xFFFFFFFF,idArray);
sl@0	734	TEST2(err,KErrNotFound);
sl@0	735
sl@0	736	//--------------Commit Transaction------------------------------------
sl@0	737	TUint32 errId;
sl@0	738	err=repository->CommitTransaction(errId);
sl@0	739	TEST2(err,KErrNone);
sl@0	740
sl@0	741	idArray.Close();
sl@0	742	CleanupStack::PopAndDestroy(repository);
sl@0	743
sl@0	744	//--------------Reopen and check the deleted keys are gone-------------
sl@0	745	User::LeaveIfNull(repository = CRepository::NewLC(testUid));
sl@0	746
sl@0	747	//Check for the key created and deleted during transaction
sl@0	748	err=repository->FindL(3400,0xFFFFFFFF,idArray);
sl@0	749	TEST2(err,KErrNotFound);
sl@0	750
sl@0	751	//Check for the rom key deleted during transaction
sl@0	752	err=repository->Get(200,retValue);
sl@0	753	TEST2(err,KErrNotFound);
sl@0	754
sl@0	755	//--------------Start Transaction------------------------------------
sl@0	756	err=repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	757	TEST2(err,KErrNone);
sl@0	758
sl@0	759	//--------------Delete follow by create-----------------------------
sl@0	760	err=repository->Delete(201);
sl@0	761	TEST2(err,KErrNone);
sl@0	762	err=repository->Create(201, 201);
sl@0	763	TEST2(err,KErrNone);
sl@0	764
sl@0	765	//--------------Commit Transaction------------------------------------
sl@0	766	err=repository->CommitTransaction(errId);
sl@0	767	TEST2(err,KErrNone);
sl@0	768
sl@0	769	err=repository->Get(201,retValue);
sl@0	770	TEST2(err,KErrNone);
sl@0	771	TEST2(retValue, 201);
sl@0	772
sl@0	773	CleanupStack::PopAndDestroy(repository);
sl@0	774	}
sl@0	775
sl@0	776	LOCAL_C void DEF057522L()
sl@0	777	{
sl@0	778	TInt r=KErrNone;
sl@0	779	CRepository* repository;
sl@0	780	TUid testUidRepository={0x10057522};
sl@0	781
sl@0	782	//Opening a repository with Max number of capabilities supported should not return KErrCorrupt
sl@0	783	User::LeaveIfNull(repository = CRepository::NewLC(testUidRepository));
sl@0	784
sl@0	785	//Test reading some of the settings with the max capabilities defined
sl@0	786	TInt retVal=0;
sl@0	787	r=repository->Get(17,retVal);
sl@0	788	TEST2(r,KErrNone);
sl@0	789	r=repository->Set(17,retVal);
sl@0	790	TEST2(r,KErrNone);
sl@0	791
sl@0	792	r=repository->Get(18,retVal);
sl@0	793	TEST2(r,KErrPermissionDenied);
sl@0	794	r=repository->Set(18,retVal);
sl@0	795	TEST2(r,KErrNone);
sl@0	796
sl@0	797	//Test that AlwaysPass and AlwaysFail behave as expected when not followed by sid
sl@0	798	r=repository->Get(21,retVal);
sl@0	799	TEST2(r,KErrPermissionDenied);
sl@0	800	r=repository->Set(21,retVal);
sl@0	801	TEST2(r,KErrPermissionDenied);
sl@0	802	r=repository->Get(22,retVal);
sl@0	803	TEST2(r,KErrNone);
sl@0	804	r=repository->Set(22,retVal);
sl@0	805	TEST2(r,KErrNone);
sl@0	806
sl@0	807
sl@0	808	//Test that AlwaysPass and AlwaysFail behave as expected when followed by sid
sl@0	809	r=repository->Get(19,retVal);
sl@0	810	TEST2(r,KErrPermissionDenied);
sl@0	811	r=repository->Set(19,retVal);
sl@0	812	TEST2(r,KErrNone);
sl@0	813
sl@0	814	//Additional test cases
sl@0	815	//Test single policies with max 3 caps for both read and write
sl@0	816	r=repository->Get(28,retVal);
sl@0	817	TEST2(r,KErrPermissionDenied);
sl@0	818	r=repository->Set(28,retVal);
sl@0	819	TEST2(r,KErrNone);
sl@0	820
sl@0	821	//Test single policies with max 7 caps for both read and write
sl@0	822	r=repository->Get(33,retVal);
sl@0	823	TEST2(r,KErrPermissionDenied);
sl@0	824	r=repository->Set(33,retVal);
sl@0	825	TEST2(r,KErrPermissionDenied);
sl@0	826
sl@0	827	//Test range policies with max 3 caps when followed by sid
sl@0	828	r=repository->Get(201,retVal);
sl@0	829	TEST2(r,KErrPermissionDenied);
sl@0	830	r=repository->Set(201,retVal);
sl@0	831	TEST2(r,KErrNone);
sl@0	832
sl@0	833	//Test range policies with max 7 caps not with sid
sl@0	834	r=repository->Get(300,retVal);
sl@0	835	TEST2(r,KErrPermissionDenied);
sl@0	836	r=repository->Set(300,retVal);
sl@0	837	TEST2(r,KErrPermissionDenied);
sl@0	838
sl@0	839	//Test behaviour when single policies are specified with just sid
sl@0	840	r=repository->Get(400,retVal);
sl@0	841	TEST2(r,KErrNone);
sl@0	842	r=repository->Set(400,retVal);
sl@0	843	TEST2(r,KErrPermissionDenied); // default read cap for sid 0 is AlwaysFail
sl@0	844
sl@0	845	r=repository->Get(401,retVal);
sl@0	846	TEST2(r,KErrNone); // default write cap for sid 0 is AlwaysPass
sl@0	847	r=repository->Set(401,retVal);
sl@0	848	TEST2(r,KErrNone);
sl@0	849
sl@0	850	//Test that default policies are picked up when no policies are specified
sl@0	851	r=repository->Get(500,retVal);
sl@0	852	TEST2(r,KErrNone);
sl@0	853
sl@0	854	r=repository->Set(500,retVal);
sl@0	855	TEST2(r,KErrPermissionDenied);
sl@0	856
sl@0	857	CleanupStack::PopAndDestroy(repository);
sl@0	858	}
sl@0	859
sl@0	860	LOCAL_C void DEF057470L()
sl@0	861	{
sl@0	862
sl@0	863	TInt r=KErrNone;
sl@0	864	TUint32 errId=0;
sl@0	865	CRepository* repository;
sl@0	866
sl@0	867	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));
sl@0	868
sl@0	869	//-------------- 1. Simple Range Delete Operation-----------------------------
sl@0	870	// Confirm that keys exist
sl@0	871	RArray<TUint32> foundIds;
sl@0	872	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
sl@0	873	TEST2(r, KErrNone);
sl@0	874	TEST(foundIds.Count()==5);
sl@0	875	foundIds.Reset();
sl@0	876	// Delete a set of keys
sl@0	877	r = repository->Delete(KRangeDeletePartialKey, KRangeDeleteMask, errId) ;
sl@0	878	TEST2(r, KErrNone);
sl@0	879	// Confirm that deleted keys do not exist
sl@0	880	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
sl@0	881	TEST2(r, KErrNotFound);
sl@0	882	TEST(foundIds.Count()==0);
sl@0	883	foundIds.Reset();
sl@0	884	CleanupStack::PopAndDestroy(repository);
sl@0	885	// Try to find keys again just to double check whether the changes have persisted
sl@0	886	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));
sl@0	887	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
sl@0	888	TEST2(r, KErrNotFound);
sl@0	889	TEST(foundIds.Count()==0);
sl@0	890	foundIds.Reset();
sl@0	891
sl@0	892
sl@0	893	//--------------- 2. Range Delete Operation where keys don't exist--------------
sl@0	894	// Confirm that keys don't exist.
sl@0	895	r = repository->FindL(KDeleteKeyDoesntExist, KRangeDeleteMask, foundIds);
sl@0	896	TEST2(r, KErrNotFound);
sl@0	897	TEST(foundIds.Count()==0);
sl@0	898	foundIds.Reset();
sl@0	899	// Attempt delete and check result
sl@0	900	r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ;
sl@0	901	TEST2(r, KErrNotFound);
sl@0	902	errId &= KRangeDeleteMask ;
sl@0	903	TEST2(errId, KDeleteKeyDoesntExist) ;
sl@0	904
sl@0	905
sl@0	906	//-------3. Range Delete Operation where client doesn't have write capabilities for key range.----
sl@0	907	// Attempt delete and check result
sl@0	908	r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ;
sl@0	909	TEST2(r, KErrPermissionDenied);
sl@0	910	errId &= KRangeDeleteMask ;
sl@0	911	TEST2(errId, KDeleteForbidden) ;
sl@0	912	// Close repository
sl@0	913	CleanupStack::PopAndDestroy(repository);
sl@0	914
sl@0	915	//------ 4. Range Delete Operation which deletes all the keys and Resets the entire repository back its original state.
sl@0	916	TInt numberOfIds;
sl@0	917	User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository));
sl@0	918	// Find how many keys are originally present
sl@0	919	r = repository->FindL(KNullKey, KNullKey, foundIds);
sl@0	920	TEST2(r, KErrNone);
sl@0	921	numberOfIds = foundIds.Count();
sl@0	922	TEST(foundIds.Count()!=0);
sl@0	923	foundIds.Reset();
sl@0	924	// Range delete all the keys in the repository
sl@0	925	r = repository->Delete(KNullKey, KNullKey, errId);
sl@0	926	TEST2(r, KErrNone);
sl@0	927	// Check all the keys have been deleted from cache
sl@0	928	r = repository->FindL(KNullKey, KNullKey, foundIds);
sl@0	929	TEST2(r, KErrNotFound);
sl@0	930	TEST(foundIds.Count()==0);
sl@0	931	foundIds.Reset();
sl@0	932	// Close and re-open the repository to check if the deleted keys have persisted.
sl@0	933	CleanupStack::PopAndDestroy(repository);
sl@0	934	// Existance of caching functionality invalidates some tests and
sl@0	935	// makes them fail, so kill the server to force clearing the cache
sl@0	936	r = KillProcess(KCentralRepositoryServerName);
sl@0	937	TEST2(r,KErrNone);
sl@0	938	User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository));
sl@0	939	// Check all the deleted keys have persisted.
sl@0	940	r = repository->FindL(KNullKey, KNullKey, foundIds);
sl@0	941	TEST2(r, KErrNotFound);
sl@0	942	TEST(foundIds.Count()==0);
sl@0	943	foundIds.Reset();
sl@0	944	// Reset repository back to its original state from ROM
sl@0	945	r = repository->Reset();
sl@0	946	TEST2(r, KErrNone);
sl@0	947	// Check that number of keys is same as when we started.
sl@0	948	r = repository->FindL(KNullKey, KNullKey, foundIds);
sl@0	949	TEST2(r, KErrNone);
sl@0	950	TEST(foundIds.Count()==numberOfIds);
sl@0	951	foundIds.Reset();
sl@0	952	// Close the repository
sl@0	953	CleanupStack::PopAndDestroy(repository);
sl@0	954
sl@0	955	//********************Delete Range within Transacrions********************
sl@0	956	//--------- 5. Range Delete within a transaction where key's don't exist.------------
sl@0	957	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));
sl@0	958	// Begin read write transaction.
sl@0	959	r = repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	960	TEST2(r, KErrNone);
sl@0	961	r = TransactionState(repository);
sl@0	962	TEST2(r, EReadWriteTransaction);
sl@0	963	r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ;
sl@0	964	TEST2(r, KErrNotFound);
sl@0	965	// Check that transaction hasn't failed.
sl@0	966	r = TransactionState(repository);
sl@0	967	TEST2(r, EReadWriteTransaction);
sl@0	968	// Fail transaction.
sl@0	969	repository->FailTransaction();
sl@0	970	r = TransactionState(repository);
sl@0	971	TEST2(r, EReadWriteTransaction \| EFailedBit);
sl@0	972	repository->RollbackTransaction();
sl@0	973	r = TransactionState(repository);
sl@0	974	TEST2(r, ENoTransaction);
sl@0	975
sl@0	976
sl@0	977	//---------- 6. Range delete within a transaction where client doesn't have capabilities to write to key range.
sl@0	978	// Begin read write transaction.
sl@0	979	r = repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	980	TEST2(r, KErrNone);
sl@0	981	r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ;
sl@0	982	TEST2(r, KErrPermissionDenied);
sl@0	983	errId &= KRangeDeleteMask ;
sl@0	984	TEST2(errId, KDeleteForbidden) ;
sl@0	985	// check that transaction has failed.
sl@0	986	r = TransactionState(repository);
sl@0	987	TEST2(r, EReadWriteTransaction \| EFailedBit);
sl@0	988	// Rollback the failed transaction.
sl@0	989	repository->RollbackTransaction();
sl@0	990	r = TransactionState(repository);
sl@0	991	TEST2(r, ENoTransaction);
sl@0	992
sl@0	993
sl@0	994	//---------- 7. Range delete while not in transaction fails other session's transaction with KErrLocked.
sl@0	995	// Open another repository
sl@0	996	CRepository* repository2;
sl@0	997	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidDEF057470TestRepository));
sl@0	998	// Begin read write transaction
sl@0	999	r = repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	1000	TEST2(r, KErrNone);
sl@0	1001	r = TransactionState(repository);
sl@0	1002	TEST2(r, EReadWriteTransaction);
sl@0	1003	// Delete keys in the first session.
sl@0	1004	r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;
sl@0	1005	TEST2(r, KErrNone);
sl@0	1006	// Delete keys in the second session.
sl@0	1007	r = repository2->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;
sl@0	1008	TEST2(r, KErrNone);
sl@0	1009	// first session's transaction should have failed with KErrLocked
sl@0	1010	TInt state = TransactionState(repository);
sl@0	1011	TEST2(state, EReadWriteTransaction \| EFailedBit);
sl@0	1012	// Commit transaction should report failure reason:
sl@0	1013	TUint32 keyInfo;
sl@0	1014	r = repository->CommitTransaction(keyInfo);
sl@0	1015	TEST2(r, KErrLocked);
sl@0	1016	TEST(keyInfo == KUnspecifiedKey);
sl@0	1017	r = TransactionState(repository);
sl@0	1018	TEST2(r, ENoTransaction);
sl@0	1019	// Close the repositories
sl@0	1020	CleanupStack::PopAndDestroy(repository2);
sl@0	1021
sl@0	1022
sl@0	1023	//----------- 8. Range Delete within a Transaction and Commit.-----------------------
sl@0	1024	//Before doing this we need to reset from the ROM first to restore the deleted keys in
sl@0	1025	//non transaction test earlier
sl@0	1026	r=repository->Reset();
sl@0	1027	TEST2(r,KErrNone);
sl@0	1028	r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
sl@0	1029	TEST2(r,KErrNone);
sl@0	1030	TEST(foundIds.Count()==5);
sl@0	1031	foundIds.Reset();
sl@0	1032	// Begin read write transaction
sl@0	1033	r = repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	1034	TEST2(r, KErrNone);
sl@0	1035	r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;
sl@0	1036	TEST2(r, KErrNone);
sl@0	1037	// Commit transaction
sl@0	1038	r = repository->CommitTransaction(errId);
sl@0	1039	TEST2(r, KErrNone);
sl@0	1040	//The number of keys changed should be equal to the number of keys deleted
sl@0	1041	TEST(errId==5);
sl@0	1042
sl@0	1043	//Reset repository to remove any changes made during this test
sl@0	1044	r=repository->Reset();
sl@0	1045	TEST2(r, KErrNone);
sl@0	1046
sl@0	1047	// Close the repositories
sl@0	1048	CleanupStack::PopAndDestroy(repository);
sl@0	1049	}
sl@0	1050
sl@0	1051	LOCAL_C void INC058229L()
sl@0	1052	{
sl@0	1053	RFs fs;
sl@0	1054	User::LeaveIfError(fs.Connect());
sl@0	1055	CleanupClosePushL(fs);
sl@0	1056
sl@0	1057	CFileMan* fm = CFileMan::NewL(fs);
sl@0	1058	CleanupStack::PushL(fm);
sl@0	1059
sl@0	1060	// Open repository to ensure server is running
sl@0	1061	CRepository* rep;
sl@0	1062	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
sl@0	1063	// Close repository
sl@0	1064	CleanupStack::PopAndDestroy(rep);
sl@0	1065
sl@0	1066	// Remove install dir
sl@0	1067	TInt r = fm->RmDir(KCInstallDir);
sl@0	1068	if(r!=KErrNone && r!=KErrNotFound && r!=KErrPathNotFound)
sl@0	1069	User::Leave(r);
sl@0	1070	// Wait so that watcher will see directory is gone
sl@0	1071	User::After(KGeneralDelay);
sl@0	1072
sl@0	1073	// Kill server so that next test will reconnect and recreate resources
sl@0	1074	r=KillProcess(KCentralRepositoryServerName);
sl@0	1075	TEST2(r,KErrNone);
sl@0	1076
sl@0	1077	// Open repository to ensure directories are restored
sl@0	1078	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
sl@0	1079	// Close repository
sl@0	1080	CleanupStack::PopAndDestroy(3); // rep, fs, fm
sl@0	1081	}
sl@0	1082
sl@0	1083	LOCAL_C void DEF058900L()
sl@0	1084	{
sl@0	1085
sl@0	1086	CRepository* repository;
sl@0	1087	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF058900TestRepository));
sl@0	1088	TRequestStatus intStatus;
sl@0	1089	RThread thisThread;
sl@0	1090
sl@0	1091	//
sl@0	1092	// Basic notification to test notification for one banned key
sl@0	1093	//
sl@0	1094	TInt r = repository->NotifyRequest(KNotifyBannedKey, intStatus);
sl@0	1095	TEST2(r, KErrNone);
sl@0	1096	TEST(intStatus == KRequestPending);
sl@0	1097
sl@0	1098	// First change to setting should cause notification
sl@0	1099	r = repository->Set(KNotifyBannedKey, 100);
sl@0	1100	TEST2(r, KErrNone);
sl@0	1101	User::WaitForAnyRequest();
sl@0	1102	TEST(intStatus==KUnspecifiedKey);
sl@0	1103
sl@0	1104	//
sl@0	1105	// Group notification to test notification when the banned key is in a range
sl@0	1106	//
sl@0	1107	r = repository->NotifyRequest(KNullKey, KNullKey, intStatus);
sl@0	1108	TEST2(r, KErrNone);
sl@0	1109
sl@0	1110	r = repository->Set(KNotifyBannedKey, 50);
sl@0	1111	TEST2(r, KErrNone);
sl@0	1112	User::WaitForAnyRequest();
sl@0	1113	TEST(intStatus==KUnspecifiedKey);
sl@0	1114	TEST(thisThread.RequestCount()==0);
sl@0	1115
sl@0	1116	//
sl@0	1117	// Group notification to test notification when many keys including the banned key change
sl@0	1118	// i.e. a repository wide reset
sl@0	1119	//
sl@0	1120	// First change values for alot of the keys before a reset.
sl@0	1121	r = repository->Set(KNotificationKey1, 80);
sl@0	1122	TEST2(r, KErrNone);
sl@0	1123	r = repository->Set(KNotifyBannedKey, 50);
sl@0	1124	TEST2(r, KErrNone);
sl@0	1125	r = repository->Set(KNotificationKey2, 70);
sl@0	1126	TEST2(r, KErrNone);
sl@0	1127	r = repository->Set(KNotificationKey3, 60);
sl@0	1128	TEST2(r, KErrNone);
sl@0	1129	r = repository->Set(KNotificationKey4, 30);
sl@0	1130	TEST2(r, KErrNone);
sl@0	1131
sl@0	1132	r = repository->NotifyRequest(KNullKey, KNullKey, intStatus); // Request notification
sl@0	1133	// for all keys in repository.
sl@0	1134	TEST2(r, KErrNone);
sl@0	1135
sl@0	1136	//Reset the whole repository to original settings
sl@0	1137	r = repository->Reset();
sl@0	1138	TEST2(r, KErrNone);
sl@0	1139
sl@0	1140	User::WaitForAnyRequest();
sl@0	1141	TEST(intStatus==KUnspecifiedKey);
sl@0	1142	TEST(thisThread.RequestCount()==0);
sl@0	1143
sl@0	1144
sl@0	1145	CleanupStack::PopAndDestroy(repository);
sl@0	1146	}
sl@0	1147
sl@0	1148	LOCAL_C void DEF061087L()
sl@0	1149	{
sl@0	1150	TInt r=KErrNone;
sl@0	1151	TUid testUid={0x10061087};
sl@0	1152	CRepository* repository;
sl@0	1153	User::LeaveIfNull(repository = CRepository::NewLC(testUid));
sl@0	1154
sl@0	1155	/*--------------Scenario 1---------------------
sl@0	1156	100 300 cap_wr=ReadDeviceData
sl@0	1157	100 200 cap_wr=TCB */
sl@0	1158	r=repository->Create(150,100);
sl@0	1159	TEST2(r,KErrPermissionDenied);
sl@0	1160	r=repository->Create(201,201);
sl@0	1161	TEST2(r,KErrNone);
sl@0	1162
sl@0	1163	/*--------------Scenario 2---------------------
sl@0	1164	400 500 cap_wr=ReadDeviceData
sl@0	1165	400 500 cap_wr=TCB */
sl@0	1166	r=repository->Create(500,100);
sl@0	1167	TEST2(r,KErrPermissionDenied);
sl@0	1168
sl@0	1169	/*--------------Scenario 3---------------------
sl@0	1170	0x600 0x700 cap_wr=ReadDeviceData
sl@0	1171	# Odd entry from 600-700
sl@0	1172	0x601 mask=0xF01 cap_wr=TCB*/
sl@0	1173	r=repository->Create(0x601,601);
sl@0	1174	TEST2(r,KErrPermissionDenied);
sl@0	1175	r=repository->Create(0x657,647);
sl@0	1176	TEST2(r,KErrPermissionDenied);
sl@0	1177	//0x602 will be even so it will check agains the next matched range policies
sl@0	1178	//which is 0x600 0x700 cap_wr=ReadDeviceData
sl@0	1179	r=repository->Create(0x602,600);
sl@0	1180	TEST2(r,KErrNone);
sl@0	1181
sl@0	1182	/*--------------Scenario 4---------------------
sl@0	1183	# protected data
sl@0	1184	0x00000100 mask=0x00000100 cap_wr=NetworkControl
sl@0	1185	# private data
sl@0	1186	0x000000F0 mask=0x00000080 cap_rd=ReadDeviceData */
sl@0	1187	r=repository->Create(0x01000100,123);
sl@0	1188	TEST2(r,KErrPermissionDenied);
sl@0	1189	r=repository->Create(0x03450700,123);
sl@0	1190	TEST2(r,KErrPermissionDenied);
sl@0	1191	r=repository->Create(0x00450080,123);
sl@0	1192	TEST2(r,KErrNone);
sl@0	1193	r=repository->Create(0x06450081,123);
sl@0	1194	TEST2(r,KErrNone);
sl@0	1195
sl@0	1196
sl@0	1197	CleanupStack::PopAndDestroy(repository);
sl@0	1198	}
sl@0	1199
sl@0	1200
sl@0	1201	LOCAL_C void DEF060843L()
sl@0	1202	{
sl@0	1203	CRepository* repository;
sl@0	1204	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
sl@0	1205
sl@0	1206	_LIT8(KString12_InitialValue, "string");
sl@0	1207	TPtrC8 p8(KString12_InitialValue);
sl@0	1208	TInt len8 = p8.Length();
sl@0	1209
sl@0	1210	_LIT(KString11_InitialValue, "string");
sl@0	1211	TPtrC p16(KString11_InitialValue);
sl@0	1212	TInt len16 = p16.Length();
sl@0	1213
sl@0	1214	//setting ids in a test repository
sl@0	1215	const TUint32 KReal1 = 2;
sl@0	1216	const TUint32 KString11 = 11;
sl@0	1217	const TUint32 KString12 = 12;
sl@0	1218
sl@0	1219	TInt r;
sl@0	1220	TInt i(0);
sl@0	1221
sl@0	1222	TBuf<15> str;
sl@0	1223	TInt strLen;
sl@0	1224
sl@0	1225	TBuf8<15> str8;
sl@0	1226	TInt strLen8;
sl@0	1227
sl@0	1228	//================read real using int ========================
sl@0	1229	r = repository->Get(KReal1, i);
sl@0	1230	TEST2(r, KErrArgument);
sl@0	1231	TEST(i==0);
sl@0	1232
sl@0	1233	//================read TDes16 using TDes8=====================
sl@0	1234	r = repository->Get(KString11, str8);
sl@0	1235	TEST2(r, KErrNone);
sl@0	1236
sl@0	1237	//8-bit descriptor holding the same data as 16-bit descriptor
sl@0	1238	//should twice as long as 16-bit des.
sl@0	1239	strLen8 = str8.Length();
sl@0	1240	TEST2(strLen8,len16*2);
sl@0	1241
sl@0	1242	const TUint16* p16a = (TUint16*)str8.Ptr();
sl@0	1243	const TUint16* p16b = p16.Ptr();
sl@0	1244	//compares content of descriptors byte by byte
sl@0	1245	r = Mem::Compare(p16a,strLen8/2,p16b,len16);
sl@0	1246	TEST2(r,KErrNone);
sl@0	1247
sl@0	1248	//=================read TDes8 using TDes16=====================
sl@0	1249	r = repository->Get(KString12, str);
sl@0	1250	TEST2(r, KErrNone);
sl@0	1251
sl@0	1252	//16-bit descriptor holding the same data as 8-bit descriptor
sl@0	1253	//should be half a length of a 8-bit desc
sl@0	1254	strLen = str.Length();
sl@0	1255	TEST2(strLen,len8/2);
sl@0	1256
sl@0	1257	const TUint8* p8a = (TUint8*)str.Ptr();
sl@0	1258	const TUint8* p8b = p8.Ptr();
sl@0	1259	//compares content of descriptors byte by byte
sl@0	1260	r = Mem::Compare(p8a,strLen*2,p8b,len8);
sl@0	1261	TEST2(r,KErrNone);
sl@0	1262
sl@0	1263	//================writting to TDes16 using TDes8===============
sl@0	1264	r = repository->Set(KString11,KString12_InitialValue);
sl@0	1265	TEST2(r, KErrNone);
sl@0	1266	CleanupStack::PopAndDestroy(repository);
sl@0	1267	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
sl@0	1268	r = repository->Get(KString11, str8);
sl@0	1269	strLen8 = str8.Length();
sl@0	1270	TEST2(strLen8,len8);
sl@0	1271	TEST(str8==KString12_InitialValue);
sl@0	1272
sl@0	1273	//================writting to TDes8 using TDes16===============
sl@0	1274	r = repository->Set(KString12,KString11_InitialValue);
sl@0	1275	TEST2(r, KErrNone);
sl@0	1276	CleanupStack::PopAndDestroy(repository);
sl@0	1277	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
sl@0	1278	r = repository->Get(KString12, str);
sl@0	1279	strLen = str.Length();
sl@0	1280	TEST2(strLen,len16);
sl@0	1281	TEST(str==KString11_InitialValue);
sl@0	1282	CleanupStack::PopAndDestroy(repository);
sl@0	1283	}
sl@0	1284
sl@0	1285	/**
sl@0	1286	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1433
sl@0	1287	@SYMTestCaseDesc Central repository panics the client when trying to read 8-bit descriptor with uneven length
sl@0	1288	@SYMTestPriority High
sl@0	1289	@SYMTestActions Read 8-bit descriptor with uneven length
sl@0	1290	@SYMTestExpectedResults The test must not fail or panic .
sl@0	1291	@SYMDEF INC069013
sl@0	1292	*/
sl@0	1293	LOCAL_C void INC069013L()
sl@0	1294	{
sl@0	1295	CRepository* repository;
sl@0	1296	User::LeaveIfNull(repository = CRepository::NewLC(KUidINC069013TestRepository));
sl@0	1297
sl@0	1298	_LIT(KString16, "16BitString");
sl@0	1299	_LIT8(KString8Odd, "8BitOddString");
sl@0	1300	_LIT8(KString8Even, "8BitEvenString");
sl@0	1301
sl@0	1302	const TUint32 KString16ID = 1;
sl@0	1303	const TUint32 KString8OddID = 2;
sl@0	1304	const TUint32 KString8EvenID = 3;
sl@0	1305
sl@0	1306	TBuf<20> buf;
sl@0	1307	TInt r = KErrNone;
sl@0	1308	TInt actualLength = 0;
sl@0	1309
sl@0	1310	//test for string stored as 16 bit
sl@0	1311	r = repository->Get(KString16ID, buf);
sl@0	1312	TEST2(r, KErrNone);
sl@0	1313
sl@0	1314	r = repository->Get(KString16ID, buf, actualLength);
sl@0	1315	TEST2(r, KErrNone);
sl@0	1316	TEST2(actualLength, KString16().Length());
sl@0	1317
sl@0	1318	//test for string stored as 8 bit with odd length
sl@0	1319	r = repository->Get(KString8OddID, buf);
sl@0	1320	TEST2(r, KErrNone);
sl@0	1321
sl@0	1322	r = repository->Get(KString8OddID, buf, actualLength);
sl@0	1323	TEST2(r, KErrNone);
sl@0	1324	TEST2(actualLength, (KString8Odd().Length() + 1) / 2);
sl@0	1325
sl@0	1326	//test for string stored as 8 bit with even length
sl@0	1327	r = repository->Get(KString8EvenID, buf);
sl@0	1328	TEST2(r, KErrNone);
sl@0	1329
sl@0	1330	r = repository->Get(KString8EvenID, buf, actualLength);
sl@0	1331	TEST2(r, KErrNone);
sl@0	1332	TEST2(actualLength, (KString8Even().Length() + 1) / 2);
sl@0	1333
sl@0	1334	CleanupStack::PopAndDestroy(repository);
sl@0	1335	}
sl@0	1336
sl@0	1337	/**
sl@0	1338	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1434
sl@0	1339	@SYMTestCaseDesc Central repository doesn't handle corrupt .cre files correctly.
sl@0	1340	@SYMTestPriority High
sl@0	1341	@SYMTestActions Open corrupt files from ROM and persists
sl@0	1342	@SYMTestExpectedResults The test must not fail.
sl@0	1343	@SYMDEF DEF070731
sl@0	1344	*/
sl@0	1345	const TUid KUidCorruptEOF = { 0x00000e0f };
sl@0	1346	const TUid KUidCorrupt = { 0x00000bad };
sl@0	1347
sl@0	1348	_LIT(KCRep1File, "c:\\private\\10202BE9\\persists\\00000100.cre");
sl@0	1349	_LIT(KZCorruptEOFFile, "z:\\private\\10202BE9\\00000e0f.cre");
sl@0	1350	_LIT(KZCorruptFile, "z:\\private\\10202BE9\\00000bad.cre");
sl@0	1351
sl@0	1352	LOCAL_C void DEF070731L()
sl@0	1353	{
sl@0	1354	RFs fs;
sl@0	1355	User::LeaveIfError(fs.Connect());
sl@0	1356	CleanupClosePushL(fs);
sl@0	1357
sl@0	1358	CFileMan* fm = CFileMan::NewL(fs);
sl@0	1359	CleanupStack::PushL(fm);
sl@0	1360
sl@0	1361	CRepository* rep;
sl@0	1362
sl@0	1363	// Open ROM cre file with EOF corruption
sl@0	1364	TheTest.Printf(_L("\nOpen ROM cre file with EOF corruption\n"));
sl@0	1365	TRAPD(errH, rep=CRepository::NewLC(KUidCorruptEOF));
sl@0	1366	TEST2(errH, KErrCorrupt);
sl@0	1367
sl@0	1368	// Open corrupt ROM file
sl@0	1369	TheTest.Printf(_L("\nOpen corrupt ROM file\n"));
sl@0	1370	TRAPD(errS,rep=CRepository::NewLC(KUidCorrupt));
sl@0	1371	TEST2(errS, KErrCorrupt);
sl@0	1372
sl@0	1373	// Edit repos with new setting
sl@0	1374	TheTest.Printf(_L("\nEdit repos with new setting\n"));
sl@0	1375	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
sl@0	1376	TInt r = rep->Create(KNewInt, KIntValue);
sl@0	1377	TEST2(r, KErrNone);
sl@0	1378	CleanupStack::PopAndDestroy(rep);
sl@0	1379
sl@0	1380	// Reopen repos to read from persists file
sl@0	1381	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
sl@0	1382	TInt newInt;
sl@0	1383	r=rep->Get(KNewInt, newInt);
sl@0	1384	TEST2(r, KErrNone);
sl@0	1385	CleanupStack::PopAndDestroy(rep);
sl@0	1386
sl@0	1387	// Existance of caching functionality invalidates some tests and
sl@0	1388	// makes them fail, so kill the server to force clearing the cache
sl@0	1389	r=KillProcess(KCentralRepositoryServerName);
sl@0	1390	TEST2(r,KErrNone);
sl@0	1391
sl@0	1392	// Copy corrupt EOF file into persists
sl@0	1393	TheTest.Printf(_L("\nCopy corrupt EOF file into persists dir\n"));
sl@0	1394	User::LeaveIfError(fm->Copy(KZCorruptEOFFile, KCRep1File));
sl@0	1395	// Reset read-only bit
sl@0	1396	User::LeaveIfError(fm->Attribs(KCRep1File,0,KEntryAttReadOnly,TTime(0)));
sl@0	1397	User::After(KGeneralDelay);
sl@0	1398	// Open repos, should find corrupt file and use ROM file
sl@0	1399	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
sl@0	1400	// If we can't find KNewInt, this proves that we are using ROM file
sl@0	1401	r=rep->Get(KNewInt, newInt);
sl@0	1402	TEST2(r, KErrNotFound);
sl@0	1403	// Test that persists file is deleted
sl@0	1404	TheTest.Printf(_L("\nCheck corrupt EOF file deleted from persists dir\n"));
sl@0	1405	TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse);
sl@0	1406	// Close repository
sl@0	1407	CleanupStack::PopAndDestroy(rep);
sl@0	1408
sl@0	1409	// Existance of caching functionality invalidates some tests and
sl@0	1410	// makes them fail, so kill the server to force clearing the cache
sl@0	1411	r=KillProcess(KCentralRepositoryServerName);
sl@0	1412	TEST2(r,KErrNone);
sl@0	1413
sl@0	1414	// Copy corrupt file into persists
sl@0	1415	TheTest.Printf(_L("\nCopy corrupt file into persists dir\n"));
sl@0	1416	User::LeaveIfError(fm->Copy(KZCorruptFile, KCRep1File));
sl@0	1417	// Reset read-only bit
sl@0	1418	User::LeaveIfError(fm->Attribs(KCRep1File,0,KEntryAttReadOnly,TTime(0)));
sl@0	1419	User::After(KGeneralDelay);
sl@0	1420	// Open repos, should find corrupt file and use ROM file
sl@0	1421	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
sl@0	1422	// Test that file is deleted
sl@0	1423	TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n"));
sl@0	1424	TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse);
sl@0	1425
sl@0	1426	// Close repository
sl@0	1427	CleanupStack::PopAndDestroy(3);// rep, fs,fm
sl@0	1428
sl@0	1429	}
sl@0	1430
sl@0	1431	// Helper function for DEF084700L
sl@0	1432	LOCAL_C void ConnectAndCommitSuicideL(void)
sl@0	1433	{
sl@0	1434	CRepository* repository;
sl@0	1435	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
sl@0	1436
sl@0	1437	RThread currentThread;
sl@0	1438	currentThread.Kill(KErrDied);
sl@0	1439
sl@0	1440	// Should never get executed
sl@0	1441	CleanupStack::PopAndDestroy(repository);
sl@0	1442	}
sl@0	1443
sl@0	1444	// Helper function for DEF084700L
sl@0	1445	LOCAL_C TInt SuicidalThread(TAny*)
sl@0	1446	{
sl@0	1447	CTrapCleanup* cleanup = CTrapCleanup::New();
sl@0	1448	if(!cleanup)
sl@0	1449	return KErrNoMemory;
sl@0	1450
sl@0	1451	TRAP_IGNORE(ConnectAndCommitSuicideL());
sl@0	1452
sl@0	1453	// Should never get executed
sl@0	1454	delete cleanup;
sl@0	1455	return KErrNone;
sl@0	1456	}
sl@0	1457
sl@0	1458	// Helper function for DEF084700L
sl@0	1459	LOCAL_C void ConnectAndDisconnectL(void)
sl@0	1460	{
sl@0	1461	CRepository* repository;
sl@0	1462	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
sl@0	1463
sl@0	1464	CleanupStack::PopAndDestroy(repository);
sl@0	1465	}
sl@0	1466
sl@0	1467	// Helper function for DEF084700L
sl@0	1468	LOCAL_C TInt WellBehavedThread(TAny*)
sl@0	1469	{
sl@0	1470	CTrapCleanup* cleanup = CTrapCleanup::New();
sl@0	1471	if(!cleanup)
sl@0	1472	return KErrNoMemory;
sl@0	1473
sl@0	1474	TRAP_IGNORE(ConnectAndDisconnectL());
sl@0	1475
sl@0	1476	delete cleanup;
sl@0	1477	return KErrNone;
sl@0	1478	}
sl@0	1479
sl@0	1480	/**
sl@0	1481	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1683
sl@0	1482	@SYMTestCaseDesc UIF automated tests crash H4 board
sl@0	1483	@SYMTestPriority High
sl@0	1484	@SYMTestActions Open a repository, create a thread, open same repository from that thread, kill the thread
sl@0	1485	before closing repository, update a setting from main body (trigger notifications). Do the same
sl@0	1486	thing for a thread which terminates normally for making sure the previous behaviour is maintained
sl@0	1487	@SYMTestExpectedResults The test must not panic or fail.
sl@0	1488	@SYMDEF DEF084700
sl@0	1489	*/
sl@0	1490	LOCAL_C void DEF084700L()
sl@0	1491	{
sl@0	1492	CRepository* repository;
sl@0	1493	User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
sl@0	1494
sl@0	1495	RThread testThread;
sl@0	1496	_LIT(KThreadName1, "SuicidalTestThread");
sl@0	1497
sl@0	1498	testThread.Create(KThreadName1, SuicidalThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);
sl@0	1499
sl@0	1500	TRequestStatus requestStatus;
sl@0	1501	// Request notification when the thread kills itself
sl@0	1502	testThread.Logon(requestStatus);
sl@0	1503	// Let the thread execute
sl@0	1504	testThread.Resume();
sl@0	1505
sl@0	1506	// Wait for suicide
sl@0	1507	User::WaitForRequest(requestStatus);
sl@0	1508	// Make sure it's dead
sl@0	1509	TEST2(requestStatus.Int(), KErrDied);
sl@0	1510
sl@0	1511	const TUint32 KInt1 = 0x1;
sl@0	1512	TInt i, r = KErrNone;
sl@0	1513
sl@0	1514	r = repository->Get(KInt1, i);
sl@0	1515	TEST2(r, KErrNone);
sl@0	1516	r = repository->Set(KInt1, i+1);
sl@0	1517	// Fails here with KErrServerTerminated before fix because server crashes
sl@0	1518	TEST2(r, KErrNone);
sl@0	1519
sl@0	1520	// Create another thread which accesses the repository but terminates normally
sl@0	1521	_LIT(KThreadName2, "WellBehavedTestThread");
sl@0	1522
sl@0	1523	testThread.Create(KThreadName2, WellBehavedThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);
sl@0	1524
sl@0	1525	// Request notification when the thread terminates normally
sl@0	1526	testThread.Logon(requestStatus);
sl@0	1527	// Let the thread execute
sl@0	1528	testThread.Resume();
sl@0	1529
sl@0	1530	// Wait for old age
sl@0	1531	User::WaitForRequest(requestStatus);
sl@0	1532	// Make sure the cause of death is natural
sl@0	1533	TEST2(requestStatus.Int(), KErrNone);
sl@0	1534
sl@0	1535	r = repository->Get(KInt1, i);
sl@0	1536	TEST2(r, KErrNone);
sl@0	1537	r = repository->Set(KInt1, i+1);
sl@0	1538
sl@0	1539	TEST2(r, KErrNone);
sl@0	1540
sl@0	1541	//Reset repository to remove any changes made during this test
sl@0	1542	r = repository->Reset();
sl@0	1543	TEST2(r, KErrNone);
sl@0	1544
sl@0	1545	CleanupStack::PopAndDestroy(repository);
sl@0	1546	}
sl@0	1547
sl@0	1548	/**
sl@0	1549	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1862
sl@0	1550	@SYMTestCaseDesc [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM
sl@0	1551	@SYMTestPriority High
sl@0	1552	@SYMTestActions Open a repository, start a transaction, then simulate a OOM failure in a TRAPPED
sl@0	1553	FindL, this will result in client side error and this error should be the returned
sl@0	1554	error of CommitTransaction.
sl@0	1555	@SYMTestExpectedResults The test must not panic or fail.
sl@0	1556	@SYMDEF DEF089945
sl@0	1557	*/
sl@0	1558	LOCAL_C void DEF089945L()
sl@0	1559	{
sl@0	1560	TInt err=KErrNone;
sl@0	1561	const TUid testUid={0x10057145};
sl@0	1562	RArray<TUint32> idArray;
sl@0	1563
sl@0	1564	CRepository* repository;
sl@0	1565	User::LeaveIfNull(repository = CRepository::NewLC(testUid));
sl@0	1566
sl@0	1567	//-----------SIMULATE CLIENT SIDE TRANSACTION ERROR------------------------------
sl@0	1568	err=repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	1569	TEST2(err,KErrNone);
sl@0	1570
sl@0	1571	//set the next allocation to fail in the FindL method
sl@0	1572	__UHEAP_FAILNEXT(1);
sl@0	1573	TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray));
sl@0	1574	__UHEAP_TOTAL_RESET;
sl@0	1575	//uheap failure only happens in debug build
sl@0	1576	#ifdef _DEBUG
sl@0	1577	TEST2(err,KErrNoMemory);
sl@0	1578	#else
sl@0	1579	TEST2(err,KErrNone);
sl@0	1580	#endif
sl@0	1581
sl@0	1582	TUint32 errId;
sl@0	1583	//ensure that the returned code from Commit is same as the last failure error in client
sl@0	1584	err=repository->CommitTransaction(errId);
sl@0	1585	#ifdef _DEBUG
sl@0	1586	TEST2(err,KErrNoMemory);
sl@0	1587	TEST2(errId,KUnspecifiedKey);
sl@0	1588	#else
sl@0	1589	TEST2(err,KErrNone);
sl@0	1590	#endif
sl@0	1591	idArray.Reset();
sl@0	1592
sl@0	1593	//----------SIMULATE CLIENT SIDE TRANSACTION ERROR FOLLOWED BY ADDITIONAL OPERATION-----
sl@0	1594	err=repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	1595	TEST2(err,KErrNone);
sl@0	1596	//set the next allocation to fail in the FindL method
sl@0	1597	__UHEAP_FAILNEXT(1);
sl@0	1598	TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray));
sl@0	1599	__UHEAP_TOTAL_RESET;
sl@0	1600	#ifdef _DEBUG
sl@0	1601	TEST2(err,KErrNoMemory);
sl@0	1602	#else
sl@0	1603	TEST2(err,KErrNone);
sl@0	1604	#endif
sl@0	1605
sl@0	1606	//now try to execute another operation following the failure
sl@0	1607	TReal realValue;
sl@0	1608	err=repository->Set(1,realValue);
sl@0	1609	#ifdef _DEBUG
sl@0	1610	TEST2(err,KErrAbort);
sl@0	1611	#else
sl@0	1612	TEST2(err,KErrArgument);
sl@0	1613	#endif
sl@0	1614
sl@0	1615	err=repository->CommitTransaction(errId);
sl@0	1616	//confirms that the error returned is the last failure in client side
sl@0	1617	#ifdef _DEBUG
sl@0	1618	TEST2(err,KErrNoMemory);
sl@0	1619	TEST2(errId,KUnspecifiedKey);
sl@0	1620	#else
sl@0	1621	TEST2(err,KErrArgument);
sl@0	1622	#endif
sl@0	1623	idArray.Reset();
sl@0	1624
sl@0	1625	//---------SIMULATE SERVER SIDE ERROR FOLLOWED BY CLIENT SIDE ERROR-------------------
sl@0	1626	err=repository->StartTransaction(CRepository::EReadWriteTransaction);
sl@0	1627	TEST2(err,KErrNone);
sl@0	1628
sl@0	1629	//server error
sl@0	1630	err=repository->Set(1,realValue);
sl@0	1631	TEST2(err,KErrArgument);
sl@0	1632
sl@0	1633	//client error
sl@0	1634	__UHEAP_FAILNEXT(1);
sl@0	1635	TInt ret=KErrNone;
sl@0	1636	TRAP(err,ret=repository->FindL(1,0xFFFFFFFF,idArray));
sl@0	1637	__UHEAP_TOTAL_RESET;
sl@0	1638	TEST2(ret,KErrAbort);
sl@0	1639
sl@0	1640	err=repository->CommitTransaction(errId);
sl@0	1641	//confirms that the error returned is the last failure in server side
sl@0	1642	TEST2(err,KErrArgument);
sl@0	1643	TEST2(errId,1);
sl@0	1644	idArray.Reset();
sl@0	1645
sl@0	1646	//clean up stuff
sl@0	1647	idArray.Close();
sl@0	1648	CleanupStack::PopAndDestroy(repository);
sl@0	1649	}
sl@0	1650
sl@0	1651	/**
sl@0	1652	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3242
sl@0	1653	@SYMTestCaseDesc Memory card: Backup to memory card causes phone freeze.
sl@0	1654	@SYMTestPriority High
sl@0	1655	@SYMTestActions Open a repository with a corrupt ini file and check that
sl@0	1656	the call to CRepository::NewLC leaves with KErrCorrupt and does not panic.
sl@0	1657	@SYMTestExpectedResults The call to CRepository::NewLC should return with KErrCorrupt and
sl@0	1658	the test must not panic or fail.
sl@0	1659	@SYMDEF PDEF098500
sl@0	1660	*/
sl@0	1661	LOCAL_C void PDEF098500()
sl@0	1662	{
sl@0	1663	CRepository* repository = NULL;
sl@0	1664
sl@0	1665	TRAPD(err,repository = CRepository::NewLC(KUidPDEF098500LRepository));
sl@0	1666
sl@0	1667	//We expect the above call to leave with KErrCorrupt so repository should be NULL
sl@0	1668	TEST(repository == NULL);
sl@0	1669	TEST2(err, KErrCorrupt);
sl@0	1670
sl@0	1671	//No PopAndDestroy required as above call is expected to leave
sl@0	1672
sl@0	1673	}
sl@0	1674
sl@0	1675	/**
sl@0	1676	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1884
sl@0	1677	@SYMTestCaseDesc DEF093855: CenRep cancels transactions if they exceed 5 seconds...
sl@0	1678	@SYMTestPriority High
sl@0	1679	@SYMTestActions Open a repository, start a transaction, then wait more than default cache timeout
sl@0	1680	to let the normal eviction clean out the cache, call a function to reload the repository,
sl@0	1681	check that the transaction is still valid, rollback the transaction to check the
sl@0	1682	repository unload/reload during an open transaction doesn't cause a panic when transaction is rolled back.
sl@0	1683	@SYMTestExpectedResults The test must not panic or fail.
sl@0	1684	@SYMDEF DEF093855
sl@0	1685	*/
sl@0	1686	LOCAL_C void DEF093855L()
sl@0	1687	{
sl@0	1688	TInt err=KErrNone;
sl@0	1689
sl@0	1690	// make sure no items are in the cache
sl@0	1691	KillProcess(KCentralRepositoryServerName);
sl@0	1692
sl@0	1693	// connect
sl@0	1694	CRepository* repository;
sl@0	1695	User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1));
sl@0	1696
sl@0	1697	// Begin concurrent read write transaction
sl@0	1698	err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
sl@0	1699	TEST2(err, KErrNone);
sl@0	1700
sl@0	1701	TInt val;
sl@0	1702	const TInt KIntTestValue = 10;
sl@0	1703	// get test value, make sure it is KIntTestValue
sl@0	1704	err = repository->Get(0x02010100,val);
sl@0	1705	TEST2(err, KErrNone);
sl@0	1706	TEST2(val, KIntTestValue);
sl@0	1707
sl@0	1708	// change the value in transaction
sl@0	1709	TInt r = repository->Set(0x02010100, KIntValue);
sl@0	1710	TEST2(r, KErrNone);
sl@0	1711
sl@0	1712	// wait for the repository to be removed from memory
sl@0	1713	CleanupRepositoryCache();
sl@0	1714
sl@0	1715	// check that the transaction is not aborted, still in memory and keeps the value set during the transaction
sl@0	1716	err = repository->Get(0x02010100,val);
sl@0	1717	TEST2(err, KErrNone);
sl@0	1718	TEST2(val, KIntValue);
sl@0	1719
sl@0	1720	// rollback to check if RollbackTransaction works, and to reset the value to KIntTestValue
sl@0	1721	repository->RollbackTransaction();
sl@0	1722
sl@0	1723	// Begin another transaction
sl@0	1724	err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
sl@0	1725	TEST2(err, KErrNone);
sl@0	1726
sl@0	1727	// get test value, make sure it is still KIntTestValue (successfully rolled back)
sl@0	1728	err = repository->Get(0x02010100,val);
sl@0	1729	TEST2(err, KErrNone);
sl@0	1730	TEST2(val, KIntTestValue);
sl@0	1731
sl@0	1732	// change the value in transaction
sl@0	1733	r = repository->Set(0x02010100, KIntValue);
sl@0	1734	TEST2(r, KErrNone);
sl@0	1735
sl@0	1736	// wait for the repository to be removed from memory
sl@0	1737	CleanupRepositoryCache();
sl@0	1738
sl@0	1739	// check that the transaction is not aborted, still in memory and keeps the value set during the transaction
sl@0	1740	err = repository->Get(0x02010100,val);
sl@0	1741	TEST2(err, KErrNone);
sl@0	1742	TEST2(val, KIntValue);
sl@0	1743
sl@0	1744	// commit to check if CommitTransaction works
sl@0	1745	TUint32 keyInfo;
sl@0	1746	repository->CommitTransaction(keyInfo);
sl@0	1747	TEST2(err, KErrNone);
sl@0	1748	TEST2(keyInfo, 1);
sl@0	1749
sl@0	1750	// check that the value is set during the transaction (in shared rep settings)
sl@0	1751	err = repository->Get(0x02010100,val);
sl@0	1752	TEST2(err, KErrNone);
sl@0	1753	TEST2(val, KIntValue);
sl@0	1754
sl@0	1755	// close repository
sl@0	1756	CleanupStack::PopAndDestroy(repository);
sl@0	1757
sl@0	1758	// make sure the repository is unloaded from cache
sl@0	1759	KillProcess(KCentralRepositoryServerName);
sl@0	1760
sl@0	1761	// reopen the repository
sl@0	1762	User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1));
sl@0	1763
sl@0	1764	// get test value, to check if it had been successfully persisted
sl@0	1765	err = repository->Get(0x02010100,val);
sl@0	1766	TEST2(err, KErrNone);
sl@0	1767	TEST2(val, KIntValue);
sl@0	1768
sl@0	1769	// reset the setting back to the original value
sl@0	1770	r = repository->Set(0x02010100, KIntTestValue);
sl@0	1771	TEST2(r, KErrNone);
sl@0	1772
sl@0	1773	//Reset repository to remove any changes made during this test
sl@0	1774	r = repository->Reset();
sl@0	1775	TEST2(r, KErrNone);
sl@0	1776
sl@0	1777	// close repository
sl@0	1778	CleanupStack::PopAndDestroy(repository);
sl@0	1779	}
sl@0	1780
sl@0	1781	/**
sl@0	1782	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3477
sl@0	1783	@SYMTestCaseDesc PDEF106507: Central repository doesn't handle corruption of the installdir.bin file properly
sl@0	1784	@SYMTestPriority High
sl@0	1785	@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.
sl@0	1786	@SYMTestExpectedResults The Server should not panic when trying to read the corrupt file, and should return KErrNone
sl@0	1787	@SYMDEF PDEF106507
sl@0	1788	*/
sl@0	1789	LOCAL_C void PDEF106507L()
sl@0	1790	{
sl@0	1791	_LIT(KInstallDirFile, "C:\\private\\10202be9\\persists\\installdir.bin");
sl@0	1792	_LIT(KInstallDirFileBad1, "Z:\\private\\10202be9\\installdir_corrupt1.bin");
sl@0	1793	_LIT(KInstallDirFileBad2, "Z:\\private\\10202be9\\installdir_corrupt2.bin");
sl@0	1794	RFs fs;
sl@0	1795	User::LeaveIfError(fs.Connect());
sl@0	1796	CleanupClosePushL(fs);
sl@0	1797
sl@0	1798	CFileMan* fm = CFileMan::NewL(fs);
sl@0	1799	CleanupStack::PushL(fm);
sl@0	1800
sl@0	1801	// copy first corrupt file into centrep private directory (this file has data area corrupted)
sl@0	1802	TheTest.Printf(_L("\nCopy first corrupt installdir.bin file into persists dir\n"));
sl@0	1803	User::LeaveIfError(fm->Copy(KInstallDirFileBad1, KInstallDirFile));
sl@0	1804	// Reset read-only bit
sl@0	1805	User::LeaveIfError(fm->Attribs(KInstallDirFile,0,KEntryAttReadOnly,TTime(0)));
sl@0	1806
sl@0	1807	// Kill server so that next test will restart and internalize file
sl@0	1808	TInt error = KillProcess(KCentralRepositoryServerName);
sl@0	1809	TEST2(error, KErrNone);
sl@0	1810
sl@0	1811	// Start server and check it does not panic
sl@0	1812	CRepository* repository = NULL;
sl@0	1813	TRAP(error, repository = CRepository::NewL(KUidRep1));
sl@0	1814	TEST2(error, KErrNone);
sl@0	1815	delete repository;
sl@0	1816
sl@0	1817	// test the second corrupted file (this file has header information corrupted)
sl@0	1818	TheTest.Printf(_L("\nCopy second corrupt installdir.bin file into persists dir\n"));
sl@0	1819	User::LeaveIfError(fm->Copy(KInstallDirFileBad2, KInstallDirFile));
sl@0	1820	// Reset read-only bit
sl@0	1821	User::LeaveIfError(fm->Attribs(KInstallDirFile,0,KEntryAttReadOnly,TTime(0)));
sl@0	1822
sl@0	1823	// Kill server so that next test will reconnect and recreate resources
sl@0	1824	error = KillProcess(KCentralRepositoryServerName);
sl@0	1825	TEST2(error, KErrNone);
sl@0	1826
sl@0	1827	// Start server and check it does not panic
sl@0	1828	TRAP(error, repository = CRepository::NewL(KUidRep1));
sl@0	1829	TEST2(error, KErrNone);
sl@0	1830	delete repository;
sl@0	1831
sl@0	1832	CleanupStack::PopAndDestroy(2); //fs, fm
sl@0	1833	}
sl@0	1834
sl@0	1835	/**
sl@0	1836	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3517
sl@0	1837	@SYMTestCaseDesc R3.2 stability problems: CentralRepositorySrv crash
sl@0	1838	@SYMTestPriority High
sl@0	1839	@SYMTestActions Attempt to open a .cre file which has a corrupt UID. Ensure that
sl@0	1840	the error is dealt with properly.
sl@0	1841	@SYMTestExpectedResults The test must not fail.
sl@0	1842	@SYMDEF INC108803
sl@0	1843	*/
sl@0	1844
sl@0	1845	_LIT(KZCorruptFile1, "z:\\private\\10202BE9\\101f8764.cre");
sl@0	1846	_LIT(KCCorruptFile1, "c:\\private\\10202BE9\\persists\\101f8764.cre");
sl@0	1847	_LIT(KCCorruptFile2, "c:\\private\\10202BE9\\persists\\101f8765.cre");
sl@0	1848
sl@0	1849	const TUid KUidCorruptUid1 = { 0x101f8764 };
sl@0	1850	const TUid KUidCorruptUid2 = { 0x101f8765 };
sl@0	1851
sl@0	1852	LOCAL_C void INC108803L()
sl@0	1853	{
sl@0	1854
sl@0	1855	TInt err = KErrNone;
sl@0	1856
sl@0	1857	RFs fs;
sl@0	1858	User::LeaveIfError(fs.Connect());
sl@0	1859	CleanupClosePushL(fs);
sl@0	1860
sl@0	1861	CFileMan* fm = CFileMan::NewL(fs);
sl@0	1862	CleanupStack::PushL(fm);
sl@0	1863
sl@0	1864	CRepository* rep = NULL;
sl@0	1865
sl@0	1866	// Attempt to open a repository from a .cre file which has a corrupt UID
sl@0	1867	// The .cre file exists on the Z drive only. This test ensures that
sl@0	1868	// the corruption of the .cre file is detected and that the correct error
sl@0	1869	// code, KErrCorrupt, is returned to the client.
sl@0	1870	// This test will
sl@0	1871	// 1. Look on c drive, be unable to find the file
sl@0	1872	// 2. Look in z drive, find the file with the specified UID,
sl@0	1873	// determine that the file is corrupt and return KErrCorupt.
sl@0	1874
sl@0	1875	TheTest.Printf(_L("\nAttempt to open ROM cre file with UID corruption\n"));
sl@0	1876	TRAP(err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep););
sl@0	1877	TEST2(err, KErrCorrupt);
sl@0	1878
sl@0	1879	// Copy the corrupt .cre file into the persists directory for the next test
sl@0	1880	User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile1 ));
sl@0	1881	// Reset read-only bit
sl@0	1882	User::LeaveIfError(fm->Attribs(KCCorruptFile1,0,KEntryAttReadOnly,TTime(0)));
sl@0	1883	User::After(KGeneralDelay);
sl@0	1884
sl@0	1885	// Attempt to open a repository which has a .cre file with a corrupt UID.
sl@0	1886	// The .cre file exists on the C and Z drives. (This test ensures that the
sl@0	1887	// corrupt .cre file on the C Drive is deleted).
sl@0	1888	// This test will
sl@0	1889	// 1.Look in the C Drive, find the file with the specified UID
sl@0	1890	// determine that the file is corrupt and delete the file
sl@0	1891	// 2. Look in the Z Drive, find the file with the specified UID,
sl@0	1892	// determine that the file is corrupt and return KErrCorupt.
sl@0	1893
sl@0	1894	TheTest.Printf(_L("\nAttempt to open persists cre file with UID corruption\n"));
sl@0	1895	TRAP (err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep););
sl@0	1896	TEST2(err, KErrCorrupt);
sl@0	1897	TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n"));
sl@0	1898	TEST2 (BaflUtils::FileExists (fs, KCCorruptFile1), EFalse);
sl@0	1899
sl@0	1900	// Copy a second corrupt .cre file into the persists directory
sl@0	1901	// (Note that an associated ini file
sl@0	1902	// z:\\private\\10202BE9\\101f8765.txt exists and is not corrupt)
sl@0	1903
sl@0	1904	User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile2));
sl@0	1905	TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), ETrue);
sl@0	1906	// Reset read-only bit
sl@0	1907	User::LeaveIfError(fm->Attribs(KCCorruptFile2,0,KEntryAttReadOnly,TTime(0)));
sl@0	1908	User::After(KGeneralDelay);
sl@0	1909
sl@0	1910	// Attempt to open a corrupt repository. This will fail and the .cre file on the
sl@0	1911	// C Drive will be deleted. Fall-back to the Z drive occurs. The associated ini file
sl@0	1912	// is found.
sl@0	1913	// Attempt to use the resulting repository by using a Reset operation. No panics should
sl@0	1914	// occur.
sl@0	1915	TheTest.Printf(_L("\nAttempt to open corrupt persists cre file, re-create from txt file\n"));
sl@0	1916	TRAP (err, rep = CRepository::NewLC(KUidCorruptUid2); CleanupStack::Pop(rep););
sl@0	1917	TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), EFalse);
sl@0	1918	TEST2(err, KErrNone);
sl@0	1919	ASSERT(rep != NULL);
sl@0	1920	rep->Reset();
sl@0	1921
sl@0	1922	// Clean up any files created on the C Drive
sl@0	1923	CleanupFileFromCDriveL(KUidCorruptUid1);
sl@0	1924	CleanupFileFromCDriveL(KUidCorruptUid2);
sl@0	1925
sl@0	1926	delete rep;
sl@0	1927	CleanupStack::PopAndDestroy(2, &fs); // fm, fs
sl@0	1928	}
sl@0	1929
sl@0	1930
sl@0	1931	/**
sl@0	1932	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3545
sl@0	1933	@SYMTestCaseDesc The corrupted Cache ini file should cause CentralRepositorySrv panic in debug mode
sl@0	1934	but keep running with the default values in release mode.
sl@0	1935	@SYMTestPriority High
sl@0	1936	@SYMTestActions Kill CentralRepositorySrv and restart it with the corrupted Cache ini file.
sl@0	1937	Ensure that:
sl@0	1938	. in debug mode, the client will fail to create a CRepository pointer because
sl@0	1939	the server has panicked.
sl@0	1940	. in release mode, the client will be able to create a CRepository pointer because
sl@0	1941	the server keeps running with the default values.
sl@0	1942	@SYMTestExpectedResults The test must not fail.
sl@0	1943	@SYMDEF DEF109390
sl@0	1944	*/
sl@0	1945
sl@0	1946	_LIT(KZCorruptIniFile, "z:\\private\\10202BE9\\cache_corrupt.ini");
sl@0	1947	_LIT(KCCorruptIniFile, "c:\\private\\10202BE9\\centrep.ini");
sl@0	1948	_LIT(KZRepFile, "z:\\private\\10202BE9\\00000001.txt");
sl@0	1949	_LIT(KCRepFile, "c:\\private\\10202BE9\\persists\\00000001.txt");
sl@0	1950
sl@0	1951	const TUid KTestRepUid = { 0x00000001};
sl@0	1952
sl@0	1953	LOCAL_C void DEF109390L()
sl@0	1954	{
sl@0	1955	TInt err(KErrNone);
sl@0	1956
sl@0	1957	RFs fs;
sl@0	1958	User::LeaveIfError(fs.Connect());
sl@0	1959	CleanupClosePushL(fs);
sl@0	1960
sl@0	1961	CFileMan* fm = CFileMan::NewL(fs);
sl@0	1962	CleanupStack::PushL(fm);
sl@0	1963
sl@0	1964	// Copy the corrupted Cache ini file to install directory.
sl@0	1965	TheTest.Printf(_L("\nCopy the corrupted Cache ini file to install directory.\n"));
sl@0	1966	User::LeaveIfError(fm->Copy(KZCorruptIniFile, KCCorruptIniFile));
sl@0	1967	// Reset read-only bit
sl@0	1968	User::LeaveIfError(fm->Attribs(KCCorruptIniFile,0,KEntryAttReadOnly,TTime(0)));
sl@0	1969
sl@0	1970	// Copy a good repository file to persist directory to verify whether the cenrep server is
sl@0	1971	// able to start up.
sl@0	1972	TheTest.Printf(_L("\nCopy the repository file to persist directory.\n"));
sl@0	1973	User::LeaveIfError(fm->Copy(KZRepFile, KCRepFile));
sl@0	1974	// Reset read-only bit
sl@0	1975	User::LeaveIfError(fm->Attribs(KCRepFile,0,KEntryAttReadOnly,TTime(0)));
sl@0	1976
sl@0	1977	// Kill server so that next test will restart it.
sl@0	1978	err=KillProcess(KCentralRepositoryServerName);
sl@0	1979	TEST2(err,KErrNone);
sl@0	1980
sl@0	1981	User::After(KGeneralDelay);
sl@0	1982
sl@0	1983	CRepository* rep = NULL;
sl@0	1984	TRAP(err, rep = CRepository::NewLC(KTestRepUid); CleanupStack::PopAndDestroy(rep););
sl@0	1985
sl@0	1986	#ifdef _DEBUG
sl@0	1987	// in debug mode, CRepository::NewLC should leave with leave code KErrGeneral.
sl@0	1988	TheTest.Printf(_L("Debug mode err = %d.\n"),err);
sl@0	1989	TEST2(err, KErrGeneral);
sl@0	1990	#else
sl@0	1991	// in release mode, CRepository::NewLC should return a valid CRepository pointer successfully.
sl@0	1992	TheTest.Printf(_L("Release mode err = %d.\n"),err);
sl@0	1993	TEST2(err, KErrNone);
sl@0	1994	#endif
sl@0	1995
sl@0	1996	// Clean up the repository files created on the C Drive
sl@0	1997	CleanupFileFromCDriveL(KTestRepUid);
sl@0	1998
sl@0	1999	// Clean up the corrupted ini file on the C Drive
sl@0	2000	User::LeaveIfError(fm->Delete(KCCorruptIniFile));
sl@0	2001
sl@0	2002	// pop the cleanup stack for fm & fs
sl@0	2003	CleanupStack::PopAndDestroy(2, &fs);
sl@0	2004
sl@0	2005	// Kill the Cenrep server so that it can it can be restarted by the client
sl@0	2006	// without the corrupted Cache ini file.
sl@0	2007	err=KillProcess(KCentralRepositoryServerName);
sl@0	2008	TEST2(err,KErrNone);
sl@0	2009	}
sl@0	2010
sl@0	2011	/**
sl@0	2012	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4024
sl@0	2013	@SYMTestCaseDesc
sl@0	2014	Test that the UID compare function works properly with large UID's. Since
sl@0	2015	CObservable::CompareTUidValues() is a private function and cannot be accessed
sl@0	2016	directly, CObservable::AddObserverL()and CObservable::FindConnectedRepository()
sl@0	2017	are used to infer the correct operation.
sl@0	2018	@SYMTestPriority High
sl@0	2019	@SYMTestActions
sl@0	2020	-Compare a large positive UID and a very negative UID
sl@0	2021	-Compare a large positive UID and a large positive UID
sl@0	2022	-Compare a very negative UID and a very negative UID
sl@0	2023	-Compare two very large but equivalent UID's.
sl@0	2024	@SYMTestExpectedResults All UID's added to a sorted list can be found later, regardless of size and sign.
sl@0	2025	@SYMDEF DEF116043
sl@0	2026	@SYMUnit CObservable::CompareTUidValues()
sl@0	2027	*/
sl@0	2028	LOCAL_C void DEF116043L()
sl@0	2029	{
sl@0	2030	const TUid KLargePositive1 = {0x7FFFFFFF};
sl@0	2031	const TUid KLargePositive2 = {0x7FFFFFFE};
sl@0	2032	const TUid KLargeNegative = {0x8FFFFFFF};
sl@0	2033
sl@0	2034	CObservable* ob = CObservable::NewLC();
sl@0	2035
sl@0	2036	// Add a variety of UID's to work with, including large positives, a very negative,
sl@0	2037	// and duplicates
sl@0	2038	ob->AddObserverL(KLargePositive1, NULL);
sl@0	2039	ob->AddObserverL(KLargeNegative, NULL);
sl@0	2040	ob->AddObserverL(KLargePositive2, NULL);
sl@0	2041	ob->AddObserverL(KLargePositive1, NULL);
sl@0	2042
sl@0	2043	// Look for a large positive and expect a non-negative index
sl@0	2044	TEST(ob->FindConnectedRepository(KLargePositive1) >= 0);
sl@0	2045
sl@0	2046	// Look for another large positive and expect a non-negative index
sl@0	2047	TEST(ob->FindConnectedRepository(KLargePositive2) >= 0);
sl@0	2048
sl@0	2049	// Look for a very negative and expect a non-negative index.
sl@0	2050	// This will fail under 'UID1 - UID2' implementations.
sl@0	2051	TEST(ob->FindConnectedRepository(KLargeNegative) >= 0);
sl@0	2052
sl@0	2053	CleanupStack::PopAndDestroy(ob);
sl@0	2054	}
sl@0	2055
sl@0	2056	/**
sl@0	2057	@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4081
sl@0	2058	@SYMTestCaseDesc
sl@0	2059	Test that the Observer compare function works properly with large UID's
sl@0	2060	@SYMTestPriority High
sl@0	2061	@SYMTestActions The test will insert a set of pointers with very big and small unsigned address
sl@0	2062	and ensure that the correct order is inserted in the list
sl@0	2063	@SYMTestExpectedResults the pointer is inserted in the correct order
sl@0	2064	@SYMDEF DEF132807
sl@0	2065	*/
sl@0	2066	LOCAL_C void DEF132807L()
sl@0	2067	{
sl@0	2068	CObservable* ob = CObservable::NewLC();
sl@0	2069
sl@0	2070	const TUid KReposUid={0x87654321};
sl@0	2071
sl@0	2072	ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFF);
sl@0	2073	ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFE);
sl@0	2074	ob->AddObserverL(KReposUid,(CServerRepository*)0x8FFFFFFF);
sl@0	2075	ob->AddObserverL(KReposUid,(CServerRepository*)0x00000001);
sl@0	2076
sl@0	2077	TEST(ob->iObservers.Count()==4);
sl@0	2078	CObservable::TRepositoryObserverInfo pos1=ob->iObservers[0];
sl@0	2079	TEST(pos1.iRepositoryPointer==(CServerRepository*)0x00000001);
sl@0	2080	CObservable::TRepositoryObserverInfo pos2=ob->iObservers[1];
sl@0	2081	TEST(pos2.iRepositoryPointer==(CServerRepository*)0x7FFFFFFE);
sl@0	2082	CObservable::TRepositoryObserverInfo pos3=ob->iObservers[2];
sl@0	2083	TEST(pos3.iRepositoryPointer==(CServerRepository*)0x7FFFFFFF);
sl@0	2084	CObservable::TRepositoryObserverInfo pos4=ob->iObservers[3];
sl@0	2085	TEST(pos4.iRepositoryPointer==(CServerRepository*)0x8FFFFFFF);
sl@0	2086	CleanupStack::PopAndDestroy(ob);
sl@0	2087	}
sl@0	2088
sl@0	2089	//a test class notify handler
sl@0	2090	//the notify handler will check the value for different test case
sl@0	2091	static TInt currentTestCaseID=0;
sl@0	2092
sl@0	2093	class CTestNotifyHandler : public CBase, public MCenRepNotifyHandlerCallback
sl@0	2094	{
sl@0	2095	public:
sl@0	2096	static CTestNotifyHandler* NewL()
sl@0	2097	{
sl@0	2098	return new (ELeave)CTestNotifyHandler;
sl@0	2099	}
sl@0	2100	~CTestNotifyHandler(){}
sl@0	2101	// Notification handlers
sl@0	2102	void HandleNotifyInt(TUint32 aId, TInt aNewValue)
sl@0	2103	{
sl@0	2104	if (currentTestCaseID==0)
sl@0	2105	return;
sl@0	2106	else if(currentTestCaseID==1)
sl@0	2107	TEST(aId==1 && aNewValue==208);
sl@0	2108	}
sl@0	2109	void HandleNotifyReal(TUint32 aId, TReal /aNewValue/)
sl@0	2110	{
sl@0	2111	if (currentTestCaseID==2)
sl@0	2112	{
sl@0	2113	TEST(aId==1);
sl@0	2114	CActiveScheduler::Stop();
sl@0	2115	}
sl@0	2116	}
sl@0	2117	void HandleNotifyString(TUint32 /aId/, const TDesC16& /aNewValue/)
sl@0	2118	{
sl@0	2119	}
sl@0	2120	void HandleNotifyBinary(TUint32 /aId/, const TDesC8& /aNewValue/)
sl@0	2121	{
sl@0	2122	}
sl@0	2123	void HandleNotifyGeneric(TUint32 /aId/)
sl@0	2124	{
sl@0	2125	}
sl@0	2126	void HandleNotifyError(TUint32 aId, TInt error, CCenRepNotifyHandler* /aHandler/)
sl@0	2127	{
sl@0	2128	if (currentTestCaseID==0)
sl@0	2129	return;
sl@0	2130	else if (currentTestCaseID==1)
sl@0	2131	TEST((TInt)aId==-11 && error==KErrArgument);
sl@0	2132	else if (currentTestCaseID==2)
sl@0	2133	TEST(aId==1 && error==KErrArgument);
sl@0	2134	else if (currentTestCaseID==3)
sl@0	2135	TEST(aId== 10000 && error==KErrPermissionDenied);
sl@0	2136
sl@0	2137	CActiveScheduler::Stop();
sl@0	2138	}
sl@0	2139	private:
sl@0	2140	CTestNotifyHandler(){}
sl@0	2141	};
sl@0	2142
sl@0	2143	/**
sl@0	2144	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4035
sl@0	2145	@SYMTestCaseDesc Notify Handling in centralrepository under different error conditions
sl@0	2146	@SYMTestPriority High
sl@0	2147	@SYMTestActions Testing the CRepository::NotifyRequest under different error condition
sl@0	2148	Testing the CCenrepNotifierHandler under different error condition
sl@0	2149	@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
sl@0	2150	@SYMDEF DEF117987
sl@0	2151	*/
sl@0	2152	LOCAL_C void DEF117987L()
sl@0	2153	{
sl@0	2154	__UHEAP_MARK;
sl@0	2155
sl@0	2156	CActiveScheduler* s=new(ELeave) CActiveScheduler;
sl@0	2157	CleanupStack::PushL(s);
sl@0	2158	CActiveScheduler::Install(s);
sl@0	2159
sl@0	2160	const TUid KCDUid = {0xF0000001};
sl@0	2161	CRepository* rep=CRepository::NewL(KCDUid);
sl@0	2162
sl@0	2163	TRequestStatus ts,ts1;
sl@0	2164
sl@0	2165	//-----------------single notification test-----------------------
sl@0	2166	//Negative testing for Double notification on same setting
sl@0	2167	TInt ret=rep->NotifyRequest(1,ts);
sl@0	2168	TEST(ret==KErrNone);
sl@0	2169	ret=rep->NotifyRequest(1,ts1);
sl@0	2170	TEST(ret==KErrNone);
sl@0	2171	ret=rep->Set(1,123);
sl@0	2172	User::WaitForRequest(ts);
sl@0	2173	User::WaitForRequest(ts1);
sl@0	2174	TEST(ts==1);
sl@0	2175	TEST(ts1==KErrAlreadyExists);
sl@0	2176
sl@0	2177	//Negative testing for non-existent key---------------------------
sl@0	2178	ts=KRequestPending;
sl@0	2179	ret=rep->NotifyRequest(10303,ts);
sl@0	2180	TEST(ret==KErrNotFound);
sl@0	2181	TEST(ts==KRequestPending);
sl@0	2182
sl@0	2183	//Negative testing for key we dont have permission----------------
sl@0	2184	ret=rep->NotifyRequest(10000,ts);
sl@0	2185	TEST(ret==KErrPermissionDenied);
sl@0	2186	TEST(ts==KRequestPending);
sl@0	2187
sl@0	2188	//---------------------group notification test--------------------------
sl@0	2189	ts=KRequestPending;
sl@0	2190	ts1=KRequestPending;
sl@0	2191
sl@0	2192	//Negative testing for double notification on the same setting range
sl@0	2193	//set partial key 0 and mask 0xFFFFFF00 to filter only 0-255
sl@0	2194	ret=rep->NotifyRequest(0,0xFFFFFF00,ts);
sl@0	2195	TEST(ret==KErrNone);
sl@0	2196	//second notification request on the same partial key and mask should not fail
sl@0	2197	ret=rep->NotifyRequest(0,0xFFFFFF00,ts1);
sl@0	2198	TEST(ret==KErrNone);
sl@0	2199	ret=rep->Set(1,246);
sl@0	2200	User::WaitForRequest(ts);
sl@0	2201	User::WaitForRequest(ts1);
sl@0	2202	TEST(ts==1);
sl@0	2203	TEST(ts1==1);
sl@0	2204
sl@0	2205	//Negative testing for unknown range------------------------------
sl@0	2206	//this will not return error code for range notification as it is intended for
sl@0	2207	//to cover keys created later in the future.
sl@0	2208	ts=KRequestPending;
sl@0	2209	ret=rep->NotifyRequest(100000,0xFFFFFFFF,ts);
sl@0	2210	TEST(ret==KErrNone);
sl@0	2211	ret=rep->NotifyCancel(100000,0xFFFFFFFF);
sl@0	2212	User::WaitForAnyRequest();
sl@0	2213	TEST(ret==KErrNone);
sl@0	2214	TEST(ts==KUnspecifiedKey);
sl@0	2215
sl@0	2216	//Negative testing for key we dont have permission------------------------------
sl@0	2217	ts=KRequestPending;
sl@0	2218	ret=rep->NotifyRequest(10000,0xFFFFFFFF,ts);
sl@0	2219	TEST(ret==KErrNone);
sl@0	2220	User::WaitForRequest(ts);
sl@0	2221	TEST(ts==KErrPermissionDenied);
sl@0	2222
sl@0	2223	delete rep;
sl@0	2224
sl@0	2225	//----------------single notification using cenrepnotifhandler-----------
sl@0	2226	currentTestCaseID=1;
sl@0	2227	rep=CRepository::NewL(KCDUid);
sl@0	2228	//create the handler callback
sl@0	2229	CTestNotifyHandler* callback=CTestNotifyHandler::NewL();
sl@0	2230
sl@0	2231	//now setup the handler
sl@0	2232	CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(callback,rep,CCenRepNotifyHandler::EIntKey,1);
sl@0	2233	CCenRepNotifyHandler* handler2=CCenRepNotifyHandler::NewLC(callback,rep,CCenRepNotifyHandler::EIntKey,1);
sl@0	2234
sl@0	2235	handler->StartListeningL();
sl@0	2236	handler2->StartListeningL();
sl@0	2237
sl@0	2238	ret=rep->Set(1,208);
sl@0	2239	TEST(ret==KErrNone);
sl@0	2240
sl@0	2241	CActiveScheduler::Start();
sl@0	2242
sl@0	2243	User::After(1000000);
sl@0	2244	CleanupStack::PopAndDestroy(2);
sl@0	2245
sl@0	2246	delete callback;
sl@0	2247	delete rep;
sl@0	2248
sl@0	2249	CleanupStack::PopAndDestroy();
sl@0	2250
sl@0	2251	__UHEAP_MARKEND;
sl@0	2252	}
sl@0	2253
sl@0	2254	/**
sl@0	2255	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4034
sl@0	2256	@SYMTestCaseDesc Centrep notifier handler does not check return codes
sl@0	2257	@SYMTestPriority High
sl@0	2258	@SYMTestActions Test that error code encountered during handling of notification
sl@0	2259	results in the HandleNotifyError being invoked
sl@0	2260	@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
sl@0	2261	@SYMDEF DEF117848
sl@0	2262	*/
sl@0	2263	LOCAL_C void DEF117848L()
sl@0	2264	{
sl@0	2265	__UHEAP_MARK;
sl@0	2266
sl@0	2267	CActiveScheduler* s=new(ELeave) CActiveScheduler;
sl@0	2268	CleanupStack::PushL(s);
sl@0	2269	CActiveScheduler::Install(s);
sl@0	2270
sl@0	2271	const TUid KCDUid = {0xF0000001};
sl@0	2272
sl@0	2273	//create the handler callback
sl@0	2274	CTestNotifyHandler* callback=CTestNotifyHandler::NewL();
sl@0	2275
sl@0	2276	//----------------notify handle error test case------------------------------
sl@0	2277	currentTestCaseID=2;
sl@0	2278	CRepository* rep=CRepository::NewL(KCDUid);
sl@0	2279
sl@0	2280	//purposely set the notify handler for a key but specifying the wrong type
sl@0	2281	//this will only be detected during the notification
sl@0	2282	CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(callback,rep,CCenRepNotifyHandler::ERealKey,1);
sl@0	2283	handler->StartListeningL();
sl@0	2284	TInt ret=rep->Set(1,199);
sl@0	2285	TEST(ret==KErrNone);
sl@0	2286
sl@0	2287	CActiveScheduler::Start();
sl@0	2288	//handlenotify error will be called and validate the error code and then stop the scheduler
sl@0	2289	handler->StopListening();
sl@0	2290
sl@0	2291	CleanupStack::PopAndDestroy();
sl@0	2292
sl@0	2293	//test for other type of settings
sl@0	2294	handler=CCenRepNotifyHandler::NewLC(callback,rep,CCenRepNotifyHandler::EStringKey,1);
sl@0	2295	handler->StartListeningL();
sl@0	2296	ret=rep->Set(1,209);
sl@0	2297	TEST(ret==KErrNone);
sl@0	2298	CActiveScheduler::Start();
sl@0	2299	handler->StopListening();
sl@0	2300	CleanupStack::PopAndDestroy();
sl@0	2301
sl@0	2302	//test for other type of settings
sl@0	2303	handler=CCenRepNotifyHandler::NewLC(callback,rep,CCenRepNotifyHandler::EBinaryKey,1);
sl@0	2304	handler->StartListeningL();
sl@0	2305	ret=rep->Set(1,309);
sl@0	2306	TEST(ret==KErrNone);
sl@0	2307
sl@0	2308	CActiveScheduler::Start();
sl@0	2309	handler->StopListening();
sl@0	2310	CleanupStack::PopAndDestroy();
sl@0	2311
sl@0	2312	delete callback;
sl@0	2313	delete rep;
sl@0	2314
sl@0	2315	CleanupStack::PopAndDestroy();
sl@0	2316
sl@0	2317	__UHEAP_MARKEND;
sl@0	2318	}
sl@0	2319
sl@0	2320	/**
sl@0	2321	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036
sl@0	2322	@SYMTestCaseDesc Central Repository Notification Handler flooded with notifications
sl@0	2323	@SYMTestPriority High
sl@0	2324	@SYMTestActions Testing the CCenrepNotifierHandler when the client does not have
sl@0	2325	enough permission when setting up the whole repository notifier.
sl@0	2326	@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
sl@0	2327	@SYMDEF DEF118107
sl@0	2328	*/
sl@0	2329	LOCAL_C void DEF118107L()
sl@0	2330	{
sl@0	2331	__UHEAP_MARK;
sl@0	2332
sl@0	2333	currentTestCaseID = 3;
sl@0	2334	CActiveScheduler* s=new(ELeave) CActiveScheduler;
sl@0	2335	CleanupStack::PushL(s);
sl@0	2336	CActiveScheduler::Install(s);
sl@0	2337
sl@0	2338	const TUid KCDUid = {0xF0000001};
sl@0	2339	CRepository* rep=CRepository::NewL(KCDUid);
sl@0	2340
sl@0	2341	//create the handler callback
sl@0	2342	CTestNotifyHandler* callback=CTestNotifyHandler::NewL();
sl@0	2343
sl@0	2344	//create a handler to listen to the whole repository
sl@0	2345	CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(callback,rep);
sl@0	2346
sl@0	2347	//Start listening as a fail should occur as one of repository entries does not
sl@0	2348	//have the correct capabilities
sl@0	2349	handler->StartListeningL();
sl@0	2350
sl@0	2351	//This causes the handlenotifyerror to be called which checks that
sl@0	2352	//KErrPermissionDenied has occured and stops the scheduler.
sl@0	2353	CActiveScheduler::Start();
sl@0	2354	handler->StopListening();
sl@0	2355
sl@0	2356	//Cleanup
sl@0	2357	CleanupStack::PopAndDestroy();
sl@0	2358
sl@0	2359	delete callback;
sl@0	2360	delete rep;
sl@0	2361
sl@0	2362	CleanupStack::PopAndDestroy();
sl@0	2363
sl@0	2364	__UHEAP_MARKEND;
sl@0	2365	}
sl@0	2366
sl@0	2367
sl@0	2368	// This function creates TServerSetting objects with the data in the ServerSettingStruct array and then
sl@0	2369	// appends them to the specified RSettingsArray object.
sl@0	2370	LOCAL_C void SetupSettingsArrayL(RSettingsArray& aSettingsArray,const ServerSettingStruct aSettingStructArr[], TInt aSettingStructArrSize)
sl@0	2371	{
sl@0	2372	for(TInt i = 0; i < aSettingStructArrSize; i++)
sl@0	2373	{
sl@0	2374	TServerSetting newSetting(aSettingStructArr[i].key);
sl@0	2375	TInt error;
sl@0	2376	newSetting.SetIntValue(aSettingStructArr[i].value);
sl@0	2377	newSetting.SetType(aSettingStructArr[i].meta);
sl@0	2378	newSetting.SetMeta(aSettingStructArr[i].meta);
sl@0	2379
sl@0	2380	error = aSettingsArray.OrderedInsert(newSetting);
sl@0	2381
sl@0	2382	if(KErrNone != error)
sl@0	2383	{
sl@0	2384	newSetting.Reset(); // for safety in case of newSetting is not TInt type.
sl@0	2385	User::Leave(error);
sl@0	2386	}
sl@0	2387	}
sl@0	2388	}
sl@0	2389
sl@0	2390	// This function compares 2 RSettingsArray arrays. Panics if they are not identical
sl@0	2391	LOCAL_C void CompareSettingsArrays(const RSettingsArray& aArr1, const RSettingsArray& aArr2)
sl@0	2392	{
sl@0	2393	TEST2(aArr1.Count(), aArr2.Count());
sl@0	2394	for(TInt i = 0; i < aArr2.Count(); i++)
sl@0	2395	{
sl@0	2396	if(aArr1[i].IsDeleted())
sl@0	2397	{
sl@0	2398	TEST(aArr2[i].IsDeleted());
sl@0	2399	}
sl@0	2400	else
sl@0	2401	{
sl@0	2402	TEST(aArr1[i] == aArr2[i]);
sl@0	2403	}
sl@0	2404	}
sl@0	2405	}
sl@0	2406
sl@0	2407	// This function compares 2 RArray<TUint32> arrays. Panics if they are not identical
sl@0	2408	LOCAL_C void CompareUint32Arrays(const RArray<TUint32>& aArr1, const RArray<TUint32>& aArr2)
sl@0	2409	{
sl@0	2410	TEST2(aArr1.Count(), aArr2.Count());
sl@0	2411	for(TInt i = 0; i < aArr2.Count(); i++)
sl@0	2412	{
sl@0	2413	TEST(aArr1[i] == aArr2[i]);
sl@0	2414	}
sl@0	2415	}
sl@0	2416
sl@0	2417	// This function calls MergerArray() with the pre-set parameters for each merge type and compares the results to
sl@0	2418	// the reference arrays.
sl@0	2419	// Also used as the OOM test if aOOMMode is ETrue.
sl@0	2420	LOCAL_C void MergerArrayTestL(const RSettingsArray aPersistRef[], const RSettingsArray aChangeRef[], const RArray<TUint32> aDeletedRef[], TBool aOOMMode)
sl@0	2421
sl@0	2422	{
sl@0	2423	// Data used to construct the persistence array for all merge types
sl@0	2424	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}};
sl@0	2425
sl@0	2426	// Data used to construct the changes array for merge type: ETransactionMerge. Some are marked as deleted.
sl@0	2427	static const ServerSettingStruct settingStructChangeTrans[] = {{1,TServerSetting::EDeleted,1}, {2,TServerSetting::EDeleted,2}, \
sl@0	2428	{3,TServerSetting::EDeleted,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};
sl@0	2429
sl@0	2430	// Data used to construct the changes array for all other merge types than ETransactionMerge. No deleted items.
sl@0	2431	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}};
sl@0	2432
sl@0	2433	for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++)
sl@0	2434	{
sl@0	2435	RSettingsArray persist;
sl@0	2436	RSettingsArray change;
sl@0	2437	RArray<TUint32> deleted;
sl@0	2438	TInt error = KErrNone ;
sl@0	2439	TInt count = 0;
sl@0	2440
sl@0	2441	do
sl@0	2442	{
sl@0	2443	__UHEAP_MARK;
sl@0	2444
sl@0	2445	// Sets up arrays passed into MergeArray()
sl@0	2446	SetupSettingsArrayL(persist,settingStructPersist, sizeof(settingStructPersist)/sizeof(ServerSettingStruct));
sl@0	2447	if( ETransactionMerge == KMergerTypes[i] )
sl@0	2448	{
sl@0	2449	SetupSettingsArrayL(change,settingStructChangeTrans, sizeof(settingStructChangeTrans)/sizeof(ServerSettingStruct));
sl@0	2450	}
sl@0	2451	else
sl@0	2452	{
sl@0	2453	SetupSettingsArrayL(change,settingStructChange, sizeof(settingStructChange)/sizeof(ServerSettingStruct));
sl@0	2454	}
sl@0	2455
sl@0	2456	deleted.InsertInUnsignedKeyOrderL(4);
sl@0	2457
sl@0	2458	if(aOOMMode)
sl@0	2459	{
sl@0	2460	__UHEAP_SETFAIL(RHeap::EFailNext, ++count);
sl@0	2461	}
sl@0	2462
sl@0	2463	error = persist.MergeArray(change, deleted, KMergerTypes[i]);
sl@0	2464
sl@0	2465	if (aOOMMode)
sl@0	2466	{
sl@0	2467	TEST(KErrNone == error \|\| KErrNoMemory == error);
sl@0	2468	__UHEAP_SETFAIL(RHeap::ENone, 0);
sl@0	2469	}
sl@0	2470	else
sl@0	2471	{
sl@0	2472	TEST(KErrNone == error);
sl@0	2473	// Verifies affected arrays.
sl@0	2474	CompareSettingsArrays(persist, aPersistRef[i]);
sl@0	2475	CompareSettingsArrays(change, aChangeRef[i]);
sl@0	2476	CompareUint32Arrays(deleted, aDeletedRef[i]);
sl@0	2477	}
sl@0	2478
sl@0	2479	// Resets the arrays.
sl@0	2480	persist.Reset();
sl@0	2481	change.Reset();
sl@0	2482	deleted.Reset();
sl@0	2483
sl@0	2484	__UHEAP_MARKEND;
sl@0	2485	} while(KErrNoMemory == error);
sl@0	2486	if (aOOMMode)
sl@0	2487	{
sl@0	2488	TheTest.Printf(_L("- MergeArray for type %d succeeded at heap failure rate of %i\n"), KMergerTypes[i], count);
sl@0	2489	}
sl@0	2490	}
sl@0	2491	}
sl@0	2492
sl@0	2493	/**
sl@0	2494	@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4037
sl@0	2495	@SYMTestCaseDesc This test case verifies the re-factored CentralRepository internal merge function (MergeArray).
sl@0	2496	@SYMTestPriority High
sl@0	2497	@SYMTestActions For each merger type, calls MergeArray() with the pre-defined arrays: this, aChanges, aDeleted,
sl@0	2498	which would be changed by the function. Verifies these 3 arrays with the reference arrays as well as
sl@0	2499	the return code after MergeArray() returns.
sl@0	2500	This case also carries out the OOM test for function MergeArray().
sl@0	2501	@SYMTestExpectedResults MergeArray() should return no error and these 3 arrays should be identical with the reference
sl@0	2502	arrays. In OOM mode, only KErrNoMemory or KErrNone should be returned.
sl@0	2503	@SYMDEF DEF116629
sl@0	2504	*/
sl@0	2505	LOCAL_C void DEF116629L()
sl@0	2506	{
sl@0	2507
sl@0	2508	// Data used to construct the reference arrays of each merge type:
sl@0	2509	// ETransactionMerge
sl@0	2510	const ServerSettingStruct settingStructPersistAfterTrans[] = {{4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}};
sl@0	2511	const ServerSettingStruct settingStructChangeAfterTrans[] = {{1,TServerSetting::EDeleted,1},
sl@0	2512	{3,TServerSetting::EDeleted,3}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}};
sl@0	2513
sl@0	2514	// ERestoreMerge
sl@0	2515	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}};
sl@0	2516	const ServerSettingStruct settingStructChangeAfterRest[] = {{2,0,2}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}};
sl@0	2517
sl@0	2518	// ESWIUpgradeMerge
sl@0	2519	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}};
sl@0	2520	const ServerSettingStruct settingStructChangeAfterSWIUp[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}};
sl@0	2521
sl@0	2522	// ESWIDowngradeMerge
sl@0	2523	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}};
sl@0	2524	const ServerSettingStruct settingStructChangeAfterSWIDown[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}, {13,0,0}};
sl@0	2525
sl@0	2526	// ERomFlash
sl@0	2527	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}};
sl@0	2528	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}};
sl@0	2529
sl@0	2530	// Reference arrays
sl@0	2531	RSettingsArray persistAfter[5];
sl@0	2532	RSettingsArray changeAfter[5];
sl@0	2533	RArray<TUint32> deletedAfter[5];
sl@0	2534
sl@0	2535	// Sets up the reference arrays for each merge type:
sl@0	2536	// ETransactionMerge
sl@0	2537	SetupSettingsArrayL(persistAfter[0],settingStructPersistAfterTrans, sizeof(settingStructPersistAfterTrans)/sizeof(ServerSettingStruct));
sl@0	2538	SetupSettingsArrayL(changeAfter[0],settingStructChangeAfterTrans, sizeof(settingStructChangeAfterTrans)/sizeof(ServerSettingStruct));
sl@0	2539	deletedAfter[0].InsertInUnsignedKeyOrderL(3);
sl@0	2540
sl@0	2541	// ERestoreMerge
sl@0	2542	SetupSettingsArrayL(persistAfter[1],settingStructPersistAfterRest, sizeof(settingStructPersistAfterRest)/sizeof(ServerSettingStruct));
sl@0	2543	SetupSettingsArrayL(changeAfter[1],settingStructChangeAfterRest, sizeof(settingStructChangeAfterRest)/sizeof(ServerSettingStruct));
sl@0	2544	//deletedAfter[1] should be empty because Restore Merge should not delete any setting.
sl@0	2545
sl@0	2546	// ESWIUpgradeMerge
sl@0	2547	SetupSettingsArrayL(persistAfter[2],settingStructPersistAfterSWIUp, sizeof(settingStructPersistAfterSWIUp)/sizeof(ServerSettingStruct));
sl@0	2548	SetupSettingsArrayL(changeAfter[2],settingStructChangeAfterSWIUp, sizeof(settingStructChangeAfterSWIUp)/sizeof(ServerSettingStruct));
sl@0	2549	//deletedAfter[2] should be empty because SWIUpgrade Merge should not delete any setting.
sl@0	2550
sl@0	2551	// ESWIDowngradeMerge
sl@0	2552	SetupSettingsArrayL(persistAfter[3],settingStructPersistAfterSWIDown, sizeof(settingStructPersistAfterSWIDown)/sizeof(ServerSettingStruct));
sl@0	2553	SetupSettingsArrayL(changeAfter[3],settingStructChangeAfterSWIDown, sizeof(settingStructChangeAfterSWIDown)/sizeof(ServerSettingStruct));
sl@0	2554	//deletedAfter[3] should be empty because settings deleted by SWIDowngrade Merge are recorded in aChanges.
sl@0	2555
sl@0	2556	// ERomFlash
sl@0	2557	SetupSettingsArrayL(persistAfter[4],settingStructPersistAfterRomFlash, sizeof(settingStructPersistAfterRomFlash)/sizeof(ServerSettingStruct));
sl@0	2558	SetupSettingsArrayL(changeAfter[4],settingStructChangeAfterRomFlash, sizeof(settingStructChangeAfterRomFlash)/sizeof(ServerSettingStruct));
sl@0	2559	//deletedAfter[4] should be empty because settings deleted by RomFlash Merge are recorded in aChanges.
sl@0	2560
sl@0	2561	TheTest.Printf(_L("- Verification test for MergeArray.\n"));
sl@0	2562	MergerArrayTestL(persistAfter, changeAfter, deletedAfter, EFalse);
sl@0	2563
sl@0	2564	TheTest.Printf(_L("- OOM test for MergeArray.\n"));
sl@0	2565	MergerArrayTestL(persistAfter, changeAfter, deletedAfter, ETrue);
sl@0	2566
sl@0	2567	// Resets the reference arrays.
sl@0	2568	for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++)
sl@0	2569	{
sl@0	2570	persistAfter[i].Reset();
sl@0	2571	changeAfter[i].Reset();
sl@0	2572	deletedAfter[i].Reset();
sl@0	2573	}
sl@0	2574	}
sl@0	2575	/**
sl@0	2576	@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4046
sl@0	2577	@SYMTestCaseDesc The centrep server panics when it reads a repository text file where
sl@0	2578	the value of a binary settings is missing.
sl@0	2579	@SYMTestPriority Medium
sl@0	2580	@SYMTestActions - Provide a repository text file for this test which have a binary
sl@0	2581	setting which value is missing.
sl@0	2582	- Open the repository text file,
sl@0	2583	this should return KErrCorrupt when parsing the repository text file.
sl@0	2584	@SYMTestExpectedResults The test must not fail.
sl@0	2585	@SYMDEF PDEF126904
sl@0	2586	*/
sl@0	2587	LOCAL_C void PDEF126904L()
sl@0	2588	{
sl@0	2589	const TUid KUidBinaryValueRepositoryFile ={0x1020506B};
sl@0	2590	const TInt KBinaryValueRepKey = 0xA;
sl@0	2591	TInt binaryValue = 0;
sl@0	2592	CRepository* repository = NULL;
sl@0	2593
sl@0	2594	TRAPD(res, repository = CRepository::NewL(KUidBinaryValueRepositoryFile));
sl@0	2595	if (res == KErrNone)
sl@0	2596	{
sl@0	2597	TInt err = KErrNone;
sl@0	2598	CleanupStack::PushL(repository);
sl@0	2599	err = repository->Get(KBinaryValueRepKey, binaryValue);
sl@0	2600	User::LeaveIfError(err);
sl@0	2601	CleanupStack::PopAndDestroy(repository);
sl@0	2602	}
sl@0	2603	else if (res == KErrCorrupt)
sl@0	2604	{
sl@0	2605	//This is just to confirm that the err should be KErrCorrupt.
sl@0	2606	TheTest.Printf(_L("The error is KErrCorrupt as expected.\n"));
sl@0	2607	}
sl@0	2608	else
sl@0	2609	{
sl@0	2610	User::Leave(res);
sl@0	2611	}
sl@0	2612	}
sl@0	2613
sl@0	2614	/**
sl@0	2615	@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4084
sl@0	2616	@SYMTestCaseDesc Ensure that the timestamp in a TXT file is always zero when not specified
sl@0	2617	instead of arbitrary value
sl@0	2618	@SYMTestPriority Medium
sl@0	2619	@SYMTestActions Create the CHeapRepository object from a TXT keyspace file where no timestamp(legacy)
sl@0	2620	section is specified. The timestamp should be set to zero
sl@0	2621	@SYMTestExpectedResults The test must not fail.
sl@0	2622	@SYMDEF DEF136161
sl@0	2623	*/
sl@0	2624	LOCAL_C void DEF136161L()
sl@0	2625	{
sl@0	2626	RFs fs;
sl@0	2627	User::LeaveIfError(fs.Connect());
sl@0	2628
sl@0	2629	//this is a TXT based ROM keyspace
sl@0	2630	const TUid KTestUid={0x00000001};
sl@0	2631
sl@0	2632	CHeapRepository* repos=CHeapRepository::NewL(KTestUid);
sl@0	2633	CIniFileIn* iniFile;
sl@0	2634	TInt ret=CIniFileIn::NewLC(fs,iniFile,_L("z:\\private\\10202be9\\00000001.txt"));
sl@0	2635	User::LeaveIfError(ret);
sl@0	2636	repos->ReloadContentL(*iniFile);
sl@0	2637
sl@0	2638	//check the timestamp is always set to zero
sl@0	2639	TEST(repos->TimeStamp()==TTime(0));
sl@0	2640
sl@0	2641	CleanupStack::PopAndDestroy(iniFile);
sl@0	2642	delete repos;
sl@0	2643
sl@0	2644	fs.Close();
sl@0	2645	}
sl@0	2646
sl@0	2647	/**
sl@0	2648	@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4085
sl@0	2649	@SYMTestCaseDesc Central Repository: Trying to configure Central Repository cache with centrep.in
sl@0	2650	@SYMTestPriority High
sl@0	2651	@SYMTestActions Testing that the SWIWatcher does nto leave when the cache configuration exists within
sl@0	2652	the private data cate
sl@0	2653	@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
sl@0	2654	@SYMDEF PDEF139979
sl@0	2655	*/
sl@0	2656	LOCAL_C void PDEF139979L()
sl@0	2657	{
sl@0	2658	__UHEAP_MARK;
sl@0	2659	CActiveScheduler* s=new(ELeave) CActiveScheduler;
sl@0	2660	CleanupStack::PushL(s);
sl@0	2661	CActiveScheduler::Install(s);
sl@0	2662
sl@0	2663	RFs fs;
sl@0	2664	User::LeaveIfError(fs.Connect());
sl@0	2665	CleanupClosePushL(fs);
sl@0	2666
sl@0	2667	CFileMan* fm = CFileMan::NewL(fs);
sl@0	2668	CleanupStack::PushL(fm);
sl@0	2669
sl@0	2670	TRAPD(err,TServerResources::InitialiseL());
sl@0	2671	TEST2(err,KErrNone);
sl@0	2672
sl@0	2673	delete TServerResources::iInstallDirectory;
sl@0	2674	_LIT(KInstallFolder,"c:\\private\\12345678\\");
sl@0	2675	TServerResources::iInstallDirectory=(KInstallFolder()).AllocL();
sl@0	2676	TInt erro=fm->Delete(_L("c:\\private\\12345678\\."));
sl@0	2677	//copy centrep.ini file to the install folder
sl@0	2678	_LIT(KSource,"z:\\private\\10202be9\\centrepcache.ini0");
sl@0	2679	_LIT(KDestination,"c:\\private\\12345678\\centrep.ini");
sl@0	2680	TRAP(err,CopyTestFilesL(*fm,KSource(),KDestination()));
sl@0	2681
sl@0	2682	CCentRepSWIWatcher* swi=CCentRepSWIWatcher::NewL(fs);
sl@0	2683	TRAP(err,swi->FindChangedEntriesL(EFalse));
sl@0	2684	TEST2(err,KErrNone);
sl@0	2685
sl@0	2686	delete swi;
sl@0	2687	TServerResources::Close();
sl@0	2688
sl@0	2689	//delete the c file before we exit
sl@0	2690	fm->Delete(KDestination());
sl@0	2691
sl@0	2692	CleanupStack::PopAndDestroy(3);
sl@0	2693	__UHEAP_MARKEND;
sl@0	2694	}
sl@0	2695
sl@0	2696	/**
sl@0	2697	@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4086
sl@0	2698	@SYMTestCaseDesc centralrepositorysrv.exe crashes and phone doesn't boot up
sl@0	2699	@SYMTestPriority High
sl@0	2700	@SYMTestActions Test merging two settings of different type, one type exist for
sl@0	2701	persist and one type for the new rom, when the type differes, we expect the
sl@0	2702	persist setting to be completely replaced by the rom.
sl@0	2703	@SYMTestExpectedResults The test must not panic or fail.
sl@0	2704	@SYMDEF PDEF141519
sl@0	2705	*/
sl@0	2706	LOCAL_C void PDEF141519L()
sl@0	2707	{
sl@0	2708	__UHEAP_MARK;
sl@0	2709
sl@0	2710	RSettingsArray persist;
sl@0	2711	RSettingsArray newRom;
sl@0	2712	RArray<TUint32> deletedSettings;
sl@0	2713	//persist setting
sl@0	2714	TServerSetting a(0x10);
sl@0	2715	a.SetType(TServerSetting::EInt);
sl@0	2716	a.SetIntValue(100);
sl@0	2717	persist.OrderedInsertL(a);
sl@0	2718
sl@0	2719	//new rom setting
sl@0	2720	TServerSetting b(0x10);
sl@0	2721	b.SetType(TServerSetting::EString);
sl@0	2722	TBuf8<5> buffer(_L8("abc"));
sl@0	2723	HBufC8* hbuf=buffer.AllocL();
sl@0	2724	b.SetStrValue(hbuf);
sl@0	2725	newRom.OrderedInsertL(b);
sl@0	2726
sl@0	2727	User::LeaveIfError(persist.MergeArray(newRom,deletedSettings,ERomFlash));
sl@0	2728	TServerSetting* persistEntry=persist.Find(0x10);
sl@0	2729	TEST2(persistEntry->Key(),0x10);
sl@0	2730	TEST2(persistEntry->Type(),TServerSetting::EString);
sl@0	2731	const HBufC8* val=persistEntry->GetStrValue();
sl@0	2732	TEST2(val->Compare(buffer),0);
sl@0	2733
sl@0	2734	persist.Close();
sl@0	2735	newRom.Close();
sl@0	2736
sl@0	2737	__UHEAP_MARKEND;
sl@0	2738	}
sl@0	2739
sl@0	2740	LOCAL_C void ConnectStartSuicideTransL(void)
sl@0	2741	{
sl@0	2742	const TUid KLargeReposUid1 ={0xcccccc00};
sl@0	2743	CRepository* repository=CRepository::NewL(KLargeReposUid1);
sl@0	2744	repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
sl@0	2745	}
sl@0	2746
sl@0	2747	LOCAL_C TInt SuicidalTransThread(TAny*)
sl@0	2748	{
sl@0	2749	CTrapCleanup* cleanup = CTrapCleanup::New();
sl@0	2750	if(!cleanup)
sl@0	2751	return KErrNoMemory;
sl@0	2752
sl@0	2753	TRAP_IGNORE(ConnectStartSuicideTransL());
sl@0	2754	//purposely waiting to be killed
sl@0	2755	User::WaitForAnyRequest();
sl@0	2756	return 0;
sl@0	2757	}
sl@0	2758
sl@0	2759	LOCAL_C void DEF143352L()
sl@0	2760	{
sl@0	2761	CleanupCDriveL();
sl@0	2762	__UHEAP_MARK;
sl@0	2763
sl@0	2764	const TUid KLargeReposUid1 ={0xcccccc00};
sl@0	2765	//create on in this thread and start transaction too
sl@0	2766	CRepository* rep1=CRepository::NewL(KLargeReposUid1);
sl@0	2767	User::LeaveIfError(rep1->StartTransaction(CRepository::EConcurrentReadWriteTransaction));
sl@0	2768
sl@0	2769	//create thread to connect, start transaction on the same repository as previous
sl@0	2770	RThread testThread;
sl@0	2771	_LIT(KThreadName1, "Martin");
sl@0	2772	testThread.Create(KThreadName1, SuicidalTransThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);
sl@0	2773
sl@0	2774	TRequestStatus requestStatus;
sl@0	2775	testThread.Logon(requestStatus);
sl@0	2776	testThread.Resume();
sl@0	2777
sl@0	2778	//wait for the first client to complete the start transaction
sl@0	2779	User::After(1000000);
sl@0	2780
sl@0	2781	//opening another big keyspace to force the eviction(cache size is 100K) both repository is about 78K in the heap
sl@0	2782	//cccccc03 is exactly the same as cccccc00
sl@0	2783	const TUid KLargeReposUid2 ={0xcccccc04};
sl@0	2784	CRepository* rep2=CRepository::NewL(KLargeReposUid2);
sl@0	2785
sl@0	2786	//now kill the thread we have created
sl@0	2787	testThread.Kill(KErrDied);
sl@0	2788	User::WaitForRequest(requestStatus);
sl@0	2789	TEST2(requestStatus.Int(), KErrDied);
sl@0	2790
sl@0	2791	//Wait for the session to be cleaned up
sl@0	2792	User::After(1000000);
sl@0	2793
sl@0	2794	//now current test thread will retry the same connection
sl@0	2795	//at this stage server will panic with kern-exec 3
sl@0	2796	CRepository* rep4=CRepository::NewL(KLargeReposUid1);
sl@0	2797
sl@0	2798	delete rep1;
sl@0	2799	delete rep2;
sl@0	2800	delete rep4;
sl@0	2801
sl@0	2802	__UHEAP_MARKEND;
sl@0	2803	}
sl@0	2804
sl@0	2805	LOCAL_C void FuncTestsL()
sl@0	2806	{
sl@0	2807	TheTest.Start(_L("DEF053500 - Central repository integer type key entries cannot handle hex values"));
sl@0	2808
sl@0	2809	DEF053500L();
sl@0	2810
sl@0	2811	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4015 DEF111734 - Central repository crashes when accessing a closed repository with active transaction "));
sl@0	2812	DEF111734L();
sl@0	2813
sl@0	2814	TheTest.Next(_L("DEF054368 - MetaData value in CentRep setting is not optional"));
sl@0	2815	DEF054368L();
sl@0	2816
sl@0	2817	TheTest.Next(_L("DEF055680 - Central repository find performance could be improved "));
sl@0	2818	DEF055680L();
sl@0	2819
sl@0	2820	TheTest.Next(_L("INC054688 - Key based capabilities in ini-file crashes cenrep server "));
sl@0	2821	INC054688L();
sl@0	2822
sl@0	2823	TheTest.Next(_L("DEF054632 - CenRep Initialisation default data does not work as expected"));
sl@0	2824	DEF054632L();
sl@0	2825
sl@0	2826	TheTest.Next(_L("DEF055661 - Central Repository does not allow AlwaysFail to be set for access control. "));
sl@0	2827	DEF055661L();
sl@0	2828
sl@0	2829	TheTest.Next(_L("DEF055267 - Can not insert more than 71 records into WapAccessPoint Table "));
sl@0	2830	DEF055267L();
sl@0	2831
sl@0	2832	TheTest.Next(_L("INC056194 - NTT - Central Repository checks DefaultWriteAccessPolicy when cancelling notif "));
sl@0	2833	INC056194L();
sl@0	2834
sl@0	2835	TheTest.Next(_L("DEF057145 - CenRepSrv KERN-EXEC3 when running CommDB test harness "));
sl@0	2836	DEF057145L();
sl@0	2837
sl@0	2838	TheTest.Next(_L("DEF057778 - Central repository ResetAll can cause user Panic 190 "));
sl@0	2839	DEF057778L();
sl@0	2840
sl@0	2841	TheTest.Next(_L("DEF057522 - Centralrepository security policy incorrect behaviour "));
sl@0	2842	DEF057522L();
sl@0	2843
sl@0	2844	TheTest.Next(_L("DEF057999 - Creating and deleting the same setting in a transaction doesn't work "));
sl@0	2845	DEF057999L();
sl@0	2846
sl@0	2847	TheTest.Next(_L("DEF057470 - Central repository lacks a range delete method "));
sl@0	2848	DEF057470L();
sl@0	2849
sl@0	2850	TheTest.Next(_L("INC058229 - CInstallFileWatcher::ReadInstallDirL contains insufficient error handling "));
sl@0	2851	INC058229L();
sl@0	2852
sl@0	2853	TheTest.Next(_L("DEF058900 - CentralRepository Notification section document needs update "));
sl@0	2854	DEF058900L();
sl@0	2855
sl@0	2856	TheTest.Next(_L("DEF061087 - Central repository cannot handle more than one range policy "));
sl@0	2857	DEF061087L();
sl@0	2858
sl@0	2859	TheTest.Next(_L("DEF060843 - [PSAudit] Lack of centralrep. data type checking could cause instability & bugs "));
sl@0	2860	DEF060843L();
sl@0	2861
sl@0	2862	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1433 INC069013 - Central repository panics the client when trying to read 8-bit descriptor with uneven length "));
sl@0	2863	INC069013L();
sl@0	2864
sl@0	2865	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1434 DEF070731 - Central repository doesn't handle corrupt .cre files correctly. "));
sl@0	2866	DEF070731L();
sl@0	2867
sl@0	2868	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1683 DEF084700 - UIF automated tests crash H4 board. "));
sl@0	2869	DEF084700L();
sl@0	2870
sl@0	2871	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1862 DEF089945: [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM "));
sl@0	2872	DEF089945L();
sl@0	2873
sl@0	2874	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3242 PDEF098500 - Backup to memory card causes phone freeze "));
sl@0	2875	PDEF098500();
sl@0	2876
sl@0	2877	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1884 DEF093855: CenRep cancels transactions if they exceed 5 seconds... "));
sl@0	2878	DEF093855L();
sl@0	2879
sl@0	2880
sl@0	2881	// When adding a new defect test, if you decide to reuse a repository that has already been used
sl@0	2882	// in another defect test, make sure you modify the existing test which uses the repository and
sl@0	2883	// add the cache delay after that test closes the repository. e.g. DEF055680L
sl@0	2884
sl@0	2885	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3477 PDEF106507 - Currupt installdir.bin file causes server to crash "));
sl@0	2886	PDEF106507L();
sl@0	2887
sl@0	2888	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3517 INC108803 - R3.2 stability problems: CentralRepositorySrv crash "));
sl@0	2889	INC108803L();
sl@0	2890
sl@0	2891	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3545 DEF109390: Centrep cache ini file corruption should not cause server crash. "));
sl@0	2892	DEF109390L();
sl@0	2893
sl@0	2894	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4024 DEF116043: Cenrep doesn't protect against overflows in sorting "));
sl@0	2895	DEF116043L();
sl@0	2896
sl@0	2897	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4035 DEF117987: CenrepNotify handler does not leave/return error "));
sl@0	2898	DEF117987L();
sl@0	2899
sl@0	2900	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4034 DEF117848: Centrep notifier handler does not check return codes "));
sl@0	2901	DEF117848L();
sl@0	2902
sl@0	2903	TheTest.Next(_L(" @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036 DEF118107: Central Repository Notification Handler flooded with notifications "));
sl@0	2904	DEF118107L();
sl@0	2905
sl@0	2906	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4037 DEF116629: CentralRepository internal merge function need to be refactored and documented"));
sl@0	2907	DEF116629L();
sl@0	2908
sl@0	2909	TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4046 PDEF126904 - Ini-file parsing of Symbian provided central repository server crashes"));
sl@0	2910	PDEF126904L();
sl@0	2911	TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4081 DEF132807 - CObservable::ObserverSortOrder ordering algorithm is wrong "));
sl@0	2912	DEF132807L();
sl@0	2913
sl@0	2914	TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4084 DEF136161: CenRep file timestamp is never intialised "));
sl@0	2915	DEF136161L();
sl@0	2916
sl@0	2917	TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4085 PDEF139979: Central Repository: Trying to configure Central Repository cache with centrep.in "));
sl@0	2918	PDEF139979L();
sl@0	2919
sl@0	2920	TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4086 PDEF141518: centralrepositorysrv.exe crashes and phone doesn't boot up "));
sl@0	2921	PDEF141519L();
sl@0	2922
sl@0	2923	TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-CT-XXXX DEF143352: CentralRepository server crash in CObservable::RefreshTransactorAccessPolicies "));
sl@0	2924	DEF143352L();
sl@0	2925
sl@0	2926	TheTest.End();
sl@0	2927	}
sl@0	2928
sl@0	2929	LOCAL_C void MainL()
sl@0	2930	{
sl@0	2931	TheTest.Start(_L("Defect tests"));
sl@0	2932	CleanupCDriveL();
sl@0	2933
sl@0	2934	FuncTestsL();
sl@0	2935
sl@0	2936	TheTest.Next(_L("Clean out C: files"));
sl@0	2937	CleanupCDriveL();
sl@0	2938
sl@0	2939	TheTest.End();
sl@0	2940	TheTest.Close();
sl@0	2941	}
sl@0	2942
sl@0	2943	TInt E32Main()
sl@0	2944	{
sl@0	2945	//
sl@0	2946	// For the tests to work we need SID policing enforced plus the specific
sl@0	2947	// capabilities listed below.
sl@0	2948	//
sl@0	2949	// These are dependent on the capabilities set in the platform security
sl@0	2950	// repository test initialisation file 87654321.txt. If the content
sl@0	2951	// of that file changes then the following clauses may need to be
sl@0	2952	// updated.
sl@0	2953	//
sl@0	2954	if(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) \|\|
sl@0	2955	!PlatSec::IsCapabilityEnforced(ECapabilityNetworkServices) \|\|
sl@0	2956	!PlatSec::IsCapabilityEnforced(ECapabilityDRM) \|\|
sl@0	2957	!PlatSec::IsCapabilityEnforced(ECapabilityLocalServices) \|\|
sl@0	2958	!PlatSec::IsCapabilityEnforced(ECapabilityCommDD))
sl@0	2959	{
sl@0	2960	TheTest.Start(_L("NOTE: Skipping tests due to incompatible PlatSec enforcement settings"));
sl@0	2961	TheTest.End();
sl@0	2962	TheTest.Close();
sl@0	2963	return 0;
sl@0	2964	}
sl@0	2965
sl@0	2966	__UHEAP_MARK;
sl@0	2967	CTrapCleanup* cleanup = CTrapCleanup::New();
sl@0	2968	if(!cleanup)
sl@0	2969	return KErrNoMemory;
sl@0	2970
sl@0	2971	TRAPD(err, MainL());
sl@0	2972	if (err != KErrNone)
sl@0	2973	User::Panic(_L("Testing failed: "), err);
sl@0	2974
sl@0	2975	delete cleanup;
sl@0	2976	__UHEAP_MARKEND;
sl@0	2977
sl@0	2978	return 0;
sl@0	2979	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--