1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "t_cenrep_helper.h"

    17 #include <centralrepository.h>

    18 #include <e32test.h>

    19 #include <f32file.h>

    20 #include "../cenrepsrv/srvreqs.h"

    21 #include "../common/inc/srvdefs.h"

    22 #include "../cenrepsrv/srvparams.h"

    23 

    24 using namespace NCentralRepositoryConstants;

    25 

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

    27 

    28 TBool OomTesting;

    29 

    30 const TUid KUidTestRepository1 = { 0x00000001 };

    31 const TUid KUidCreTestRepository1 = { 0x22222221 };

    32 const TUid KUidTestRepository2 = { 0x00000002 };

    33 

    34 const TUid KUidCorruptRepository = { 0x00000003 };

    35 const TUid KUidResetTestRepository = { 0x00000004 };

    36 

    37 const TUid KUidDriveCRepository = { 0x00000010 };

    38 

    39 const TUid KUidDriveCOnlyRepository = { 0x00000013 };

    40 

    41 //

    42 // Test repository 1

    43 //

    44 

    45 const TUint32 KNonExisitentSetting = 0;

    46 

    47 const TInt KNumSettings = 9;

    48 

    49 const TUint32 KInt1 = 1;

    50 const TInt KInt1_InitialValue = 1;

    51 const TInt KInt1_UpdatedValue = 73;

    52 const TUint32 KInt3 = 257;

    53 const TUint32 KNewInt = 1000;

    54 

    55 const TUint32 KReal1 = 2;

    56 const TReal KReal1_InitialValue = 2.732;

    57 const TReal KReal1_UpdatedValue = 72.8;

    58 const TUint32 KReal2 = 8;

    59 const TReal KReal2_InitialValue = 1.5;

    60 const TUint32 KReal3 = 17;

    61 const TUint32 KNewReal = 2000;

    62 

    63 const TUint32 KString1 = 5;

    64 _LIT(KString1_InitialValue, "test\\\"string\"");

    65 _LIT(KString1_UpdatedValue, "another one");

    66 const TUint32 KString2 = 12;

    67 _LIT8(KString2_8BitValue, "string");

    68 

    69 const TUint32 KString12 = 12;

    70 const TUint32 KNewString8 = 3000;

    71 const TUint32 KNewString16 = 4000;

    72 

    73 const TUint32 KNewSetting1 = 0x2001;

    74 const TUint32 KNewSetting2 = 0x2002;

    75 const TUint32 KNewSetting3 = 0x2003;

    76 const TUint32 KNewSetting4 = 0x2004;

    77 const TUint32 KNewSetting5 = 0x2005;

    78 const TUint32 KNewSetting6 = 0x2006;

    79 const TUint32 KNewSetting7 = 0x2007;

    80 const TUint32 KNewSetting8 = 0x2008;

    81 

    82 const TInt32 KNewSetting1Value = 4567;

    83 const TReal KNewSetting2Value = 45.67;

    84 _LIT(KNewSetting3Value, "a unicode str");

    85 _LIT8(KNewSetting4Value, "an ascii str");

    86 const TInt32 KNewSetting5Value = 2389;

    87 const TReal KNewSetting6Value = 23.89;

    88 _LIT(KNewSetting7Value, "another unicode str");

    89 _LIT8(KNewSetting8Value, "another ascii str");

    90 

    91 

    92 //

    93 // Test repository 2

    94 //

    95 

    96 const TInt KIntB1 = 807;

    97 const TInt KIntB1_InitialValue = 100;

    98 

    99 

   100 

   101 ///////////////////////////////////////////////////////////////////////////////////////

   102 ///////////////////////////////////////////////////////////////////////////////////////

   103 //Test macroses and functions

   104 

   105 LOCAL_C void CheckL(TInt aValue, TInt aLine)

   106 	{

   107 	if(!aValue)

   108 		{

   109 		CleanupCDriveL();

   110 		TheTest(EFalse, aLine);

   111 		}

   112 	}

   113 LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)

   114 	{

   115 	if(aValue != aExpected)

   116 		{

   117 		CleanupCDriveL();

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

   119 		TheTest(EFalse, aLine);

   120 		}

   121 	}

   122 #define TEST(arg) ::CheckL((arg), __LINE__)

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

   124 

   125 ///////////////////////////////////////////////////////////////////////////////////////

   126 ///////////////////////////////////////////////////////////////////////////////////////

   127 

   128 LOCAL_C void KillCentRepServerL()

   129 	{

   130 	_LIT(KCentralRepositoryServerName, "Centralrepositorysrv");

   131 	_LIT(KProcessKillProcess, "t_processkillprocess.exe");

   132 	

   133 	TRequestStatus stat;    

   134 	RProcess p;

   135 	User::LeaveIfError(p.Create(KProcessKillProcess, KCentralRepositoryServerName));

   136 

   137 	// Asynchronous logon: completes when process terminates with process 

   138 	// exit code

   139 	p.Logon(stat);

   140 	p.Resume();

   141 	User::WaitForRequest(stat);

   142 

   143 	TExitType exitType = p.ExitType();

   144 	TInt exitReason = p.ExitReason();

   145 	

   146 	_LIT(KKillServerFailed, "Killing Central Repository Server Failed");

   147 	__ASSERT_ALWAYS(exitType == EExitKill, User::Panic(KKillServerFailed, exitReason));

   148 

   149 	p.Close();

   150 	User::LeaveIfError(exitReason);

   151 	}

   152 

   153 //This function resets the KUidTestRepository1 repository

   154 //to its intial state to remove any changes made to the repository during

   155 //previous tests

   156 LOCAL_C void ResetTestRepositoryL()

   157 	{

   158 	CRepository* repository;

   159 

   160 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));

   161 	TInt r = repository->Reset();

   162 	TEST2(r, KErrNone);

   163 	CleanupStack::PopAndDestroy(repository);

   164 	}

   165 

   166 //This function restores the state of the files required for this test

   167 //Existing files are deleted and then the required files are copied

   168 //back from the Z drive to the c drive

   169 LOCAL_C void RestoreTestFilesL()

   170 	{

   171 	//Delete all files from C:\\private\\10202BE9\\persists\\ dir

   172 	//and C:\\private\\10202BE9\\ dir

   173 	CleanupCDriveL();

   174 

   175 	RFs fs;

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

   177 	CleanupClosePushL(fs);

   178 

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

   180 	CleanupStack::PushL(fm);

   181 

   182 //	_LIT(KPersistTargetPath, "c:\\private\\10202BE9\\persists\\*.txt");

   183 	_LIT(KPersistTargetPath, "z:\\private\\10202BE9\\*.txt");

   184 	_LIT(KPersistSourcePath, "Z:\\private\\10202BE9\\*.txc");

   185 	_LIT(KInstallTargetPath, "C:\\private\\10202BE9\\*.txt");

   186 	_LIT(KInstallSourcePath, "Z:\\private\\10202BE9\\*.txi");

   187 

   188 	//copy test files from Z: to C:

   189 	CopyTestFilesL(*fm,KPersistSourcePath, KPersistTargetPath);

   190 	CopyTestFilesL(*fm,KInstallSourcePath, KInstallTargetPath);

   191 

   192 	CleanupStack::PopAndDestroy(2);

   193 

   194 	}

   195 

   196 

   197 /**

   198 @SYMTestCaseID			SYSLIB-CENTRALREPOSITORY-CT-1297

   199 @SYMTestCaseDesc		Tests for creation and opening a central repository

   200 @SYMTestPriority		High

   201 @SYMTestActions			Tests for CRepository::NewLC(),CRepository::Get() functions

   202 @SYMTestExpectedResults Test must not fail

   203 @SYMREQ					REQ0000

   204 */

   205 LOCAL_C void OpenRepositoryL()

   206 	{

   207 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1297 "));

   208 	CRepository* repositoryA;

   209 	CRepository* repositoryB;

   210 

   211 	TInt r;

   212 

   213 	// When an attempt is made to open a central repository in this test the result will

   214 	// be that a new session (+ subsession) will be created with the server. For subsequent

   215 	// central repository openings subsessions are then created under the same server.

   216 	// Note that by placing the CRepository creation calls in the following order we

   217 	// are exercising among other things the following scenarios:

   218 	// 1. Session is opened and first subsession is created. Error occurs, whole session

   219 	// is pulled down.

   220 	// 2. Session is opened and first subsession is successfully created. 2nd subsession

   221 	// is opened. Error occurs with 2nd subsession. 2nd subsession is pulled down. Session

   222 	// and first sub-sesssion remain up. (DEF105089)

   223 

   224 	TRAP(r, CRepository::NewL(TUid::Null()));

   225 	if(OomTesting && r==KErrNoMemory)

   226 		User::Leave(KErrNoMemory);

   227 	TEST2(r, KErrNotFound);

   228 

   229 	repositoryB = CRepository::NewLC(KUidTestRepository2);

   230 

   231 	TRAP(r, CRepository::NewL(KUidCorruptRepository));

   232 	if(OomTesting && r==KErrNoMemory)

   233 		User::Leave(KErrNoMemory);

   234 	TEST2(r, KErrCorrupt);

   235 

   236  	repositoryA = CRepository::NewLC(KUidTestRepository1);

   237 

   238 	TInt a;

   239 	r = repositoryA->Get(KInt1, a);

   240 	TEST2(r, KErrNone);

   241 	TEST(a==KInt1_InitialValue);

   242 

   243 	r = repositoryB->Get(KIntB1, a);

   244 	TEST2(r, KErrNone);

   245 	TEST(a==KIntB1_InitialValue);

   246 

   247 	CleanupStack::PopAndDestroy(repositoryA);

   248 

   249 	r = repositoryB->Get(KIntB1, a);

   250 	TEST2(r, KErrNone);

   251 	TEST(a==KIntB1_InitialValue);

   252 

   253 	CleanupStack::PopAndDestroy(repositoryB);

   254 	}

   255 

   256 /**

   257 @SYMTestCaseID			SYSLIB-CENTRALREPOSITORY-CT-1298

   258 @SYMTestCaseDesc		Tests for CRepository's Integer,Real,String's Get and Set functions

   259 @SYMTestPriority		High

   260 @SYMTestActions			Tests for CRepository::Get(),CRepository::Set() functions

   261 @SYMTestExpectedResults Test must not fail

   262 @SYMREQ					REQ0000

   263 */

   264 LOCAL_C void GetSetL(const TUid& aUid)

   265 	{

   266 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1298 "));

   267 	CRepository* repository;

   268 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   269 

   270 	_LIT8(KString12_InitialValue, "string");

   271 	TPtrC8 p8(KString12_InitialValue);

   272 

   273 	_LIT(KString11_InitialValue, "string");

   274 	TPtrC p16(KString11_InitialValue);

   275 

   276 	TBuf8<20> str8;

   277 	TBuf<20> str;

   278 	TInt i = 0;

   279 

   280 	//

   281 	// Integer get/set

   282 	//

   283 

   284 	TInt r = repository->Get(KNonExisitentSetting, i);

   285 	TEST2(r, KErrNotFound);

   286 	TEST(i==0);

   287 

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

   289 	TEST2(r, KErrArgument);

   290 	TEST(i==0);

   291 

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

   293 	TEST2(r, KErrNone);

   294 	TEST(i==KInt1_InitialValue);

   295 

   296 	r = repository->Get(KNonExisitentSetting, i);

   297 	TEST2(r, KErrNotFound);

   298 

   299 	r = repository->Set(KNonExisitentSetting, 10);

   300 	TEST2(r, KErrNone);

   301 

   302 	//close and reopen rep to check set is persisted

   303 	CleanupStack::PopAndDestroy(repository);

   304 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   305 

   306 	r = repository->Get(KNonExisitentSetting, i);

   307 	TEST2(r, KErrNone);

   308 	TEST(i==10);

   309 

   310 	r = repository->Delete(KNonExisitentSetting);

   311 	TEST2(r, KErrNone);

   312 

   313 	r = repository->Set(KReal1, 0);

   314 	TEST2(r, KErrArgument);

   315 

   316 	r = repository->Set(KInt1, KInt1_UpdatedValue);

   317 	TEST2(r, KErrNone);

   318 

   319 	//close and reopen rep to check set is persisted

   320 	CleanupStack::PopAndDestroy(repository);

   321 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   322 

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

   324 	TEST2(r, KErrNone);

   325 	TEST(i==KInt1_UpdatedValue);

   326 

   327 	r = repository->Get(KInt1,str8);

   328 	TEST2(r, KErrArgument);

   329 	//checks if KInt was modified

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

   331 	TEST2(r, KErrNone);

   332 	TEST(i==KInt1_UpdatedValue);

   333 

   334 	r = repository->Set(KInt1, KString12_InitialValue);

   335 	TEST2(r, KErrArgument);

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

   337 	TEST2(r, KErrNone);

   338 	TEST(i==KInt1_UpdatedValue);

   339 

   340 	r = repository->Get(KInt1,str);

   341 	TEST2(r, KErrArgument);

   342 	//checks if KInt was modified

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

   344 	TEST2(r, KErrNone);

   345 	TEST(i==KInt1_UpdatedValue);

   346 

   347 	r = repository->Set(KInt1, KString11_InitialValue);

   348 	TEST2(r, KErrArgument);

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

   350 	TEST2(r, KErrNone);

   351 	TEST(i==KInt1_UpdatedValue);

   352 	//

   353 	// Real get/set

   354 	//

   355 

   356 	TReal y = 0;

   357 

   358 	r = repository->Get(KNonExisitentSetting, y);

   359 	TEST2(r, KErrNotFound);

   360 	TEST(y==0);

   361 

   362 	r = repository->Get(KInt1, y);

   363 	TEST2(r, KErrArgument);

   364 	TEST(y==0);

   365 

   366 	r = repository->Get(KReal1, y);

   367 	TEST2(r, KErrNone);

   368 	TEST(y==KReal1_InitialValue);

   369 

   370 	r = repository->Get(KNonExisitentSetting, y);

   371 	TEST2(r, KErrNotFound);

   372 

   373 	r = repository->Set(KNonExisitentSetting, 0.0);

   374 	TEST2(r, KErrNone);

   375 

   376 	//close and reopen rep to check set is persisted

   377 	CleanupStack::PopAndDestroy(repository);

   378 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   379 

   380 	r = repository->Get(KNonExisitentSetting, y);

   381 	TEST2(r, KErrNone);

   382 	TEST(y == 0.0);

   383 

   384 	r = repository->Delete(KNonExisitentSetting);

   385 	TEST2(r, KErrNone);

   386 

   387 	r = repository->Set(KInt1, 0.0);

   388 	TEST2(r, KErrArgument);

   389 

   390 	r = repository->Set(KReal1, KReal1_UpdatedValue);

   391 	TEST2(r, KErrNone);

   392 

   393 	//close and reopen rep to check set is persisted

   394 	CleanupStack::PopAndDestroy(repository);

   395 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   396 

   397 	r = repository->Get(KReal1, y);

   398 	TEST2(r, KErrNone);

   399 	TEST(y==KReal1_UpdatedValue);

   400 

   401 	r = repository->Get(KReal1,str8);

   402 	TEST2(r, KErrArgument);

   403 	//checks if KInt was modified

   404 	r = repository->Get(KReal1, y);

   405 	TEST2(r, KErrNone);

   406 	TEST(y==KReal1_UpdatedValue);

   407 

   408 	r = repository->Get(KReal1,str);

   409 	TEST2(r, KErrArgument);

   410 	//checks if KInt was modified

   411 	r = repository->Get(KReal1, y);

   412 	TEST2(r, KErrNone);

   413 	TEST(y==KReal1_UpdatedValue);

   414 

   415 	r = repository->Set(KReal1, KString12_InitialValue);

   416 	TEST2(r, KErrArgument);

   417 	r = repository->Get(KReal1, y);

   418 	TEST2(r, KErrNone);

   419 	TEST(y==KReal1_UpdatedValue);

   420 

   421 	r = repository->Set(KReal1, KString11_InitialValue);

   422 	TEST2(r, KErrArgument);

   423 	r = repository->Get(KReal1, y);

   424 	TEST2(r, KErrNone);

   425 	TEST(y==KReal1_UpdatedValue);

   426 

   427 	//

   428 	// String get/set

   429 	//

   430 	r = repository->Get(KNonExisitentSetting, str);

   431 	TEST2(r, KErrNotFound);

   432 	TEST(str.Length()==0);

   433 

   434 	r = repository->Get(KInt1, str);

   435 	TEST2(r, KErrArgument);

   436 	TEST(str.Length()==0);

   437 

   438 	r = repository->Get(KString1, str);

   439 	TEST2(r, KErrNone);

   440 	TEST(str==KString1_InitialValue);

   441 

   442 	TBuf<10> tooShort;

   443 	r = repository->Get(KString1, tooShort);

   444 	TEST2(r, KErrOverflow);

   445 	TEST(tooShort.Length()==10);

   446 

   447 	r = repository->Get(KNonExisitentSetting, str);

   448 	TEST2(r, KErrNotFound);

   449 

   450 	r = repository->Set(KNonExisitentSetting, KString1_UpdatedValue);

   451 	TEST2(r, KErrNone);

   452 

   453 	//close and reopen rep to check set is persisted

   454 	CleanupStack::PopAndDestroy(repository);

   455 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   456 

   457 	r = repository->Get(KNonExisitentSetting, str);

   458 	TEST2(r, KErrNone);

   459 	TEST(str==KString1_UpdatedValue);

   460 

   461 	r = repository->Delete(KNonExisitentSetting);

   462 	TEST2(r, KErrNone);

   463 

   464 	r = repository->Set(KInt1, str);

   465 	TEST2(r, KErrArgument);

   466 

   467 	r = repository->Set(KString1, KString1_UpdatedValue);

   468 	TEST2(r, KErrNone);

   469 

   470 	//close and reopen rep to check set is persisted

   471 	CleanupStack::PopAndDestroy(repository);

   472 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   473 

   474 	r = repository->Get(KString1, str);

   475 	TEST2(r, KErrNone);

   476 	TEST(str==KString1_UpdatedValue);

   477 

   478 	//testing the new feature: creating an 8 bit string from ini file.

   479 	r = repository->Get(KString12, str8);

   480 	TEST2(r, KErrNone);

   481 	TEST(str8==KString12_InitialValue);

   482 

   483 	//get 8-bit string with int

   484 	r = repository->Get(KString12, i);

   485 	TEST2(r, KErrArgument);

   486 	r = repository->Get(KString12, str8);

   487 	TEST2(r, KErrNone);

   488 	TEST(str8==KString12_InitialValue);

   489 

   490 	//get 8-bit string with real

   491 	r = repository->Get(KString12, y);

   492 	TEST2(r, KErrArgument);

   493 	r = repository->Get(KString12, str8);

   494 	TEST2(r, KErrNone);

   495 	TEST(str8==KString12_InitialValue);

   496 

   497 	//set 8-bit string with int

   498 	r = repository->Set(KString12, i);

   499 	TEST2(r, KErrArgument);

   500 	r = repository->Get(KString12, str8);

   501 	TEST2(r, KErrNone);

   502 	TEST(str8==KString12_InitialValue);

   503 

   504 	//set 8-bit string with real

   505 	r = repository->Set(KString12, y);

   506 	TEST2(r, KErrArgument);

   507 	r = repository->Get(KString12, str8);

   508 	TEST2(r, KErrNone);

   509 	TEST(str8==KString12_InitialValue);

   510 

   511 

   512 	//get 16-bit string with int

   513 	r = repository->Get(KString1,i);

   514 	TEST2(r, KErrArgument);

   515 	//checks if a string was modified

   516 	r = repository->Get(KString1, str);

   517 	TEST2(r, KErrNone);

   518 	TEST(str==KString1_UpdatedValue);

   519 

   520 	//get 16-bit string with real

   521 	r = repository->Get(KString1,y);

   522 	TEST2(r, KErrArgument);

   523 	//checks if a string was modified

   524 	r = repository->Get(KString1, str);

   525 	TEST2(r, KErrNone);

   526 	TEST(str==KString1_UpdatedValue);

   527 

   528 	//set 16-bit string with int

   529 	r = repository->Set(KString1,i);

   530 	TEST2(r, KErrArgument);

   531 	//checks if a string was modified

   532 	r = repository->Get(KString1, str);

   533 	TEST2(r, KErrNone);

   534 	TEST(str==KString1_UpdatedValue);

   535 

   536 	//set 16-bit string with real

   537 	r = repository->Set(KString1,y);

   538 	TEST2(r, KErrArgument);

   539 	//checks if a string was modified

   540 	r = repository->Get(KString1, str);

   541 	TEST2(r, KErrNone);

   542 	TEST(str==KString1_UpdatedValue);

   543 

   544 	const TInt KStringLengthTooBig = KMaxUnicodeStringLength  + 1;

   545 	TBuf<KStringLengthTooBig> tooBig;

   546 	tooBig.SetLength(KStringLengthTooBig);

   547 	r = repository->Set(KString1, tooBig);

   548 	TEST2(r, KErrArgument);

   549 

   550 	//- Test null descriptors

   551 	r = repository->Set(KString1, KNullDesC);

   552 	TEST2(r, KErrNone);

   553 

   554 	CleanupStack::PopAndDestroy(repository);

   555 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   556 

   557 	r = repository->Get(KString1, str);

   558 	TEST2(r, KErrNone);

   559 	TEST(str==KNullDesC);

   560 

   561 	r = repository->Set(KString1, KString1_UpdatedValue);

   562 	TEST2(r, KErrNone);

   563 

   564 	//close and reopen rep to check set is persisted

   565 	CleanupStack::PopAndDestroy(repository);

   566 	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

   567 

   568 	r = repository->Get(KString1, str);

   569 	TEST2(r, KErrNone);

   570 	TEST(str==KString1_UpdatedValue);

   571 	//-

   572 

   573 	// Check that the SetGetParameters interface returns KErrNotSupported in the default macro configuration

   574 #if !defined(__CENTREP_SERVER_PERFTEST__) && !defined(__CENTREP_SERVER_MEMTEST__) && !defined(__CENTREP_SERVER_CACHETEST__)

   575 	TIpcArgs args;

   576 	r = SetGetParameters(args);

   577 	TEST2(r, KErrNotSupported);

   578 #endif

   579 

   580 	CleanupStack::PopAndDestroy(repository);

   581 	}

   582 

   583 /**

   584 @SYMTestCaseID			SYSLIB-CENTRALREPOSITORY-CT-1299

   585 @SYMTestCaseDesc		Tests for CRepository class's find operations

   586 @SYMTestPriority		High

   587 @SYMTestActions			Tests for CRepository::FindL(),CRepository::FindEqL(),CRepository::FindNeqL() functions

   588 @SYMTestExpectedResults Test must not fail

   589 @SYMREQ					REQ0000

   590 */

   591 LOCAL_C void FindL()

   592 	{

   593 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1299 "));

   594 	CRepository* repository;

   595 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));

   596 

   597 	RArray<TUint32> foundIds;

   598 

   599 	TInt r = KErrNone;

   600 	TInt leaveCode = KErrNone;

   601 	TRAP(leaveCode, r = repository->FindL(0, 0, foundIds));

   602 	if (leaveCode != KErrNone)

   603 		r = leaveCode ;

   604 

   605 	if(OomTesting && r==KErrNoMemory)

   606 		{

   607 		foundIds.Close();

   608 		User::Leave(KErrNoMemory);

   609 		}

   610 

   611 	TEST2(r, KErrNone);

   612 	TEST(foundIds.Count()==KNumSettings);

   613 	foundIds.Reset();

   614 

   615 	/***************************************************************************************/

   616 	//Tests for FindL

   617 	/***************************************************************************************/

   618 	TRAP(leaveCode, r = repository->FindL(23, 0, foundIds));  // 23 - just a random number, value is not important

   619 	if (leaveCode != KErrNone)

   620 		r = leaveCode ;

   621 	if(OomTesting && r==KErrNoMemory)

   622 	{

   623 		foundIds.Close();

   624 		User::Leave(KErrNoMemory);

   625 		}

   626 	TEST2(r, KErrNone);

   627 	TEST(foundIds.Count()==KNumSettings);

   628 	foundIds.Reset();

   629 

   630 

   631 	TRAP(leaveCode, r=repository->FindL(0, 2, foundIds));

   632 	if (leaveCode != KErrNone)

   633 		r = leaveCode ;

   634 	if(OomTesting && r==KErrNoMemory)

   635 	{

   636 		foundIds.Close();

   637 		User::Leave(KErrNoMemory);

   638 		}

   639 	TEST2(r, KErrNone);

   640 	TEST(foundIds.Count()==6);

   641 	foundIds.Reset();

   642 

   643 

   644 	TRAP(leaveCode, r=repository->FindL(4, 6, foundIds));

   645 	if (leaveCode != KErrNone)

   646 		r = leaveCode ;

   647 	if(OomTesting && r==KErrNoMemory)

   648 		{

   649 		foundIds.Close();

   650 		User::Leave(KErrNoMemory);

   651 		}

   652 	TEST2(r, KErrNone);

   653 	TEST(foundIds.Count()==2);

   654 	foundIds.Reset();

   655 

   656 

   657 

   658 	TRAP(leaveCode, r= repository->FindL(15, 15, foundIds));

   659 	if (leaveCode != KErrNone)

   660 		r = leaveCode ;

   661 	if(OomTesting && r==KErrNoMemory)

   662 		{

   663 		foundIds.Close();

   664 		User::Leave(KErrNoMemory);

   665 		}

   666 	TEST2(r, KErrNotFound);

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

   668 

   669 

   670 	/***************************************************************************************/

   671 	//Tests for FindEqL for Int

   672 	/***************************************************************************************/

   673 	TRAP(leaveCode, r= repository->FindEqL(0, 0, KInt1_UpdatedValue, foundIds));

   674 	if (leaveCode != KErrNone)

   675 		r = leaveCode ;

   676 	if(OomTesting && r==KErrNoMemory)

   677 		{

   678 		foundIds.Close();

   679 		User::Leave(KErrNoMemory);

   680 		}

   681 	TEST2(r, KErrNone);

   682 	TEST(foundIds.Count()==1);

   683 	TEST(foundIds[0]==KInt1);

   684 	foundIds.Reset();

   685 

   686 

   687 	TRAP(leaveCode, r= repository->FindEqL(0, 0, 0, foundIds));

   688 	if (leaveCode != KErrNone)

   689 		r = leaveCode ;

   690 	if(OomTesting && r==KErrNoMemory)

   691 		{

   692 		foundIds.Close();

   693 		User::Leave(KErrNoMemory);

   694 		}

   695 	TEST2(r, KErrNotFound);

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

   697 

   698 

   699 	/***************************************************************************************/

   700 	//Tests for FindEqL for Real

   701 	/***************************************************************************************/

   702 	TRAP(leaveCode, r= repository->FindEqL(0, 0, KReal2_InitialValue, foundIds));

   703 	if (leaveCode != KErrNone)

   704 		r = leaveCode ;

   705 	if(OomTesting && r==KErrNoMemory)

   706 		{

   707 		foundIds.Close();

   708 		User::Leave(KErrNoMemory);

   709 		}

   710 	TEST2(r, KErrNone);

   711 	TEST(foundIds.Count()==2);

   712 	TEST(foundIds[0]==KReal2);

   713 	TEST(foundIds[1]==KReal3);

   714 	foundIds.Reset();

   715 

   716 

   717 	TRAP(leaveCode, r= repository->FindEqL(0, 0, 7.7, foundIds));

   718 	if (leaveCode != KErrNone)

   719 		r = leaveCode ;

   720 	if(OomTesting && r==KErrNoMemory)

   721 		{

   722 		foundIds.Close();

   723 		User::Leave(KErrNoMemory);

   724 		}

   725 	TEST2(r, KErrNotFound);

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

   727 

   728 

   729 	/***************************************************************************************/

   730 	//Tests for FindEqL for String

   731 	/***************************************************************************************/

   732 	TRAP(leaveCode, r= repository->FindEqL(0, 0, KString1_UpdatedValue, foundIds));

   733 	if (leaveCode != KErrNone)

   734 		r = leaveCode ;

   735 	if(OomTesting && r==KErrNoMemory)

   736 		{

   737 		foundIds.Close();

   738 		User::Leave(KErrNoMemory);

   739 		}

   740 	TEST2(r, KErrNone);

   741 	TEST(foundIds.Count()==1);

   742 	TEST(foundIds[0]==KString1);

   743 	foundIds.Reset();

   744 

   745 	_LIT(KFoo, "foo");

   746 

   747 	TRAP(leaveCode, r= repository->FindEqL(0, 0, KFoo, foundIds));

   748 	if (leaveCode != KErrNone)

   749 		r = leaveCode ;

   750 	if(OomTesting && r==KErrNoMemory)

   751 		{

   752 		foundIds.Close();

   753 		User::Leave(KErrNoMemory);

   754 		}

   755 	TEST2(r, KErrNotFound);

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

   757 

   758 	/***************************************************************************************/

   759 	//Tests for FindEqL for String8

   760 	/***************************************************************************************/

   761 	TRAP(leaveCode, r= repository->FindEqL(0, 0, KString2_8BitValue, foundIds));

   762 	if (leaveCode != KErrNone)

   763 		r = leaveCode ;

   764 	if(OomTesting && r==KErrNoMemory)

   765 		{

   766 		foundIds.Close();

   767 		User::Leave(KErrNoMemory);

   768 		}

   769 	TEST2(r, KErrNone);

   770 	TEST(foundIds.Count()==1);

   771 	TEST(foundIds[0]==KString2);

   772 	foundIds.Reset();

   773 

   774 	_LIT8(KFoo8, "foo");

   775 

   776 	TRAP(leaveCode, r= repository->FindEqL(0, 0, KFoo8, foundIds));

   777 	if (leaveCode != KErrNone)

   778 		r = leaveCode ;

   779 	if(OomTesting && r==KErrNoMemory)

   780 		{

   781 		foundIds.Close();

   782 		User::Leave(KErrNoMemory);

   783 		}

   784 	TEST2(r, KErrNotFound);

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

   786 

   787 	/***************************************************************************************/

   788 	//Tests for FindNeqL for Int

   789 	/***************************************************************************************/

   790 	TRAP(leaveCode, r= repository->FindNeqL(0, 0, KInt1_UpdatedValue, foundIds));

   791 	if (leaveCode != KErrNone)

   792 		r = leaveCode ;

   793 	if(OomTesting && r==KErrNoMemory)

   794 		{

   795 		foundIds.Close();

   796 		User::Leave(KErrNoMemory);

   797 		}

   798 	TEST2(r, KErrNone);

   799 	TEST(foundIds.Count()==8);

   800 	TEST2(foundIds.Find(KInt1), KErrNotFound);

   801 	foundIds.Reset();

   802 

   803 

   804 	TRAP(leaveCode, r= repository->FindNeqL(25, 25, KInt1_UpdatedValue, foundIds));

   805 	if (leaveCode != KErrNone)

   806 		r = leaveCode ;

   807 	if(OomTesting && r==KErrNoMemory)

   808 		{

   809 		foundIds.Close();

   810 		User::Leave(KErrNoMemory);

   811 		}

   812 	TEST2(r, KErrNotFound);

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

   814 

   815 

   816 	/***************************************************************************************/

   817 	//Tests for FindNeqL for Real

   818 	/***************************************************************************************/

   819 	TRAP(leaveCode, r= repository->FindNeqL(0, 0, KReal1_UpdatedValue, foundIds));

   820 	if (leaveCode != KErrNone)

   821 		r = leaveCode ;

   822 	if(OomTesting && r==KErrNoMemory)

   823 		{

   824 		foundIds.Close();

   825 		User::Leave(KErrNoMemory);

   826 		}

   827 	TEST2(r, KErrNone);

   828 	TEST(foundIds.Count()==8);

   829 	TEST2(foundIds.Find(KReal1), KErrNotFound);

   830 	foundIds.Reset();

   831 

   832 

   833 	TRAP(leaveCode,r= repository->FindNeqL(25, 25, KReal1_UpdatedValue, foundIds));

   834 	if (leaveCode != KErrNone)

   835 		r = leaveCode ;

   836 	if(OomTesting && r==KErrNoMemory)

   837 		{

   838 		foundIds.Close();

   839 		User::Leave(KErrNoMemory);

   840 		}

   841 	TEST2(r, KErrNotFound);

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

   843 

   844 

   845 	/***************************************************************************************/

   846 	//Tests for FindNeqL for String

   847 	/***************************************************************************************/

   848 	TRAP(leaveCode, r= repository->FindNeqL(0, 0, KString1_UpdatedValue, foundIds));

   849 	if (leaveCode != KErrNone)

   850 		r = leaveCode ;

   851 	if(OomTesting && r==KErrNoMemory)

   852 		{

   853 		foundIds.Close();

   854 		User::Leave(KErrNoMemory);

   855 		}

   856 	TEST2(r, KErrNone);

   857 	TEST(foundIds.Count()==8);

   858 	TEST2(foundIds.Find(KString1), KErrNotFound);

   859 	foundIds.Reset();

   860 

   861 

   862 	TRAP(leaveCode, r= repository->FindNeqL(25, 25, KString1_UpdatedValue, foundIds));

   863 	if (leaveCode != KErrNone)

   864 		r = leaveCode ;

   865 	if(OomTesting && r==KErrNoMemory)

   866 		{

   867 		foundIds.Close();

   868 		User::Leave(KErrNoMemory);

   869 		}

   870 	TEST2(r, KErrNotFound);

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

   872 

   873 	/***************************************************************************************/

   874 	//Tests for FindNeqL for String8

   875 	/***************************************************************************************/

   876 	TRAP(leaveCode, r= repository->FindNeqL(0, 0, KString2_8BitValue, foundIds));

   877 	if (leaveCode != KErrNone)

   878 		r = leaveCode ;

   879 	if(OomTesting && r==KErrNoMemory)

   880 		{

   881 		foundIds.Close();

   882 		User::Leave(KErrNoMemory);

   883 		}

   884 	TEST2(r, KErrNone);

   885 	TEST(foundIds.Count()==8);

   886 	TEST2(foundIds.Find(KString2), KErrNotFound);

   887 	foundIds.Reset();

   888 

   889 

   890 	TRAP(leaveCode, r= repository->FindNeqL(25, 25, KString2_8BitValue, foundIds));

   891 	if (leaveCode != KErrNone)

   892 		r = leaveCode ;

   893 	if(OomTesting && r==KErrNoMemory)

   894 		{

   895 		foundIds.Close();

   896 		User::Leave(KErrNoMemory);

   897 		}

   898 	TEST2(r, KErrNotFound);

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

   900 

   901 	CleanupStack::PopAndDestroy(repository);

   902 	}

   903 

   904 /**

   905 @SYMTestCaseID			SYSLIB-CENTRALREPOSITORY-CT-1300

   906 @SYMTestCaseDesc		CRepository class functionality test

   907 @SYMTestPriority		High

   908 @SYMTestActions			Test for CRepository::NotifyRequest() functions

   909 @SYMTestExpectedResults Test must not fail

   910 @SYMREQ					REQ0000

   911 */

   912 LOCAL_C void NotifyL()

   913 	{

   914 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1300 "));

   915 	CRepository* repository;

   916 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));

   917 

   918 	TInt r = KErrNone;

   919 	TInt intval;

   920 	TRequestStatus intStatus;

   921 	TRequestStatus realStatus;

   922 	TRequestStatus stringStatus;

   923 	RThread thisThread;

   924 

   925 	//

   926 	// Notification on non-existent setting

   927 	//

   928 	r = repository->NotifyRequest(KNonExisitentSetting, intStatus);

   929 	TEST2(r, KErrNotFound);

   930 

   931 	//

   932 	// Basic notification

   933 	//

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

   935 	TEST2(r, KErrNone);

   936 

   937 	r = repository->NotifyRequest(KReal1, realStatus);

   938 	TEST2(r, KErrNone);

   939 

   940 	r = repository->NotifyRequest(KString1, stringStatus);

   941 	TEST2(r, KErrNone);

   942 

   943 

   944 	// Setting to the same value should not cause a notification

   945 	r = repository->Get(KInt1, intval);

   946 	TEST2(r, KErrNone);

   947 	r = repository->Set(KInt1, intval);

   948 	TEST2(r, KErrNone);

   949 	TEST(intStatus==KRequestPending);

   950 	TEST(realStatus==KRequestPending);

   951 	TEST(stringStatus==KRequestPending);

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

   953 

   954 	// First change to setting should cause notification

   955 	r = repository->Set(KInt1, 0);

   956 	TEST2(r, KErrNone);

   957 	User::WaitForAnyRequest();

   958 	TEST(intStatus==KInt1);

   959 	TEST(realStatus==KRequestPending);

   960 	TEST(stringStatus==KRequestPending);

   961 

   962 	// Second change to setting should not cause notification

   963 	intStatus = 7777;

   964 	r = repository->Set(KInt1, 0);

   965 	TEST2(r, KErrNone);

   966 	TEST(intStatus==7777);

   967 	TEST(realStatus==KRequestPending);

   968 	TEST(stringStatus==KRequestPending);

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

   970 

   971 

   972 	// Setting to the same value should not cause a notification

   973 	TReal realval;

   974 	r = repository->Get(KReal1, realval);

   975 	TEST2(r, KErrNone);

   976 	r = repository->Set(KReal1, realval);

   977 	TEST2(r, KErrNone);

   978 	TEST(intStatus==7777);

   979 	TEST(realStatus==KRequestPending);

   980 	TEST(stringStatus==KRequestPending);

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

   982 

   983 	r = repository->Set(KReal1, 0.0);

   984 	TEST2(r, KErrNone);

   985 	User::WaitForAnyRequest();

   986 	TEST(intStatus==7777);

   987 	TEST(realStatus==KReal1);

   988 	TEST(stringStatus==KRequestPending);

   989 

   990 

   991 	// Setting to the same value should not cause a notification

   992 	realStatus = 8888;

   993 	TBuf<20> stringval;

   994 	r = repository->Get(KString1, stringval);

   995 	TEST2(r, KErrNone);

   996 	r = repository->Set(KString1, stringval);

   997 	TEST2(r, KErrNone);

   998 	TEST(intStatus==7777);

   999 	TEST(realStatus==8888);

  1000 	TEST(stringStatus==KRequestPending);

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

  1002 

  1003 	_LIT(KStringValue2, "string2");

  1004 	r = repository->Set(KString1, KStringValue2);

  1005 	TEST2(r, KErrNone);

  1006 	User::WaitForAnyRequest();

  1007 	TEST(intStatus==7777);

  1008 	TEST(realStatus==8888);

  1009 	TEST(stringStatus==KString1);

  1010 

  1011 

  1012 	//

  1013 	// Cancelling single notifications

  1014 	//

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

  1016 	TEST2(r, KErrNone);

  1017 	r = repository->NotifyCancel(KInt1);

  1018 	TEST2(r, KErrNone);

  1019 	User::WaitForAnyRequest();

  1020 	TEST(intStatus==KUnspecifiedKey);

  1021 

  1022 	intStatus = 7777;

  1023 	r = repository->NotifyRequest(KReal1, realStatus);

  1024 	TEST2(r, KErrNone);

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

  1026 	TEST2(r, KErrNone);

  1027 	r = repository->Set(KReal1, 1.1);

  1028 	TEST2(r, KErrNone);

  1029 	User::WaitForAnyRequest();

  1030 	TEST(intStatus==7777);

  1031 	TEST(realStatus==KReal1);

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

  1033 

  1034 

  1035 	//

  1036 	// Cancelling all notifications

  1037 	//

  1038 	realStatus = 8888;

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

  1040 	TEST2(r, KErrNone);

  1041 	r = repository->NotifyRequest(KReal1, realStatus);

  1042 	TEST2(r, KErrNone);

  1043 

  1044 	r = repository->NotifyCancelAll();

  1045 	TEST2(r, KErrNone);

  1046 	User::WaitForAnyRequest();

  1047 	User::WaitForAnyRequest();

  1048 	TEST(intStatus==KUnspecifiedKey);

  1049 	TEST(realStatus==KUnspecifiedKey);

  1050 

  1051 	intStatus = 7777;

  1052 	realStatus = 8888;

  1053 	r = repository->Set(KInt1, 2);

  1054 	TEST2(r, KErrNone);

  1055 	r = repository->Set(KReal1, 2.2);

  1056 	TEST2(r, KErrNone);

  1057 	TEST(intStatus==7777);

  1058 	TEST(realStatus==8888);

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

  1060 

  1061 

  1062 	//

  1063 	// Group notifications

  1064 	//

  1065 	r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus);

  1066 	TEST2(r, KErrNone);

  1067 

  1068 	r = repository->Set(KInt3, 3);

  1069 	TEST2(r, KErrNone);

  1070 	TEST(intStatus==KRequestPending);

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

  1072 

  1073 	r = repository->Set(KInt1, 3);

  1074 	TEST2(r, KErrNone);

  1075 	User::WaitForAnyRequest();

  1076 	TEST(intStatus==KInt1);

  1077 

  1078 	r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus);

  1079 	TEST2(r, KErrNone);

  1080 

  1081 	r = repository->Set(KReal1, 3.3);

  1082 	TEST2(r, KErrNone);

  1083 	User::WaitForAnyRequest();

  1084 	TEST(intStatus==KReal1);

  1085 

  1086 

  1087 	//

  1088 	// Cancelling group notifications

  1089 	//

  1090 	r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus);

  1091 	TEST2(r, KErrNone);

  1092 	r = repository->NotifyCancel(0, ~(KInt1+KReal1));

  1093 	TEST2(r, KErrNone);

  1094 	User::WaitForAnyRequest();

  1095 	TEST(intStatus==KUnspecifiedKey);

  1096 

  1097 	r = repository->Set(KInt1, 3);

  1098 	TEST2(r, KErrNone);

  1099 	TEST(intStatus==KUnspecifiedKey);

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

  1101 

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

  1103 	TEST2(r, KErrNone);

  1104 	r = repository->NotifyRequest(0, ~(KInt1+KReal1), realStatus);

  1105 	TEST2(r, KErrNone);

  1106 	r = repository->NotifyCancelAll();

  1107 	TEST2(r, KErrNone);

  1108 	User::WaitForAnyRequest();

  1109 	User::WaitForAnyRequest();

  1110 	TEST(intStatus==KUnspecifiedKey);

  1111 	TEST(realStatus==KUnspecifiedKey);

  1112 

  1113 	r = repository->Set(KInt1, 4);

  1114 	TEST2(r, KErrNone);

  1115 	TEST(intStatus==KUnspecifiedKey);

  1116 	TEST(realStatus==KUnspecifiedKey);

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

  1118 

  1119 	CleanupStack::PopAndDestroy(repository);

  1120 	}

  1121 

  1122 /**

  1123 @SYMTestCaseID         	SYSLIB-CENTRALREPOSITORY-CT-3400

  1124 @SYMTestCaseDesc        CRepository class functionality test

  1125 @SYMTestPriority        High

  1126 @SYMTestActions         Negative tests exercising CRepository::NotifyCancel() functions

  1127 						Tests check that central repository notifier works properly when

  1128 						client cancels multiple, non-existent notifications, and also

  1129 						multiple and non-existent group notificatins in a variety of combinations.

  1130 @SYMTestExpectedResults There are 2 main points that we need to check in this test:

  1131 						1) when we are cancelling multiple notifications server-side function should

  1132 						always return KErrNone or KErrNotFound preventing client requests from waitng

  1133 						indefinitely

  1134 						2) IPC handling function should convert any error returned from the server