1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/centralrepository/test/t_cenrep.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2519 @@
1.4 +// Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "t_cenrep_helper.h"
1.20 +#include <centralrepository.h>
1.21 +#include <e32test.h>
1.22 +#include <f32file.h>
1.23 +#include "../cenrepsrv/srvreqs.h"
1.24 +#include "../common/inc/srvdefs.h"
1.25 +#include "../cenrepsrv/srvparams.h"
1.26 +
1.27 +using namespace NCentralRepositoryConstants;
1.28 +
1.29 +RTest TheTest(_L("Central Repository Tests"));
1.30 +
1.31 +TBool OomTesting;
1.32 +
1.33 +const TUid KUidTestRepository1 = { 0x00000001 };
1.34 +const TUid KUidCreTestRepository1 = { 0x22222221 };
1.35 +const TUid KUidTestRepository2 = { 0x00000002 };
1.36 +
1.37 +const TUid KUidCorruptRepository = { 0x00000003 };
1.38 +const TUid KUidResetTestRepository = { 0x00000004 };
1.39 +
1.40 +const TUid KUidDriveCRepository = { 0x00000010 };
1.41 +
1.42 +const TUid KUidDriveCOnlyRepository = { 0x00000013 };
1.43 +
1.44 +const TUid KUidTestRepository3 = { 0x00000103 };
1.45 +
1.46 +//
1.47 +// Test repository 1
1.48 +//
1.49 +
1.50 +const TUint32 KNonExisitentSetting = 0;
1.51 +
1.52 +const TInt KNumSettings = 9;
1.53 +
1.54 +const TUint32 KInt1 = 1;
1.55 +const TInt KInt1_InitialValue = 1;
1.56 +const TInt KInt1_UpdatedValue = 73;
1.57 +const TUint32 KInt3 = 257;
1.58 +const TUint32 KNewInt = 1000;
1.59 +
1.60 +const TUint32 KReal1 = 2;
1.61 +const TReal KReal1_InitialValue = 2.732;
1.62 +const TReal KReal1_UpdatedValue = 72.8;
1.63 +const TUint32 KReal2 = 8;
1.64 +const TReal KReal2_InitialValue = 1.5;
1.65 +const TUint32 KReal3 = 17;
1.66 +const TUint32 KNewReal = 2000;
1.67 +
1.68 +const TUint32 KString1 = 5;
1.69 +_LIT(KString1_InitialValue, "test\\\"string\"");
1.70 +_LIT(KString1_UpdatedValue, "another one");
1.71 +const TUint32 KString2 = 12;
1.72 +_LIT8(KString2_8BitValue, "string");
1.73 +
1.74 +const TUint32 KString12 = 12;
1.75 +const TUint32 KNewString8 = 3000;
1.76 +const TUint32 KNewString16 = 4000;
1.77 +
1.78 +const TUint32 KNewSetting1 = 0x2001;
1.79 +const TUint32 KNewSetting2 = 0x2002;
1.80 +const TUint32 KNewSetting3 = 0x2003;
1.81 +const TUint32 KNewSetting4 = 0x2004;
1.82 +const TUint32 KNewSetting5 = 0x2005;
1.83 +const TUint32 KNewSetting6 = 0x2006;
1.84 +const TUint32 KNewSetting7 = 0x2007;
1.85 +const TUint32 KNewSetting8 = 0x2008;
1.86 +
1.87 +const TInt32 KNewSetting1Value = 4567;
1.88 +const TReal KNewSetting2Value = 45.67;
1.89 +_LIT(KNewSetting3Value, "a unicode str");
1.90 +_LIT8(KNewSetting4Value, "an ascii str");
1.91 +const TInt32 KNewSetting5Value = 2389;
1.92 +const TReal KNewSetting6Value = 23.89;
1.93 +_LIT(KNewSetting7Value, "another unicode str");
1.94 +_LIT8(KNewSetting8Value, "another ascii str");
1.95 +
1.96 +
1.97 +//
1.98 +// Test repository 2
1.99 +//
1.100 +
1.101 +const TInt KIntB1 = 807;
1.102 +const TInt KIntB1_InitialValue = 100;
1.103 +
1.104 +
1.105 +
1.106 +///////////////////////////////////////////////////////////////////////////////////////
1.107 +///////////////////////////////////////////////////////////////////////////////////////
1.108 +//Test macroses and functions
1.109 +
1.110 +LOCAL_C void CheckL(TInt aValue, TInt aLine)
1.111 + {
1.112 + if(!aValue)
1.113 + {
1.114 + CleanupCDriveL();
1.115 + TheTest(EFalse, aLine);
1.116 + }
1.117 + }
1.118 +LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)
1.119 + {
1.120 + if(aValue != aExpected)
1.121 + {
1.122 + CleanupCDriveL();
1.123 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.124 + TheTest(EFalse, aLine);
1.125 + }
1.126 + }
1.127 +#define TEST(arg) ::CheckL((arg), __LINE__)
1.128 +#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)
1.129 +
1.130 +///////////////////////////////////////////////////////////////////////////////////////
1.131 +///////////////////////////////////////////////////////////////////////////////////////
1.132 +
1.133 +LOCAL_C void KillCentRepServerL()
1.134 + {
1.135 + _LIT(KCentralRepositoryServerName, "Centralrepositorysrv");
1.136 + _LIT(KProcessKillProcess, "t_processkillprocess.exe");
1.137 +
1.138 + TRequestStatus stat;
1.139 + RProcess p;
1.140 + User::LeaveIfError(p.Create(KProcessKillProcess, KCentralRepositoryServerName));
1.141 +
1.142 + // Asynchronous logon: completes when process terminates with process
1.143 + // exit code
1.144 + p.Logon(stat);
1.145 + p.Resume();
1.146 + User::WaitForRequest(stat);
1.147 +
1.148 + TExitType exitType = p.ExitType();
1.149 + TInt exitReason = p.ExitReason();
1.150 +
1.151 + _LIT(KKillServerFailed, "Killing Central Repository Server Failed");
1.152 + __ASSERT_ALWAYS(exitType == EExitKill, User::Panic(KKillServerFailed, exitReason));
1.153 +
1.154 + p.Close();
1.155 + User::LeaveIfError(exitReason);
1.156 + }
1.157 +
1.158 +//This function resets the KUidTestRepository1 repository
1.159 +//to its intial state to remove any changes made to the repository during
1.160 +//previous tests
1.161 +LOCAL_C void ResetTestRepositoryL()
1.162 + {
1.163 + CRepository* repository;
1.164 +
1.165 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));
1.166 + TInt r = repository->Reset();
1.167 + TEST2(r, KErrNone);
1.168 + CleanupStack::PopAndDestroy(repository);
1.169 + }
1.170 +
1.171 +//This function restores the state of the files required for this test
1.172 +//Existing files are deleted and then the required files are copied
1.173 +//back from the Z drive to the c drive
1.174 +LOCAL_C void RestoreTestFilesL()
1.175 + {
1.176 + //Delete all files from C:\\private\\10202BE9\\persists\\ dir
1.177 + //and C:\\private\\10202BE9\\ dir
1.178 + CleanupCDriveL();
1.179 +
1.180 + RFs fs;
1.181 + User::LeaveIfError(fs.Connect());
1.182 + CleanupClosePushL(fs);
1.183 +
1.184 + CFileMan* fm = CFileMan::NewL(fs);
1.185 + CleanupStack::PushL(fm);
1.186 +
1.187 +// _LIT(KPersistTargetPath, "c:\\private\\10202BE9\\persists\\*.txt");
1.188 + _LIT(KPersistTargetPath, "z:\\private\\10202BE9\\*.txt");
1.189 + _LIT(KPersistSourcePath, "Z:\\private\\10202BE9\\*.txc");
1.190 + _LIT(KInstallTargetPath, "C:\\private\\10202BE9\\*.txt");
1.191 + _LIT(KInstallSourcePath, "Z:\\private\\10202BE9\\*.txi");
1.192 +
1.193 + //copy test files from Z: to C:
1.194 + CopyTestFilesL(*fm,KPersistSourcePath, KPersistTargetPath);
1.195 + CopyTestFilesL(*fm,KInstallSourcePath, KInstallTargetPath);
1.196 +
1.197 + CleanupStack::PopAndDestroy(2);
1.198 +
1.199 + }
1.200 +
1.201 +
1.202 +/**
1.203 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1297
1.204 +@SYMTestCaseDesc Tests for creation and opening a central repository
1.205 +@SYMTestPriority High
1.206 +@SYMTestActions Tests for CRepository::NewLC(),CRepository::Get() functions
1.207 +@SYMTestExpectedResults Test must not fail
1.208 +@SYMREQ REQ0000
1.209 +*/
1.210 +LOCAL_C void OpenRepositoryL()
1.211 + {
1.212 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1297 "));
1.213 + CRepository* repositoryA;
1.214 + CRepository* repositoryB;
1.215 +
1.216 + TInt r;
1.217 +
1.218 + // When an attempt is made to open a central repository in this test the result will
1.219 + // be that a new session (+ subsession) will be created with the server. For subsequent
1.220 + // central repository openings subsessions are then created under the same server.
1.221 + // Note that by placing the CRepository creation calls in the following order we
1.222 + // are exercising among other things the following scenarios:
1.223 + // 1. Session is opened and first subsession is created. Error occurs, whole session
1.224 + // is pulled down.
1.225 + // 2. Session is opened and first subsession is successfully created. 2nd subsession
1.226 + // is opened. Error occurs with 2nd subsession. 2nd subsession is pulled down. Session
1.227 + // and first sub-sesssion remain up. (DEF105089)
1.228 +
1.229 + TRAP(r, CRepository::NewL(TUid::Null()));
1.230 + if(OomTesting && r==KErrNoMemory)
1.231 + User::Leave(KErrNoMemory);
1.232 + TEST2(r, KErrNotFound);
1.233 +
1.234 + repositoryB = CRepository::NewLC(KUidTestRepository2);
1.235 +
1.236 + TRAP(r, CRepository::NewL(KUidCorruptRepository));
1.237 + if(OomTesting && r==KErrNoMemory)
1.238 + User::Leave(KErrNoMemory);
1.239 + TEST2(r, KErrCorrupt);
1.240 +
1.241 + repositoryA = CRepository::NewLC(KUidTestRepository1);
1.242 +
1.243 + TInt a;
1.244 + r = repositoryA->Get(KInt1, a);
1.245 + TEST2(r, KErrNone);
1.246 + TEST(a==KInt1_InitialValue);
1.247 +
1.248 + r = repositoryB->Get(KIntB1, a);
1.249 + TEST2(r, KErrNone);
1.250 + TEST(a==KIntB1_InitialValue);
1.251 +
1.252 + CleanupStack::PopAndDestroy(repositoryA);
1.253 +
1.254 + r = repositoryB->Get(KIntB1, a);
1.255 + TEST2(r, KErrNone);
1.256 + TEST(a==KIntB1_InitialValue);
1.257 +
1.258 + CleanupStack::PopAndDestroy(repositoryB);
1.259 + }
1.260 +
1.261 +/**
1.262 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1298
1.263 +@SYMTestCaseDesc Tests for CRepository's Integer,Real,String's Get and Set functions
1.264 +@SYMTestPriority High
1.265 +@SYMTestActions Tests for CRepository::Get(),CRepository::Set() functions
1.266 +@SYMTestExpectedResults Test must not fail
1.267 +@SYMREQ REQ0000
1.268 +*/
1.269 +LOCAL_C void GetSetL(const TUid& aUid)
1.270 + {
1.271 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1298 "));
1.272 + CRepository* repository;
1.273 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.274 +
1.275 + _LIT8(KString12_InitialValue, "string");
1.276 + TPtrC8 p8(KString12_InitialValue);
1.277 +
1.278 + _LIT(KString11_InitialValue, "string");
1.279 + TPtrC p16(KString11_InitialValue);
1.280 +
1.281 + TBuf8<20> str8;
1.282 + TBuf<20> str;
1.283 + TInt i = 0;
1.284 +
1.285 + //
1.286 + // Integer get/set
1.287 + //
1.288 +
1.289 + TInt r = repository->Get(KNonExisitentSetting, i);
1.290 + TEST2(r, KErrNotFound);
1.291 + TEST(i==0);
1.292 +
1.293 + r = repository->Get(KReal1, i);
1.294 + TEST2(r, KErrArgument);
1.295 + TEST(i==0);
1.296 +
1.297 + r = repository->Get(KInt1, i);
1.298 + TEST2(r, KErrNone);
1.299 + TEST(i==KInt1_InitialValue);
1.300 +
1.301 + r = repository->Get(KNonExisitentSetting, i);
1.302 + TEST2(r, KErrNotFound);
1.303 +
1.304 + r = repository->Set(KNonExisitentSetting, 10);
1.305 + TEST2(r, KErrNone);
1.306 +
1.307 + //close and reopen rep to check set is persisted
1.308 + CleanupStack::PopAndDestroy(repository);
1.309 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.310 +
1.311 + r = repository->Get(KNonExisitentSetting, i);
1.312 + TEST2(r, KErrNone);
1.313 + TEST(i==10);
1.314 +
1.315 + r = repository->Delete(KNonExisitentSetting);
1.316 + TEST2(r, KErrNone);
1.317 +
1.318 + r = repository->Set(KReal1, 0);
1.319 + TEST2(r, KErrArgument);
1.320 +
1.321 + r = repository->Set(KInt1, KInt1_UpdatedValue);
1.322 + TEST2(r, KErrNone);
1.323 +
1.324 + //close and reopen rep to check set is persisted
1.325 + CleanupStack::PopAndDestroy(repository);
1.326 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.327 +
1.328 + r = repository->Get(KInt1, i);
1.329 + TEST2(r, KErrNone);
1.330 + TEST(i==KInt1_UpdatedValue);
1.331 +
1.332 + r = repository->Get(KInt1,str8);
1.333 + TEST2(r, KErrArgument);
1.334 + //checks if KInt was modified
1.335 + r = repository->Get(KInt1, i);
1.336 + TEST2(r, KErrNone);
1.337 + TEST(i==KInt1_UpdatedValue);
1.338 +
1.339 + r = repository->Set(KInt1, KString12_InitialValue);
1.340 + TEST2(r, KErrArgument);
1.341 + r = repository->Get(KInt1, i);
1.342 + TEST2(r, KErrNone);
1.343 + TEST(i==KInt1_UpdatedValue);
1.344 +
1.345 + r = repository->Get(KInt1,str);
1.346 + TEST2(r, KErrArgument);
1.347 + //checks if KInt was modified
1.348 + r = repository->Get(KInt1, i);
1.349 + TEST2(r, KErrNone);
1.350 + TEST(i==KInt1_UpdatedValue);
1.351 +
1.352 + r = repository->Set(KInt1, KString11_InitialValue);
1.353 + TEST2(r, KErrArgument);
1.354 + r = repository->Get(KInt1, i);
1.355 + TEST2(r, KErrNone);
1.356 + TEST(i==KInt1_UpdatedValue);
1.357 + //
1.358 + // Real get/set
1.359 + //
1.360 +
1.361 + TReal y = 0;
1.362 +
1.363 + r = repository->Get(KNonExisitentSetting, y);
1.364 + TEST2(r, KErrNotFound);
1.365 + TEST(y==0);
1.366 +
1.367 + r = repository->Get(KInt1, y);
1.368 + TEST2(r, KErrArgument);
1.369 + TEST(y==0);
1.370 +
1.371 + r = repository->Get(KReal1, y);
1.372 + TEST2(r, KErrNone);
1.373 + TEST(y==KReal1_InitialValue);
1.374 +
1.375 + r = repository->Get(KNonExisitentSetting, y);
1.376 + TEST2(r, KErrNotFound);
1.377 +
1.378 + r = repository->Set(KNonExisitentSetting, 0.0);
1.379 + TEST2(r, KErrNone);
1.380 +
1.381 + //close and reopen rep to check set is persisted
1.382 + CleanupStack::PopAndDestroy(repository);
1.383 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.384 +
1.385 + r = repository->Get(KNonExisitentSetting, y);
1.386 + TEST2(r, KErrNone);
1.387 + TEST(y == 0.0);
1.388 +
1.389 + r = repository->Delete(KNonExisitentSetting);
1.390 + TEST2(r, KErrNone);
1.391 +
1.392 + r = repository->Set(KInt1, 0.0);
1.393 + TEST2(r, KErrArgument);
1.394 +
1.395 + r = repository->Set(KReal1, KReal1_UpdatedValue);
1.396 + TEST2(r, KErrNone);
1.397 +
1.398 + //close and reopen rep to check set is persisted
1.399 + CleanupStack::PopAndDestroy(repository);
1.400 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.401 +
1.402 + r = repository->Get(KReal1, y);
1.403 + TEST2(r, KErrNone);
1.404 + TEST(y==KReal1_UpdatedValue);
1.405 +
1.406 + r = repository->Get(KReal1,str8);
1.407 + TEST2(r, KErrArgument);
1.408 + //checks if KInt was modified
1.409 + r = repository->Get(KReal1, y);
1.410 + TEST2(r, KErrNone);
1.411 + TEST(y==KReal1_UpdatedValue);
1.412 +
1.413 + r = repository->Get(KReal1,str);
1.414 + TEST2(r, KErrArgument);
1.415 + //checks if KInt was modified
1.416 + r = repository->Get(KReal1, y);
1.417 + TEST2(r, KErrNone);
1.418 + TEST(y==KReal1_UpdatedValue);
1.419 +
1.420 + r = repository->Set(KReal1, KString12_InitialValue);
1.421 + TEST2(r, KErrArgument);
1.422 + r = repository->Get(KReal1, y);
1.423 + TEST2(r, KErrNone);
1.424 + TEST(y==KReal1_UpdatedValue);
1.425 +
1.426 + r = repository->Set(KReal1, KString11_InitialValue);
1.427 + TEST2(r, KErrArgument);
1.428 + r = repository->Get(KReal1, y);
1.429 + TEST2(r, KErrNone);
1.430 + TEST(y==KReal1_UpdatedValue);
1.431 +
1.432 + //
1.433 + // String get/set
1.434 + //
1.435 + r = repository->Get(KNonExisitentSetting, str);
1.436 + TEST2(r, KErrNotFound);
1.437 + TEST(str.Length()==0);
1.438 +
1.439 + r = repository->Get(KInt1, str);
1.440 + TEST2(r, KErrArgument);
1.441 + TEST(str.Length()==0);
1.442 +
1.443 + r = repository->Get(KString1, str);
1.444 + TEST2(r, KErrNone);
1.445 + TEST(str==KString1_InitialValue);
1.446 +
1.447 + TBuf<10> tooShort;
1.448 + r = repository->Get(KString1, tooShort);
1.449 + TEST2(r, KErrOverflow);
1.450 + TEST(tooShort.Length()==10);
1.451 +
1.452 + r = repository->Get(KNonExisitentSetting, str);
1.453 + TEST2(r, KErrNotFound);
1.454 +
1.455 + r = repository->Set(KNonExisitentSetting, KString1_UpdatedValue);
1.456 + TEST2(r, KErrNone);
1.457 +
1.458 + //close and reopen rep to check set is persisted
1.459 + CleanupStack::PopAndDestroy(repository);
1.460 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.461 +
1.462 + r = repository->Get(KNonExisitentSetting, str);
1.463 + TEST2(r, KErrNone);
1.464 + TEST(str==KString1_UpdatedValue);
1.465 +
1.466 + r = repository->Delete(KNonExisitentSetting);
1.467 + TEST2(r, KErrNone);
1.468 +
1.469 + r = repository->Set(KInt1, str);
1.470 + TEST2(r, KErrArgument);
1.471 +
1.472 + r = repository->Set(KString1, KString1_UpdatedValue);
1.473 + TEST2(r, KErrNone);
1.474 +
1.475 + //close and reopen rep to check set is persisted
1.476 + CleanupStack::PopAndDestroy(repository);
1.477 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.478 +
1.479 + r = repository->Get(KString1, str);
1.480 + TEST2(r, KErrNone);
1.481 + TEST(str==KString1_UpdatedValue);
1.482 +
1.483 + //testing the new feature: creating an 8 bit string from ini file.
1.484 + r = repository->Get(KString12, str8);
1.485 + TEST2(r, KErrNone);
1.486 + TEST(str8==KString12_InitialValue);
1.487 +
1.488 + //get 8-bit string with int
1.489 + r = repository->Get(KString12, i);
1.490 + TEST2(r, KErrArgument);
1.491 + r = repository->Get(KString12, str8);
1.492 + TEST2(r, KErrNone);
1.493 + TEST(str8==KString12_InitialValue);
1.494 +
1.495 + //get 8-bit string with real
1.496 + r = repository->Get(KString12, y);
1.497 + TEST2(r, KErrArgument);
1.498 + r = repository->Get(KString12, str8);
1.499 + TEST2(r, KErrNone);
1.500 + TEST(str8==KString12_InitialValue);
1.501 +
1.502 + //set 8-bit string with int
1.503 + r = repository->Set(KString12, i);
1.504 + TEST2(r, KErrArgument);
1.505 + r = repository->Get(KString12, str8);
1.506 + TEST2(r, KErrNone);
1.507 + TEST(str8==KString12_InitialValue);
1.508 +
1.509 + //set 8-bit string with real
1.510 + r = repository->Set(KString12, y);
1.511 + TEST2(r, KErrArgument);
1.512 + r = repository->Get(KString12, str8);
1.513 + TEST2(r, KErrNone);
1.514 + TEST(str8==KString12_InitialValue);
1.515 +
1.516 +
1.517 + //get 16-bit string with int
1.518 + r = repository->Get(KString1,i);
1.519 + TEST2(r, KErrArgument);
1.520 + //checks if a string was modified
1.521 + r = repository->Get(KString1, str);
1.522 + TEST2(r, KErrNone);
1.523 + TEST(str==KString1_UpdatedValue);
1.524 +
1.525 + //get 16-bit string with real
1.526 + r = repository->Get(KString1,y);
1.527 + TEST2(r, KErrArgument);
1.528 + //checks if a string was modified
1.529 + r = repository->Get(KString1, str);
1.530 + TEST2(r, KErrNone);
1.531 + TEST(str==KString1_UpdatedValue);
1.532 +
1.533 + //set 16-bit string with int
1.534 + r = repository->Set(KString1,i);
1.535 + TEST2(r, KErrArgument);
1.536 + //checks if a string was modified
1.537 + r = repository->Get(KString1, str);
1.538 + TEST2(r, KErrNone);
1.539 + TEST(str==KString1_UpdatedValue);
1.540 +
1.541 + //set 16-bit string with real
1.542 + r = repository->Set(KString1,y);
1.543 + TEST2(r, KErrArgument);
1.544 + //checks if a string was modified
1.545 + r = repository->Get(KString1, str);
1.546 + TEST2(r, KErrNone);
1.547 + TEST(str==KString1_UpdatedValue);
1.548 +
1.549 + const TInt KStringLengthTooBig = KMaxUnicodeStringLength + 1;
1.550 + TBuf<KStringLengthTooBig> tooBig;
1.551 + tooBig.SetLength(KStringLengthTooBig);
1.552 + r = repository->Set(KString1, tooBig);
1.553 + TEST2(r, KErrArgument);
1.554 +
1.555 + //- Test null descriptors
1.556 + r = repository->Set(KString1, KNullDesC);
1.557 + TEST2(r, KErrNone);
1.558 +
1.559 + CleanupStack::PopAndDestroy(repository);
1.560 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.561 +
1.562 + r = repository->Get(KString1, str);
1.563 + TEST2(r, KErrNone);
1.564 + TEST(str==KNullDesC);
1.565 +
1.566 + r = repository->Set(KString1, KString1_UpdatedValue);
1.567 + TEST2(r, KErrNone);
1.568 +
1.569 + //close and reopen rep to check set is persisted
1.570 + CleanupStack::PopAndDestroy(repository);
1.571 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.572 +
1.573 + r = repository->Get(KString1, str);
1.574 + TEST2(r, KErrNone);
1.575 + TEST(str==KString1_UpdatedValue);
1.576 + //-
1.577 +
1.578 + // Check that the SetGetParameters interface returns KErrNotSupported in the default macro configuration
1.579 +#if !defined(__CENTREP_SERVER_PERFTEST__) && !defined(__CENTREP_SERVER_MEMTEST__) && !defined(__CENTREP_SERVER_CACHETEST__)
1.580 + TIpcArgs args;
1.581 + r = SetGetParameters(args);
1.582 + TEST2(r, KErrNotSupported);
1.583 +#endif
1.584 +
1.585 + CleanupStack::PopAndDestroy(repository);
1.586 + }
1.587 +
1.588 +/**
1.589 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1299
1.590 +@SYMTestCaseDesc Tests for CRepository class's find operations
1.591 +@SYMTestPriority High
1.592 +@SYMTestActions Tests for CRepository::FindL(),CRepository::FindEqL(),CRepository::FindNeqL() functions
1.593 +@SYMTestExpectedResults Test must not fail
1.594 +@SYMREQ REQ0000
1.595 +*/
1.596 +LOCAL_C void FindL()
1.597 + {
1.598 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1299 "));
1.599 + CRepository* repository;
1.600 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));
1.601 +
1.602 + RArray<TUint32> foundIds;
1.603 +
1.604 + TInt r = KErrNone;
1.605 + TInt leaveCode = KErrNone;
1.606 + TRAP(leaveCode, r = repository->FindL(0, 0, foundIds));
1.607 + if (leaveCode != KErrNone)
1.608 + r = leaveCode ;
1.609 +
1.610 + if(OomTesting && r==KErrNoMemory)
1.611 + {
1.612 + foundIds.Close();
1.613 + User::Leave(KErrNoMemory);
1.614 + }
1.615 +
1.616 + TEST2(r, KErrNone);
1.617 + TEST(foundIds.Count()==KNumSettings);
1.618 + foundIds.Reset();
1.619 +
1.620 + /***************************************************************************************/
1.621 + //Tests for FindL
1.622 + /***************************************************************************************/
1.623 + TRAP(leaveCode, r = repository->FindL(23, 0, foundIds)); // 23 - just a random number, value is not important
1.624 + if (leaveCode != KErrNone)
1.625 + r = leaveCode ;
1.626 + if(OomTesting && r==KErrNoMemory)
1.627 + {
1.628 + foundIds.Close();
1.629 + User::Leave(KErrNoMemory);
1.630 + }
1.631 + TEST2(r, KErrNone);
1.632 + TEST(foundIds.Count()==KNumSettings);
1.633 + foundIds.Reset();
1.634 +
1.635 +
1.636 + TRAP(leaveCode, r=repository->FindL(0, 2, foundIds));
1.637 + if (leaveCode != KErrNone)
1.638 + r = leaveCode ;
1.639 + if(OomTesting && r==KErrNoMemory)
1.640 + {
1.641 + foundIds.Close();
1.642 + User::Leave(KErrNoMemory);
1.643 + }
1.644 + TEST2(r, KErrNone);
1.645 + TEST(foundIds.Count()==6);
1.646 + foundIds.Reset();
1.647 +
1.648 +
1.649 + TRAP(leaveCode, r=repository->FindL(4, 6, foundIds));
1.650 + if (leaveCode != KErrNone)
1.651 + r = leaveCode ;
1.652 + if(OomTesting && r==KErrNoMemory)
1.653 + {
1.654 + foundIds.Close();
1.655 + User::Leave(KErrNoMemory);
1.656 + }
1.657 + TEST2(r, KErrNone);
1.658 + TEST(foundIds.Count()==2);
1.659 + foundIds.Reset();
1.660 +
1.661 +
1.662 +
1.663 + TRAP(leaveCode, r= repository->FindL(15, 15, foundIds));
1.664 + if (leaveCode != KErrNone)
1.665 + r = leaveCode ;
1.666 + if(OomTesting && r==KErrNoMemory)
1.667 + {
1.668 + foundIds.Close();
1.669 + User::Leave(KErrNoMemory);
1.670 + }
1.671 + TEST2(r, KErrNotFound);
1.672 + TEST(foundIds.Count()==0);
1.673 +
1.674 +
1.675 + /***************************************************************************************/
1.676 + //Tests for FindEqL for Int
1.677 + /***************************************************************************************/
1.678 + TRAP(leaveCode, r= repository->FindEqL(0, 0, KInt1_UpdatedValue, foundIds));
1.679 + if (leaveCode != KErrNone)
1.680 + r = leaveCode ;
1.681 + if(OomTesting && r==KErrNoMemory)
1.682 + {
1.683 + foundIds.Close();
1.684 + User::Leave(KErrNoMemory);
1.685 + }
1.686 + TEST2(r, KErrNone);
1.687 + TEST(foundIds.Count()==1);
1.688 + TEST(foundIds[0]==KInt1);
1.689 + foundIds.Reset();
1.690 +
1.691 +
1.692 + TRAP(leaveCode, r= repository->FindEqL(0, 0, 0, foundIds));
1.693 + if (leaveCode != KErrNone)
1.694 + r = leaveCode ;
1.695 + if(OomTesting && r==KErrNoMemory)
1.696 + {
1.697 + foundIds.Close();
1.698 + User::Leave(KErrNoMemory);
1.699 + }
1.700 + TEST2(r, KErrNotFound);
1.701 + TEST(foundIds.Count()==0);
1.702 +
1.703 +
1.704 + /***************************************************************************************/
1.705 + //Tests for FindEqL for Real
1.706 + /***************************************************************************************/
1.707 + TRAP(leaveCode, r= repository->FindEqL(0, 0, KReal2_InitialValue, foundIds));
1.708 + if (leaveCode != KErrNone)
1.709 + r = leaveCode ;
1.710 + if(OomTesting && r==KErrNoMemory)
1.711 + {
1.712 + foundIds.Close();
1.713 + User::Leave(KErrNoMemory);
1.714 + }
1.715 + TEST2(r, KErrNone);
1.716 + TEST(foundIds.Count()==2);
1.717 + TEST(foundIds[0]==KReal2);
1.718 + TEST(foundIds[1]==KReal3);
1.719 + foundIds.Reset();
1.720 +
1.721 +
1.722 + TRAP(leaveCode, r= repository->FindEqL(0, 0, 7.7, foundIds));
1.723 + if (leaveCode != KErrNone)
1.724 + r = leaveCode ;
1.725 + if(OomTesting && r==KErrNoMemory)
1.726 + {
1.727 + foundIds.Close();
1.728 + User::Leave(KErrNoMemory);
1.729 + }
1.730 + TEST2(r, KErrNotFound);
1.731 + TEST(foundIds.Count()==0);
1.732 +
1.733 +
1.734 + /***************************************************************************************/
1.735 + //Tests for FindEqL for String
1.736 + /***************************************************************************************/
1.737 + TRAP(leaveCode, r= repository->FindEqL(0, 0, KString1_UpdatedValue, foundIds));
1.738 + if (leaveCode != KErrNone)
1.739 + r = leaveCode ;
1.740 + if(OomTesting && r==KErrNoMemory)
1.741 + {
1.742 + foundIds.Close();
1.743 + User::Leave(KErrNoMemory);
1.744 + }
1.745 + TEST2(r, KErrNone);
1.746 + TEST(foundIds.Count()==1);
1.747 + TEST(foundIds[0]==KString1);
1.748 + foundIds.Reset();
1.749 +
1.750 + _LIT(KFoo, "foo");
1.751 +
1.752 + TRAP(leaveCode, r= repository->FindEqL(0, 0, KFoo, foundIds));
1.753 + if (leaveCode != KErrNone)
1.754 + r = leaveCode ;
1.755 + if(OomTesting && r==KErrNoMemory)
1.756 + {
1.757 + foundIds.Close();
1.758 + User::Leave(KErrNoMemory);
1.759 + }
1.760 + TEST2(r, KErrNotFound);
1.761 + TEST(foundIds.Count()==0);
1.762 +
1.763 + /***************************************************************************************/
1.764 + //Tests for FindEqL for String8
1.765 + /***************************************************************************************/
1.766 + TRAP(leaveCode, r= repository->FindEqL(0, 0, KString2_8BitValue, foundIds));
1.767 + if (leaveCode != KErrNone)
1.768 + r = leaveCode ;
1.769 + if(OomTesting && r==KErrNoMemory)
1.770 + {
1.771 + foundIds.Close();
1.772 + User::Leave(KErrNoMemory);
1.773 + }
1.774 + TEST2(r, KErrNone);
1.775 + TEST(foundIds.Count()==1);
1.776 + TEST(foundIds[0]==KString2);
1.777 + foundIds.Reset();
1.778 +
1.779 + _LIT8(KFoo8, "foo");
1.780 +
1.781 + TRAP(leaveCode, r= repository->FindEqL(0, 0, KFoo8, foundIds));
1.782 + if (leaveCode != KErrNone)
1.783 + r = leaveCode ;
1.784 + if(OomTesting && r==KErrNoMemory)
1.785 + {
1.786 + foundIds.Close();
1.787 + User::Leave(KErrNoMemory);
1.788 + }
1.789 + TEST2(r, KErrNotFound);
1.790 + TEST(foundIds.Count()==0);
1.791 +
1.792 + /***************************************************************************************/
1.793 + //Tests for FindNeqL for Int
1.794 + /***************************************************************************************/
1.795 + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KInt1_UpdatedValue, foundIds));
1.796 + if (leaveCode != KErrNone)
1.797 + r = leaveCode ;
1.798 + if(OomTesting && r==KErrNoMemory)
1.799 + {
1.800 + foundIds.Close();
1.801 + User::Leave(KErrNoMemory);
1.802 + }
1.803 + TEST2(r, KErrNone);
1.804 + TEST(foundIds.Count()==8);
1.805 + TEST2(foundIds.Find(KInt1), KErrNotFound);
1.806 + foundIds.Reset();
1.807 +
1.808 +
1.809 + TRAP(leaveCode, r= repository->FindNeqL(25, 25, KInt1_UpdatedValue, foundIds));
1.810 + if (leaveCode != KErrNone)
1.811 + r = leaveCode ;
1.812 + if(OomTesting && r==KErrNoMemory)
1.813 + {
1.814 + foundIds.Close();
1.815 + User::Leave(KErrNoMemory);
1.816 + }
1.817 + TEST2(r, KErrNotFound);
1.818 + TEST(foundIds.Count()==0);
1.819 +
1.820 +
1.821 + /***************************************************************************************/
1.822 + //Tests for FindNeqL for Real
1.823 + /***************************************************************************************/
1.824 + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KReal1_UpdatedValue, foundIds));
1.825 + if (leaveCode != KErrNone)
1.826 + r = leaveCode ;
1.827 + if(OomTesting && r==KErrNoMemory)
1.828 + {
1.829 + foundIds.Close();
1.830 + User::Leave(KErrNoMemory);
1.831 + }
1.832 + TEST2(r, KErrNone);
1.833 + TEST(foundIds.Count()==8);
1.834 + TEST2(foundIds.Find(KReal1), KErrNotFound);
1.835 + foundIds.Reset();
1.836 +
1.837 +
1.838 + TRAP(leaveCode,r= repository->FindNeqL(25, 25, KReal1_UpdatedValue, foundIds));
1.839 + if (leaveCode != KErrNone)
1.840 + r = leaveCode ;
1.841 + if(OomTesting && r==KErrNoMemory)
1.842 + {
1.843 + foundIds.Close();
1.844 + User::Leave(KErrNoMemory);
1.845 + }
1.846 + TEST2(r, KErrNotFound);
1.847 + TEST(foundIds.Count()==0);
1.848 +
1.849 +
1.850 + /***************************************************************************************/
1.851 + //Tests for FindNeqL for String
1.852 + /***************************************************************************************/
1.853 + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KString1_UpdatedValue, foundIds));
1.854 + if (leaveCode != KErrNone)
1.855 + r = leaveCode ;
1.856 + if(OomTesting && r==KErrNoMemory)
1.857 + {
1.858 + foundIds.Close();
1.859 + User::Leave(KErrNoMemory);
1.860 + }
1.861 + TEST2(r, KErrNone);
1.862 + TEST(foundIds.Count()==8);
1.863 + TEST2(foundIds.Find(KString1), KErrNotFound);
1.864 + foundIds.Reset();
1.865 +
1.866 +
1.867 + TRAP(leaveCode, r= repository->FindNeqL(25, 25, KString1_UpdatedValue, foundIds));
1.868 + if (leaveCode != KErrNone)
1.869 + r = leaveCode ;
1.870 + if(OomTesting && r==KErrNoMemory)
1.871 + {
1.872 + foundIds.Close();
1.873 + User::Leave(KErrNoMemory);
1.874 + }
1.875 + TEST2(r, KErrNotFound);
1.876 + TEST(foundIds.Count()==0);
1.877 +
1.878 + /***************************************************************************************/
1.879 + //Tests for FindNeqL for String8
1.880 + /***************************************************************************************/
1.881 + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KString2_8BitValue, foundIds));
1.882 + if (leaveCode != KErrNone)
1.883 + r = leaveCode ;
1.884 + if(OomTesting && r==KErrNoMemory)
1.885 + {
1.886 + foundIds.Close();
1.887 + User::Leave(KErrNoMemory);
1.888 + }
1.889 + TEST2(r, KErrNone);
1.890 + TEST(foundIds.Count()==8);
1.891 + TEST2(foundIds.Find(KString2), KErrNotFound);
1.892 + foundIds.Reset();
1.893 +
1.894 +
1.895 + TRAP(leaveCode, r= repository->FindNeqL(25, 25, KString2_8BitValue, foundIds));
1.896 + if (leaveCode != KErrNone)
1.897 + r = leaveCode ;
1.898 + if(OomTesting && r==KErrNoMemory)
1.899 + {
1.900 + foundIds.Close();
1.901 + User::Leave(KErrNoMemory);
1.902 + }
1.903 + TEST2(r, KErrNotFound);
1.904 + TEST(foundIds.Count()==0);
1.905 +
1.906 + CleanupStack::PopAndDestroy(repository);
1.907 + }
1.908 +
1.909 +/**
1.910 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1300
1.911 +@SYMTestCaseDesc CRepository class functionality test
1.912 +@SYMTestPriority High
1.913 +@SYMTestActions Test for CRepository::NotifyRequest() functions
1.914 +@SYMTestExpectedResults Test must not fail
1.915 +@SYMREQ REQ0000
1.916 +*/
1.917 +LOCAL_C void NotifyL()
1.918 + {
1.919 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1300 "));
1.920 + CRepository* repository;
1.921 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));
1.922 +
1.923 + TInt r = KErrNone;
1.924 + TInt intval;
1.925 + TRequestStatus intStatus;
1.926 + TRequestStatus realStatus;
1.927 + TRequestStatus stringStatus;
1.928 + RThread thisThread;
1.929 +
1.930 + //
1.931 + // Notification on non-existent setting
1.932 + //
1.933 + r = repository->NotifyRequest(KNonExisitentSetting, intStatus);
1.934 + TEST2(r, KErrNotFound);
1.935 +
1.936 + //
1.937 + // Basic notification
1.938 + //
1.939 + r = repository->NotifyRequest(KInt1, intStatus);
1.940 + TEST2(r, KErrNone);
1.941 +
1.942 + r = repository->NotifyRequest(KReal1, realStatus);
1.943 + TEST2(r, KErrNone);
1.944 +
1.945 + r = repository->NotifyRequest(KString1, stringStatus);
1.946 + TEST2(r, KErrNone);
1.947 +
1.948 +
1.949 + // Setting to the same value should not cause a notification
1.950 + r = repository->Get(KInt1, intval);
1.951 + TEST2(r, KErrNone);
1.952 + r = repository->Set(KInt1, intval);
1.953 + TEST2(r, KErrNone);
1.954 + TEST(intStatus==KRequestPending);
1.955 + TEST(realStatus==KRequestPending);
1.956 + TEST(stringStatus==KRequestPending);
1.957 + TEST(thisThread.RequestCount()==0);
1.958 +
1.959 + // First change to setting should cause notification
1.960 + r = repository->Set(KInt1, 0);
1.961 + TEST2(r, KErrNone);
1.962 + User::WaitForAnyRequest();
1.963 + TEST(intStatus==KInt1);
1.964 + TEST(realStatus==KRequestPending);
1.965 + TEST(stringStatus==KRequestPending);
1.966 +
1.967 + // Second change to setting should not cause notification
1.968 + intStatus = 7777;
1.969 + r = repository->Set(KInt1, 0);
1.970 + TEST2(r, KErrNone);
1.971 + TEST(intStatus==7777);
1.972 + TEST(realStatus==KRequestPending);
1.973 + TEST(stringStatus==KRequestPending);
1.974 + TEST(thisThread.RequestCount()==0);
1.975 +
1.976 +
1.977 + // Setting to the same value should not cause a notification
1.978 + TReal realval;
1.979 + r = repository->Get(KReal1, realval);
1.980 + TEST2(r, KErrNone);
1.981 + r = repository->Set(KReal1, realval);
1.982 + TEST2(r, KErrNone);
1.983 + TEST(intStatus==7777);
1.984 + TEST(realStatus==KRequestPending);
1.985 + TEST(stringStatus==KRequestPending);
1.986 + TEST(thisThread.RequestCount()==0);
1.987 +
1.988 + r = repository->Set(KReal1, 0.0);
1.989 + TEST2(r, KErrNone);
1.990 + User::WaitForAnyRequest();
1.991 + TEST(intStatus==7777);
1.992 + TEST(realStatus==KReal1);
1.993 + TEST(stringStatus==KRequestPending);
1.994 +
1.995 +
1.996 + // Setting to the same value should not cause a notification
1.997 + realStatus = 8888;
1.998 + TBuf<20> stringval;
1.999 + r = repository->Get(KString1, stringval);
1.1000 + TEST2(r, KErrNone);
1.1001 + r = repository->Set(KString1, stringval);
1.1002 + TEST2(r, KErrNone);
1.1003 + TEST(intStatus==7777);
1.1004 + TEST(realStatus==8888);
1.1005 + TEST(stringStatus==KRequestPending);
1.1006 + TEST(thisThread.RequestCount()==0);
1.1007 +
1.1008 + _LIT(KStringValue2, "string2");
1.1009 + r = repository->Set(KString1, KStringValue2);
1.1010 + TEST2(r, KErrNone);
1.1011 + User::WaitForAnyRequest();
1.1012 + TEST(intStatus==7777);
1.1013 + TEST(realStatus==8888);
1.1014 + TEST(stringStatus==KString1);
1.1015 +
1.1016 +
1.1017 + //
1.1018 + // Cancelling single notifications
1.1019 + //
1.1020 + r = repository->NotifyRequest(KInt1, intStatus);
1.1021 + TEST2(r, KErrNone);
1.1022 + r = repository->NotifyCancel(KInt1);
1.1023 + TEST2(r, KErrNone);
1.1024 + User::WaitForAnyRequest();
1.1025 + TEST(intStatus==KUnspecifiedKey);
1.1026 +
1.1027 + intStatus = 7777;
1.1028 + r = repository->NotifyRequest(KReal1, realStatus);
1.1029 + TEST2(r, KErrNone);
1.1030 + r = repository->Set(KInt1, 1);
1.1031 + TEST2(r, KErrNone);
1.1032 + r = repository->Set(KReal1, 1.1);
1.1033 + TEST2(r, KErrNone);
1.1034 + User::WaitForAnyRequest();
1.1035 + TEST(intStatus==7777);
1.1036 + TEST(realStatus==KReal1);
1.1037 + TEST(thisThread.RequestCount()==0);
1.1038 +
1.1039 +
1.1040 + //
1.1041 + // Cancelling all notifications
1.1042 + //
1.1043 + realStatus = 8888;
1.1044 + r = repository->NotifyRequest(KInt1, intStatus);
1.1045 + TEST2(r, KErrNone);
1.1046 + r = repository->NotifyRequest(KReal1, realStatus);
1.1047 + TEST2(r, KErrNone);
1.1048 +
1.1049 + r = repository->NotifyCancelAll();
1.1050 + TEST2(r, KErrNone);
1.1051 + User::WaitForAnyRequest();
1.1052 + User::WaitForAnyRequest();
1.1053 + TEST(intStatus==KUnspecifiedKey);
1.1054 + TEST(realStatus==KUnspecifiedKey);
1.1055 +
1.1056 + intStatus = 7777;
1.1057 + realStatus = 8888;
1.1058 + r = repository->Set(KInt1, 2);
1.1059 + TEST2(r, KErrNone);
1.1060 + r = repository->Set(KReal1, 2.2);
1.1061 + TEST2(r, KErrNone);
1.1062 + TEST(intStatus==7777);
1.1063 + TEST(realStatus==8888);
1.1064 + TEST(thisThread.RequestCount()==0);
1.1065 +
1.1066 +
1.1067 + //
1.1068 + // Group notifications
1.1069 + //
1.1070 + r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus);
1.1071 + TEST2(r, KErrNone);
1.1072 +
1.1073 + r = repository->Set(KInt3, 3);
1.1074 + TEST2(r, KErrNone);
1.1075 + TEST(intStatus==KRequestPending);
1.1076 + TEST(thisThread.RequestCount()==0);
1.1077 +
1.1078 + r = repository->Set(KInt1, 3);
1.1079 + TEST2(r, KErrNone);
1.1080 + User::WaitForAnyRequest();
1.1081 + TEST(intStatus==KInt1);
1.1082 +
1.1083 + r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus);
1.1084 + TEST2(r, KErrNone);
1.1085 +
1.1086 + r = repository->Set(KReal1, 3.3);
1.1087 + TEST2(r, KErrNone);
1.1088 + User::WaitForAnyRequest();
1.1089 + TEST(intStatus==KReal1);
1.1090 +
1.1091 +
1.1092 + //
1.1093 + // Cancelling group notifications
1.1094 + //
1.1095 + r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus);
1.1096 + TEST2(r, KErrNone);
1.1097 + r = repository->NotifyCancel(0, ~(KInt1+KReal1));
1.1098 + TEST2(r, KErrNone);
1.1099 + User::WaitForAnyRequest();
1.1100 + TEST(intStatus==KUnspecifiedKey);
1.1101 +
1.1102 + r = repository->Set(KInt1, 3);
1.1103 + TEST2(r, KErrNone);
1.1104 + TEST(intStatus==KUnspecifiedKey);
1.1105 + TEST(thisThread.RequestCount()==0);
1.1106 +
1.1107 + r = repository->NotifyRequest(KInt1, intStatus);
1.1108 + TEST2(r, KErrNone);
1.1109 + r = repository->NotifyRequest(0, ~(KInt1+KReal1), realStatus);
1.1110 + TEST2(r, KErrNone);
1.1111 + r = repository->NotifyCancelAll();
1.1112 + TEST2(r, KErrNone);
1.1113 + User::WaitForAnyRequest();
1.1114 + User::WaitForAnyRequest();
1.1115 + TEST(intStatus==KUnspecifiedKey);
1.1116 + TEST(realStatus==KUnspecifiedKey);
1.1117 +
1.1118 + r = repository->Set(KInt1, 4);
1.1119 + TEST2(r, KErrNone);
1.1120 + TEST(intStatus==KUnspecifiedKey);
1.1121 + TEST(realStatus==KUnspecifiedKey);
1.1122 + TEST(thisThread.RequestCount()==0);
1.1123 +
1.1124 + CleanupStack::PopAndDestroy(repository);
1.1125 + }
1.1126 +
1.1127 +/**
1.1128 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3400
1.1129 +@SYMTestCaseDesc CRepository class functionality test
1.1130 +@SYMTestPriority High
1.1131 +@SYMTestActions Negative tests exercising CRepository::NotifyCancel() functions
1.1132 + Tests check that central repository notifier works properly when
1.1133 + client cancels multiple, non-existent notifications, and also
1.1134 + multiple and non-existent group notificatins in a variety of combinations.
1.1135 +@SYMTestExpectedResults There are 2 main points that we need to check in this test:
1.1136 + 1) when we are cancelling multiple notifications server-side function should
1.1137 + always return KErrNone or KErrNotFound preventing client requests from waitng
1.1138 + indefinitely
1.1139 + 2) IPC handling function should convert any error returned from the server
1.1140 + to KErrNone so that the client-side function NotifyCancel always returns KErrNone
1.1141 + (for more nformation on this requirement see DEF061504)
1.1142 +@SYMDEF INC102413
1.1143 +*/
1.1144 +LOCAL_C void CancelNotificationsL()
1.1145 + {
1.1146 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3400 "));
1.1147 + CRepository* repository;
1.1148 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));
1.1149 +
1.1150 + TInt r = KErrNone;
1.1151 + TRequestStatus intStatus;
1.1152 + TRequestStatus realStatus1;
1.1153 + TRequestStatus realStatus2;
1.1154 + TRequestStatus realStatus3;
1.1155 + RThread thisThread;
1.1156 +
1.1157 + //
1.1158 + // Cancelling non-existent notifications
1.1159 + //
1.1160 + r = repository->NotifyCancel(KInt1);
1.1161 + TEST2(r, KErrNone);
1.1162 +
1.1163 + //
1.1164 + // Cancelling multiple notifications
1.1165 + // This test step checks that NotifyCancel function returns correct
1.1166 + // value KErrNone regardless of the number of registered notifiers
1.1167 + //
1.1168 + r = repository->NotifyRequest(KReal1, realStatus1);
1.1169 + TEST2(r, KErrNone);
1.1170 + r = repository->NotifyRequest(KReal2, realStatus2);
1.1171 + TEST2(r, KErrNone);
1.1172 + r = repository->NotifyRequest(KReal3, realStatus3);
1.1173 + TEST2(r, KErrNone);
1.1174 +
1.1175 + r = repository->NotifyCancel(KReal3);
1.1176 + TEST2(r, KErrNone);
1.1177 + r = repository->NotifyCancel(KReal2);
1.1178 + TEST2(r, KErrNone);
1.1179 + r = repository->NotifyCancel(KReal1);
1.1180 + TEST2(r, KErrNone);
1.1181 + TEST2(thisThread.RequestCount(),3);
1.1182 + User::WaitForAnyRequest();
1.1183 + TEST(realStatus3==KUnspecifiedKey);
1.1184 + User::WaitForAnyRequest();
1.1185 + TEST(realStatus2==KUnspecifiedKey);
1.1186 + User::WaitForAnyRequest();
1.1187 + TEST(realStatus1==KUnspecifiedKey);
1.1188 + TEST2(thisThread.RequestCount(),0);
1.1189 +
1.1190 + // check that all notificatioins were actually cancelled and we will not
1.1191 + // get a notification when we change the settings
1.1192 + realStatus1 = 7777;
1.1193 + realStatus2 = 8888;
1.1194 + realStatus3 = 9999;
1.1195 + r = repository->NotifyRequest(KInt1, intStatus);
1.1196 + TEST2(r, KErrNone);
1.1197 + r = repository->Set(KReal1, 1.0);
1.1198 + TEST2(r, KErrNone);
1.1199 + r = repository->Set(KReal2, 2.0);
1.1200 + TEST2(r, KErrNone);
1.1201 + r = repository->Set(KReal3, 3.0);
1.1202 + TEST2(r, KErrNone);
1.1203 + r = repository->Set(KInt1, 2);
1.1204 + TEST2(r, KErrNone);
1.1205 + User::WaitForAnyRequest();
1.1206 + TEST(realStatus1==7777);
1.1207 + TEST(realStatus2==8888);
1.1208 + TEST(realStatus3==9999);
1.1209 + TEST(intStatus==KInt1);
1.1210 + TEST2(thisThread.RequestCount(),0);
1.1211 +
1.1212 + //
1.1213 + // Cancelling all notifications when no notifications exist
1.1214 + //
1.1215 + r = repository->NotifyCancelAll();
1.1216 + TEST2(r, KErrNone);
1.1217 +
1.1218 + //
1.1219 + // Cancelling group notifications where some of the notifications have not been set up
1.1220 + //
1.1221 + //first make sure that all the settings exist
1.1222 + r = repository->Set(KReal1, 2.0);
1.1223 + r = repository->Set(KReal2, 3.0);
1.1224 + r = repository->Set(KReal3, 4.0);
1.1225 + //This mask notify request sets up notifies for a number of keys including KReal1 and KReal2
1.1226 + r = repository->NotifyRequest(0, ~(KReal1+KReal2), realStatus1);
1.1227 + TEST2(r, KErrNone);
1.1228 + //This mask notify request cancels notifies for a number of keys including KReal1 and KReal3
1.1229 + r = repository->NotifyCancel(0, ~(KReal1+KReal3));
1.1230 + TEST2(r, KErrNone);
1.1231 + //check that notification request for the setting KReal1 has not been cancelled
1.1232 + r = repository->Set(KReal1, 1.0);
1.1233 + User::WaitForAnyRequest();
1.1234 + TEST2(r, KErrNone);
1.1235 + TEST(realStatus1==KReal1);
1.1236 +
1.1237 + //
1.1238 + // Cancelling multiple group notifications
1.1239 + //
1.1240 + //set up notification requests for 2 different groups of settings and then cancel them
1.1241 + // one by one in the reverse order checking that we get an expected return value
1.1242 + //This mask notify request sets up notifies for a number of keys including KInt1 and KReal3
1.1243 + r = repository->NotifyRequest(0, ~(KInt1+KReal3), realStatus1);
1.1244 + TEST2(r, KErrNone);
1.1245 + //This mask notify request sets up notifies for a number of keys including KReal1 and KReal2
1.1246 + r = repository->NotifyRequest(0, ~(KReal1+KReal2), realStatus2);
1.1247 + TEST2(r, KErrNone);
1.1248 +
1.1249 + //This mask notify request cancels notifies for a number of keys including KReal1 and KReal2
1.1250 + r = repository->NotifyCancel(0, ~(KReal1+KReal2));
1.1251 + TEST2(r, KErrNone);
1.1252 + //This mask notify request cancels notifies for a number of keys including KInt1 and KReal3
1.1253 + r = repository->NotifyCancel(0, ~(KInt1+KReal3));
1.1254 + TEST2(r, KErrNone);
1.1255 + User::WaitForAnyRequest();
1.1256 + User::WaitForAnyRequest();
1.1257 + TEST(realStatus1==KUnspecifiedKey);
1.1258 + TEST(realStatus2==KUnspecifiedKey);
1.1259 +
1.1260 + //
1.1261 + // Cancelling non-existent group notifications
1.1262 + //
1.1263 + r = repository->NotifyCancel(0, ~(KInt1+KReal3));
1.1264 + TEST2(r, KErrNone);
1.1265 +
1.1266 + //restore the repository value for the later tests to use
1.1267 + r = repository->Set(KInt1, 1);
1.1268 + TEST2(r, KErrNone);
1.1269 +
1.1270 + CleanupStack::PopAndDestroy(repository);
1.1271 + }
1.1272 +
1.1273 +/**
1.1274 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1301
1.1275 +@SYMTestCaseDesc Tests for creation and deletion of new settings for CRepository class
1.1276 +@SYMTestPriority High
1.1277 +@SYMTestActions Test for CRepository::Create(),CRepository::Delete() functions
1.1278 +@SYMTestExpectedResults Test must not fail
1.1279 +@SYMREQ REQ0000
1.1280 +*/
1.1281 +LOCAL_C void CreateDeleteL(const TUid& aUid)
1.1282 + {
1.1283 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1301 "));
1.1284 + CRepository* repository;
1.1285 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1286 +
1.1287 + TInt x;
1.1288 + TReal y;
1.1289 + TBuf8<20> z8;
1.1290 + TBuf16<20> z16;
1.1291 +
1.1292 + /***************************************************************************************/
1.1293 + //test int create
1.1294 + /***************************************************************************************/
1.1295 + TInt r = repository->Get(KNewInt, x);
1.1296 + TEST2(r, KErrNotFound);
1.1297 +
1.1298 + const TInt KIntValue = 1234;
1.1299 + r = repository->Create(KNewInt, KIntValue);
1.1300 + TEST2(r, KErrNone);
1.1301 +
1.1302 + //close and reopen rep to check create is persisted
1.1303 + CleanupStack::PopAndDestroy(repository);
1.1304 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1305 +
1.1306 + r = repository->Get(KNewInt, x);
1.1307 + TEST2(r, KErrNone);
1.1308 + TEST(x==KIntValue);
1.1309 +
1.1310 + r = repository->Delete(KNewInt);
1.1311 + TEST2(r, KErrNone);
1.1312 +
1.1313 + r = repository->Get(KNewInt, x);
1.1314 + TEST2(r, KErrNotFound);
1.1315 +
1.1316 + // close and reopen rep to check delete is persisted
1.1317 + CleanupStack::PopAndDestroy(repository);
1.1318 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1319 + r = repository->Get(KNewInt, x);
1.1320 + TEST2(r, KErrNotFound);
1.1321 +
1.1322 +
1.1323 + // test int create - second run
1.1324 + r = repository->Create(KNewInt, KIntValue);
1.1325 + TEST2(r, KErrNone);
1.1326 +
1.1327 + //close and reopen rep to check create is persisted
1.1328 + CleanupStack::PopAndDestroy(repository);
1.1329 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1330 +
1.1331 + r = repository->Get(KNewInt, x);
1.1332 + TEST2(r, KErrNone);
1.1333 + TEST(x==KIntValue);
1.1334 +
1.1335 + r = repository->Delete(KNewInt);
1.1336 + TEST2(r, KErrNone);
1.1337 +
1.1338 + // close and reopen rep to check delete is persisted
1.1339 + CleanupStack::PopAndDestroy(repository);
1.1340 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1341 +
1.1342 + r = repository->Get(KNewInt, x);
1.1343 + TEST2(r, KErrNotFound);
1.1344 +
1.1345 +
1.1346 + /***************************************************************************************/
1.1347 + //test real create
1.1348 + /***************************************************************************************/
1.1349 +
1.1350 + r = repository->Get(KNewReal, y);
1.1351 + TEST2(r, KErrNotFound);
1.1352 +
1.1353 + const TReal KRealValue = 5678.0;
1.1354 + r = repository->Create(KNewReal, KRealValue);
1.1355 + TEST2(r, KErrNone);
1.1356 +
1.1357 + //close and reopen rep to check create is persisted
1.1358 + CleanupStack::PopAndDestroy(repository);
1.1359 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1360 +
1.1361 + r = repository->Get(KNewReal, y);
1.1362 + TEST2(r, KErrNone);
1.1363 + TEST(y==KRealValue);
1.1364 +
1.1365 + r = repository->Delete(KNewReal);
1.1366 + TEST2(r, KErrNone);
1.1367 +
1.1368 + // close and reopen rep to check delete is persisted
1.1369 + CleanupStack::PopAndDestroy(repository);
1.1370 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1371 +
1.1372 + r = repository->Get(KNewReal, y);
1.1373 + TEST2(r, KErrNotFound);
1.1374 +
1.1375 + //create real - second run
1.1376 + r = repository->Create(KNewReal, KRealValue);
1.1377 + TEST2(r, KErrNone);
1.1378 +
1.1379 + //close and reopen rep to check create is persisted
1.1380 + CleanupStack::PopAndDestroy(repository);
1.1381 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1382 +
1.1383 + r = repository->Get(KNewReal, y);
1.1384 + TEST2(r, KErrNone);
1.1385 + TEST(y==KRealValue);
1.1386 +
1.1387 + r = repository->Delete(KNewReal);
1.1388 + TEST2(r, KErrNone);
1.1389 +
1.1390 + // close and reopen rep to check delete is persisted
1.1391 + CleanupStack::PopAndDestroy(repository);
1.1392 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1393 +
1.1394 + r = repository->Get(KNewReal, x);
1.1395 + TEST2(r, KErrNotFound);
1.1396 +
1.1397 + /***************************************************************************************/
1.1398 + //test string8 create
1.1399 + /***************************************************************************************/
1.1400 +
1.1401 + r = repository->Get(KNewString8, z8);
1.1402 + TEST2(r, KErrNotFound);
1.1403 +
1.1404 + _LIT8(KString8Value, "ABCDEF");
1.1405 + r = repository->Create(KNewString8, KString8Value);
1.1406 + TEST2(r, KErrNone);
1.1407 +
1.1408 + //close and reopen rep to check create is persisted
1.1409 + CleanupStack::PopAndDestroy(repository);
1.1410 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1411 +
1.1412 + r = repository->Get(KNewString8, z8);
1.1413 + TEST2(r, KErrNone);
1.1414 + TEST(z8==KString8Value);
1.1415 +
1.1416 + r = repository->Delete(KNewString8);
1.1417 + TEST2(r, KErrNone);
1.1418 +
1.1419 + // close and reopen rep to check delete is persisted
1.1420 + CleanupStack::PopAndDestroy(repository);
1.1421 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1422 +
1.1423 + r = repository->Get(KNewString8, z8);
1.1424 + TEST2(r, KErrNotFound);
1.1425 +
1.1426 + r = repository->Create(KNewString8, KString8Value);
1.1427 + TEST2(r, KErrNone);
1.1428 +
1.1429 + //close and reopen rep to check create is persisted
1.1430 + CleanupStack::PopAndDestroy(repository);
1.1431 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1432 +
1.1433 + r = repository->Get(KNewString8, z8);
1.1434 + TEST2(r, KErrNone);
1.1435 + TEST(z8==KString8Value);
1.1436 +
1.1437 + r = repository->Delete(KNewString8);
1.1438 + TEST2(r, KErrNone);
1.1439 +
1.1440 + // close and reopen rep to check delete is persisted
1.1441 + CleanupStack::PopAndDestroy(repository);
1.1442 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1443 +
1.1444 + //second run
1.1445 + r = repository->Get(KNewString8, x);
1.1446 + TEST2(r, KErrNotFound);
1.1447 +
1.1448 + /***************************************************************************************/
1.1449 + //test string16 create
1.1450 + /***************************************************************************************/
1.1451 +
1.1452 + r = repository->Get(KNewString16, z16);
1.1453 + TEST2(r, KErrNotFound);
1.1454 +
1.1455 + _LIT(KString16Value, "ghijklmn");
1.1456 + r = repository->Create(KNewString16, KString16Value);
1.1457 + TEST2(r, KErrNone);
1.1458 +
1.1459 + //close and reopen rep to check create is persisted
1.1460 + CleanupStack::PopAndDestroy(repository);
1.1461 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1462 +
1.1463 + r = repository->Get(KNewString16, z16);
1.1464 + TEST2(r, KErrNone);
1.1465 + TEST(z16==KString16Value);
1.1466 +
1.1467 + r = repository->Delete(KNewString16);
1.1468 + TEST2(r, KErrNone);
1.1469 +
1.1470 + // close and reopen rep to check delete is persisted
1.1471 + CleanupStack::PopAndDestroy(repository);
1.1472 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1473 +
1.1474 + r = repository->Get(KNewString16, z16);
1.1475 + TEST2(r, KErrNotFound);
1.1476 +
1.1477 + r = repository->Create(KNewString16, KString16Value);
1.1478 + TEST2(r, KErrNone);
1.1479 +
1.1480 + //close and reopen rep to check create is persisted
1.1481 + CleanupStack::PopAndDestroy(repository);
1.1482 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1483 +
1.1484 + r = repository->Get(KNewString16, z16);
1.1485 + TEST2(r, KErrNone);
1.1486 + TEST(z16==KString16Value);
1.1487 +
1.1488 + r = repository->Delete(KNewString16);
1.1489 + TEST2(r, KErrNone);
1.1490 +
1.1491 + CleanupStack::PopAndDestroy(repository);
1.1492 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1493 +
1.1494 + r = repository->Get(KNewString16, x);
1.1495 + TEST2(r, KErrNotFound);
1.1496 +
1.1497 + CleanupStack::PopAndDestroy(repository);
1.1498 +
1.1499 + /***************************************************************************************/
1.1500 + //test create all kinds and delete with mask
1.1501 + /***************************************************************************************/
1.1502 +
1.1503 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1504 +
1.1505 + //first check that none of the settings exist in the repository
1.1506 + r = repository->Get(KNewSetting1, x);
1.1507 + TEST2(r, KErrNotFound);
1.1508 +
1.1509 + r = repository->Get(KNewSetting2, y);
1.1510 + TEST2(r, KErrNotFound);
1.1511 +
1.1512 + r = repository->Get(KNewSetting3, z8);
1.1513 + TEST2(r, KErrNotFound);
1.1514 +
1.1515 + r = repository->Get(KNewSetting4, z16);
1.1516 + TEST2(r, KErrNotFound);
1.1517 +
1.1518 + r = repository->Get(KNewSetting5, x);
1.1519 + TEST2(r, KErrNotFound);
1.1520 +
1.1521 + r = repository->Get(KNewSetting6, y);
1.1522 + TEST2(r, KErrNotFound);
1.1523 +
1.1524 + r = repository->Get(KNewSetting7, z8);
1.1525 + TEST2(r, KErrNotFound);
1.1526 +
1.1527 + r = repository->Get(KNewSetting8, z16);
1.1528 + TEST2(r, KErrNotFound);
1.1529 +
1.1530 + //now create all of the new settings
1.1531 + x = KNewSetting1Value;
1.1532 + r = repository->Create(KNewSetting1, x);
1.1533 + TEST2(r, KErrNone);
1.1534 +
1.1535 + r = repository->Create(KNewSetting2, KNewSetting2Value);
1.1536 + TEST2(r, KErrNone);
1.1537 +
1.1538 + r = repository->Create(KNewSetting3, KNewSetting3Value);
1.1539 + TEST2(r, KErrNone);
1.1540 +
1.1541 + r = repository->Create(KNewSetting4, KNewSetting4Value);
1.1542 + TEST2(r, KErrNone);
1.1543 +
1.1544 + x = KNewSetting5Value;
1.1545 + r = repository->Create(KNewSetting5, x);
1.1546 + TEST2(r, KErrNone);
1.1547 +
1.1548 + r = repository->Create(KNewSetting6, KNewSetting6Value);
1.1549 + TEST2(r, KErrNone);
1.1550 +
1.1551 + r = repository->Create(KNewSetting7, KNewSetting7Value);
1.1552 + TEST2(r, KErrNone);
1.1553 +
1.1554 + r = repository->Create(KNewSetting8, KNewSetting8Value);
1.1555 + TEST2(r, KErrNone);
1.1556 +
1.1557 + //close and reopen rep to check create is persisted
1.1558 + CleanupStack::PopAndDestroy(repository);
1.1559 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1560 +
1.1561 + //check that the new settings exist in the repository
1.1562 + r = repository->Get(KNewSetting1, x);
1.1563 + TEST(x == KNewSetting1Value);
1.1564 + TEST2(r, KErrNone);
1.1565 +
1.1566 + r = repository->Get(KNewSetting2, y);
1.1567 + TEST(y == KNewSetting2Value);
1.1568 + TEST2(r, KErrNone);
1.1569 +
1.1570 + r = repository->Get(KNewSetting3, z16);
1.1571 + TEST(z16 == KNewSetting3Value);
1.1572 + TEST2(r, KErrNone);
1.1573 +
1.1574 + r = repository->Get(KNewSetting4, z8);
1.1575 + TEST(z8 == KNewSetting4Value);
1.1576 + TEST2(r, KErrNone);
1.1577 +
1.1578 + r = repository->Get(KNewSetting5, x);
1.1579 + TEST(x == KNewSetting5Value);
1.1580 + TEST2(r, KErrNone);
1.1581 +
1.1582 + r = repository->Get(KNewSetting6, y);
1.1583 + TEST(y == KNewSetting6Value);
1.1584 + TEST2(r, KErrNone);
1.1585 +
1.1586 + r = repository->Get(KNewSetting7, z16);
1.1587 + TEST(z16 == KNewSetting7Value);
1.1588 + TEST2(r, KErrNone);
1.1589 +
1.1590 + r = repository->Get(KNewSetting8, z8);
1.1591 + TEST(z8 == KNewSetting8Value);
1.1592 + TEST2(r, KErrNone);
1.1593 +
1.1594 + // delete the settings
1.1595 + TUint32 errorKey = 0;
1.1596 + r = repository->Delete(0x00002000, 0xFFFFFF00, errorKey);
1.1597 + TEST2(errorKey, KUnspecifiedKey);
1.1598 + TEST2(r, KErrNone);
1.1599 +
1.1600 + // close and reopen rep to check delete is persisted
1.1601 + CleanupStack::PopAndDestroy(repository);
1.1602 + User::LeaveIfNull(repository = CRepository::NewLC(aUid));
1.1603 +
1.1604 + //check that none of the settings exist in the repository
1.1605 + r = repository->Get(KNewSetting1, x);
1.1606 + TEST2(r, KErrNotFound);
1.1607 +
1.1608 + r = repository->Get(KNewSetting2, y);
1.1609 + TEST2(r, KErrNotFound);
1.1610 +
1.1611 + r = repository->Get(KNewSetting3, z16);
1.1612 + TEST2(r, KErrNotFound);
1.1613 +
1.1614 + r = repository->Get(KNewSetting4, z8);
1.1615 + TEST2(r, KErrNotFound);
1.1616 +
1.1617 + r = repository->Get(KNewSetting5, x);
1.1618 + TEST2(r, KErrNotFound);
1.1619 +
1.1620 + r = repository->Get(KNewSetting6, y);
1.1621 + TEST2(r, KErrNotFound);
1.1622 +
1.1623 + r = repository->Get(KNewSetting7, z16);
1.1624 + TEST2(r, KErrNotFound);
1.1625 +
1.1626 + r = repository->Get(KNewSetting8, z8);
1.1627 + TEST2(r, KErrNotFound);
1.1628 +
1.1629 + CleanupStack::PopAndDestroy(repository);
1.1630 + }
1.1631 +
1.1632 +/**
1.1633 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1302
1.1634 +@SYMTestCaseDesc Multi client test
1.1635 +@SYMTestPriority High
1.1636 +@SYMTestActions Tests for CRepository::Get(),CRepository::Set() functions
1.1637 +@SYMTestExpectedResults Test must not fail
1.1638 +@SYMREQ REQ0000
1.1639 +*/
1.1640 +LOCAL_C void MultiClientL()
1.1641 + {
1.1642 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1302 "));
1.1643 + CRepository* repository1;
1.1644 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.1645 + CRepository* repository2;
1.1646 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository1));
1.1647 +
1.1648 + //
1.1649 + // Get/Set
1.1650 + //
1.1651 + TInt i;
1.1652 + TInt r = repository1->Set(KInt1, 0);
1.1653 + TEST2(r, KErrNone);
1.1654 + r = repository2->Get(KInt1, i);
1.1655 + TEST2(r, KErrNone);
1.1656 + TEST(i==0);
1.1657 +
1.1658 + r = repository2->Set(KInt1, 123);
1.1659 + TEST2(r, KErrNone);
1.1660 + r = repository1->Get(KInt1, i);
1.1661 + TEST2(r, KErrNone);
1.1662 + TEST(i==123);
1.1663 +
1.1664 + //
1.1665 + // Notification
1.1666 + //
1.1667 + TRequestStatus status;
1.1668 + r = repository1->NotifyRequest(KInt1, status);
1.1669 + TEST2(r, KErrNone);
1.1670 +
1.1671 + r = repository2->Set(KInt1, 0);
1.1672 + TEST2(r, KErrNone);
1.1673 + User::WaitForAnyRequest();
1.1674 + TEST(status==KInt1);
1.1675 +
1.1676 + CleanupStack::PopAndDestroy(2);
1.1677 + }
1.1678 +
1.1679 +/**
1.1680 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1303
1.1681 +@SYMTestCaseDesc Tests for resetting the new changes on CRepository
1.1682 +@SYMTestPriority High
1.1683 +@SYMTestActions Tests for CRepository::Reset() function
1.1684 + Tests for reset on a single setting that exists in the original ROM-based settings.
1.1685 + Tests for reset for a single setting that does not exist in the original ROM-based settings.
1.1686 + Tests for repository-wide reset for a repository that exists on ROM.
1.1687 + Tests for repository-wide reset for a repository that does not exist on ROM.
1.1688 +@SYMTestExpectedResults Test must not fail
1.1689 +@SYMREQ REQ0000
1.1690 +*/
1.1691 +LOCAL_C void ResetL()
1.1692 + {
1.1693 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1303 "));
1.1694 + CRepository* repositoryA;
1.1695 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidTestRepository1));
1.1696 +
1.1697 + //
1.1698 + // Test reset on a single setting that exists in the
1.1699 + // original ROM-based settings (we'll use KInt1)
1.1700 + //
1.1701 +
1.1702 + // Ensure KInt1 is set to a different value to its initial value
1.1703 + TInt r = repositoryA->Set(KInt1, KInt1_InitialValue+10);
1.1704 + TEST2(r, KErrNone);
1.1705 +
1.1706 + // We're testing we get a notification on a reset as well
1.1707 + TRequestStatus s;
1.1708 + r = repositoryA->NotifyRequest(KInt1, s);
1.1709 + TEST2(r, KErrNone);
1.1710 +
1.1711 + r = repositoryA->Reset(KInt1);
1.1712 + TEST2(r, KErrNone);
1.1713 +
1.1714 + // Check we got a notifiation
1.1715 + RThread thisThread;
1.1716 +
1.1717 + TEST2(thisThread.RequestCount(), 1);
1.1718 + User::WaitForAnyRequest();
1.1719 + TEST(s==KInt1);
1.1720 +
1.1721 + // Check KInt1 now has the right value
1.1722 + TInt x;
1.1723 + r = repositoryA->Get(KInt1, x);
1.1724 + TEST2(r, KErrNone);
1.1725 + TEST(x==KInt1_InitialValue);
1.1726 +
1.1727 + // A second reset should not generate notification
1.1728 + // as value has not changed
1.1729 + r = repositoryA->NotifyRequest(KInt1, s);
1.1730 + TEST2(r, KErrNone);
1.1731 + r = repositoryA->Reset(KInt1);
1.1732 + TEST2(r, KErrNone);
1.1733 +
1.1734 + //
1.1735 + // Test reset for a single setting that does not exist
1.1736 + // in the original ROM-based settings.
1.1737 + //
1.1738 + const TInt KIntValue = 1234;
1.1739 + r = repositoryA->Create(KNewInt, KIntValue);
1.1740 + TEST2(r, KErrNone);
1.1741 +
1.1742 + // We're testing we get a notification on a reset as well
1.1743 + r = repositoryA->NotifyRequest(KNewInt, s);
1.1744 + TEST2(r, KErrNone);
1.1745 +
1.1746 + r = repositoryA->Reset(KNewInt);
1.1747 + TEST2(r, KErrNone);
1.1748 +
1.1749 + // Check we got a notifiation
1.1750 + TEST2(thisThread.RequestCount(), 1);
1.1751 + User::WaitForAnyRequest();
1.1752 + TEST(s==KNewInt);
1.1753 +
1.1754 + // Check KNewInt has been deleted
1.1755 + r = repositoryA->Get(KNewInt, x);
1.1756 + TEST2(r, KErrNotFound);
1.1757 +
1.1758 + CleanupStack::PopAndDestroy(repositoryA);
1.1759 + User::WaitForAnyRequest(); //cancellation of request
1.1760 + TEST2(thisThread.RequestCount(), 0);
1.1761 +
1.1762 + //
1.1763 + // Test reset for a single setting in a repository that
1.1764 + // does not exist on ROM.
1.1765 + //
1.1766 + const TInt KSettingKey = KNonExisitentSetting;
1.1767 + const TInt KInitialValue = 10;
1.1768 +
1.1769 + CRepository* repositoryB;
1.1770 + User::LeaveIfNull(repositoryB = CRepository::NewLC(KUidDriveCOnlyRepository));
1.1771 +
1.1772 + r = repositoryB->Create(KSettingKey, KInitialValue);
1.1773 + TEST2(r, KErrNone);
1.1774 +
1.1775 + // We're testing we get a notification on a reset as well
1.1776 + r = repositoryB->NotifyRequest(KSettingKey, s);
1.1777 + TEST2(r, KErrNone);
1.1778 +
1.1779 + r = repositoryB->Reset(KSettingKey);
1.1780 + TEST2(r, KErrNone);
1.1781 +
1.1782 + // Check we got a notifiation
1.1783 + TEST2(thisThread.RequestCount(), 1);
1.1784 + User::WaitForAnyRequest();
1.1785 + TEST(s==KSettingKey);
1.1786 +
1.1787 + // Check KSettingKey has been deleted
1.1788 + r = repositoryB->Get(KSettingKey, x);
1.1789 + TEST2(r, KErrNotFound);
1.1790 +
1.1791 + CleanupStack::PopAndDestroy(repositoryB);
1.1792 + //
1.1793 + // Test repository-wide reset for a repository
1.1794 + // that exists on ROM.
1.1795 + //
1.1796 + CRepository* repositoryC;
1.1797 + User::LeaveIfNull(repositoryC = CRepository::NewLC(KUidResetTestRepository));
1.1798 +
1.1799 + const TInt KNewSetting1 = 5;
1.1800 + const TInt KNewSetting2 = 6;
1.1801 + r = repositoryC->Create(KNewSetting1, 0);
1.1802 + TEST2(r, KErrNone);
1.1803 + r = repositoryC->Create(KNewSetting2, 0);
1.1804 + TEST2(r, KErrNone);
1.1805 +
1.1806 + r = repositoryC->Create(65, 1);
1.1807 + TEST2(r, KErrNone);
1.1808 +
1.1809 + r = repositoryC->Set(70, 1);
1.1810 + TEST2(r, KErrNone);
1.1811 +
1.1812 + r = repositoryC->Create(80, 1);
1.1813 + TEST2(r, KErrNone);
1.1814 +
1.1815 + r = repositoryC->Create(90, 1);
1.1816 + TEST2(r, KErrNone);
1.1817 +
1.1818 + r = repositoryC->NotifyRequest(0, 0, s);
1.1819 + TEST2(r, KErrNone);
1.1820 +
1.1821 + r = repositoryC->Reset();
1.1822 + TEST2(r, KErrNone);
1.1823 + TEST(thisThread.RequestCount()==1);
1.1824 + User::WaitForAnyRequest();
1.1825 + TEST(s==KUnspecifiedKey);
1.1826 +
1.1827 + r = repositoryC->Get(10, x);
1.1828 + TEST2(r, KErrNone);
1.1829 + TEST(x==10);
1.1830 +
1.1831 + r = repositoryC->Get(40, x);
1.1832 + TEST2(r, KErrNone);
1.1833 + TEST(x==0);
1.1834 +
1.1835 + r = repositoryC->Get(50, x);
1.1836 + TEST2(r, KErrNone);
1.1837 + TEST(x==0);
1.1838 +
1.1839 + r = repositoryC->Get(60, x);
1.1840 + TEST2(r, KErrNone);
1.1841 + TEST(x==0);
1.1842 +
1.1843 + r = repositoryC->Get(70, x);
1.1844 + TEST2(r, KErrNone);
1.1845 + TEST(x==0);
1.1846 +
1.1847 + TBuf<10> z;
1.1848 + r = repositoryC->Get(20, z);
1.1849 + TEST2(r, KErrNone);
1.1850 + TEST(z==_L("string"));
1.1851 +
1.1852 + TReal y;
1.1853 + r = repositoryC->Get(30, y);
1.1854 + TEST2(r, KErrNone);
1.1855 + TEST(y==1);
1.1856 +
1.1857 + r = repositoryC->Get(5, x);
1.1858 + TEST2(r, KErrNotFound);
1.1859 + r = repositoryC->Get(6, x);
1.1860 + TEST2(r, KErrNotFound);
1.1861 + r = repositoryC->Get(65, x);
1.1862 + TEST2(r, KErrNotFound);
1.1863 + r = repositoryC->Get(80, x);
1.1864 + TEST2(r, KErrNotFound);
1.1865 + r = repositoryC->Get(90, x);
1.1866 + TEST2(r, KErrNotFound);
1.1867 +
1.1868 + CleanupStack::PopAndDestroy(repositoryC);
1.1869 +
1.1870 + //
1.1871 + // Test repository-wide reset for a repository
1.1872 + // that does not exist on ROM.
1.1873 + //
1.1874 + CRepository* repositoryD;
1.1875 + User::LeaveIfNull(repositoryD = CRepository::NewLC(KUidDriveCOnlyRepository));
1.1876 +
1.1877 + r = repositoryD->Create(KSettingKey, KInitialValue);
1.1878 + TEST2(r, KErrNone);
1.1879 +
1.1880 + // We're testing we get a notification on a reset as well
1.1881 + r = repositoryD->NotifyRequest(KSettingKey, s);
1.1882 + TEST2(r, KErrNone);
1.1883 +
1.1884 + r = repositoryD->Reset();
1.1885 + TEST2(r, KErrNone);
1.1886 +
1.1887 + // Check we got a notifiation
1.1888 + TEST(thisThread.RequestCount()==1);
1.1889 + User::WaitForAnyRequest();
1.1890 + TEST(s==KUnspecifiedKey);
1.1891 +
1.1892 + // Check KSettingKey has been deleted
1.1893 + r = repositoryD->Get(KSettingKey, x);
1.1894 + TEST2(r, KErrNotFound);
1.1895 +
1.1896 + // Recreate KSettingKey
1.1897 + r = repositoryD->Create(KSettingKey, 10);
1.1898 + TEST2(r, KErrNone);
1.1899 +
1.1900 + // Reset KSettingKey only
1.1901 + r = repositoryD->Reset(KSettingKey);
1.1902 + TEST2(r, KErrNone);
1.1903 +
1.1904 + // Check KSettingKey has been deleted
1.1905 + r = repositoryD->Get(KSettingKey, x);
1.1906 + TEST2(r, KErrNotFound);
1.1907 +
1.1908 + CleanupStack::PopAndDestroy(repositoryD);
1.1909 + }
1.1910 +
1.1911 +LOCAL_C void ResetCreL()
1.1912 + {
1.1913 + CRepository* repositoryA;
1.1914 + TInt r = KErrNone;
1.1915 + TRequestStatus s;
1.1916 + TInt x;
1.1917 + RThread thisThread;
1.1918 +
1.1919 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1920 +
1.1921 + // test for .cre file
1.1922 + // Test reset on a single setting that exists in the
1.1923 + // original ROM-based settings (we'll use KInt1)
1.1924 + //
1.1925 +
1.1926 + // Ensure KInt1 is set to a different value to its initial value
1.1927 + r = repositoryA->Set(KInt1, KInt1_InitialValue+10);
1.1928 + TEST2(r, KErrNone);
1.1929 +
1.1930 + CleanupStack::PopAndDestroy(repositoryA);
1.1931 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1932 +
1.1933 + // We're testing we get a notification on a reset as well
1.1934 + r = repositoryA->NotifyRequest(KInt1, s);
1.1935 + TEST2(r, KErrNone);
1.1936 +
1.1937 + r = repositoryA->Reset(KInt1);
1.1938 + TEST2(r, KErrNone);
1.1939 +
1.1940 + // Check we got a notifiation
1.1941 + TEST2(thisThread.RequestCount(), 1);
1.1942 + User::WaitForAnyRequest();
1.1943 + TEST(s == KInt1);
1.1944 +
1.1945 + CleanupStack::PopAndDestroy(repositoryA);
1.1946 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1947 +
1.1948 + // Check KInt1 now has the right value
1.1949 + r = repositoryA->Get(KInt1, x);
1.1950 + TEST2(r, KErrNone);
1.1951 + TEST2(x, KInt1_InitialValue);
1.1952 +
1.1953 + // A second reset should not generate notification
1.1954 + // as value has not changed
1.1955 + r = repositoryA->NotifyRequest(KInt1, s);
1.1956 + TEST2(r, KErrNone);
1.1957 +
1.1958 + r = repositoryA->Reset(KInt1);
1.1959 + TEST2(r, KErrNone);
1.1960 + TEST2(thisThread.RequestCount(), 0);
1.1961 +
1.1962 + CleanupStack::PopAndDestroy(repositoryA);
1.1963 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1964 + //
1.1965 + // Test reset for a single setting that does not exist
1.1966 + // in the original ROM-based settings.
1.1967 + //
1.1968 + const TInt KIntValue = 1234;
1.1969 + r = repositoryA->Create(KNewInt, KIntValue);
1.1970 + TEST2(r, KErrNone);
1.1971 +
1.1972 + CleanupStack::PopAndDestroy(repositoryA);
1.1973 + User::WaitForAnyRequest();//this is the cancellation of last notify request
1.1974 + TEST2(thisThread.RequestCount(), 0);
1.1975 +
1.1976 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1977 +
1.1978 + // We're testing we get a notification on a reset as well
1.1979 + r = repositoryA->NotifyRequest(KNewInt, s);
1.1980 + TEST2(r, KErrNone);
1.1981 +
1.1982 + r = repositoryA->Reset(KNewInt);
1.1983 + TEST2(r, KErrNone);
1.1984 +
1.1985 + // Check we got a notifiation
1.1986 + TEST2(thisThread.RequestCount(), 1);
1.1987 + User::WaitForAnyRequest();
1.1988 + TEST(s == KNewInt);
1.1989 +
1.1990 + CleanupStack::PopAndDestroy(repositoryA);
1.1991 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1992 +
1.1993 + // Check KNewInt has been deleted
1.1994 + r = repositoryA->Get(KNewInt, x);
1.1995 + TEST2(r, KErrNotFound);
1.1996 +
1.1997 + CleanupStack::PopAndDestroy(repositoryA);
1.1998 + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1));
1.1999 +
1.2000 + // Reset entire repository
1.2001 + r = repositoryA->Reset();
1.2002 + TEST2(r, KErrNone);
1.2003 +
1.2004 + CleanupStack::PopAndDestroy(repositoryA);
1.2005 + }
1.2006 +
1.2007 +/**
1.2008 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1304
1.2009 +@SYMTestCaseDesc Tests for initialising file searching
1.2010 +@SYMTestPriority High
1.2011 +@SYMTestActions Tests for CRepository::Get() function
1.2012 +@SYMTestExpectedResults Test must not fail
1.2013 +@SYMREQ REQ0000
1.2014 +*/
1.2015 +LOCAL_C void IniFileSearching()
1.2016 + {
1.2017 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1304 "));
1.2018 + const TInt KSettingKey = 1;
1.2019 +
1.2020 + _LIT(KDriveZ, "drive z");
1.2021 +
1.2022 + const TInt KBufLen = 7; // = Max of 3 above string lengths
1.2023 +
1.2024 + //
1.2025 + // File on drive C should take precedence
1.2026 + //
1.2027 + CRepository* repository = CRepository::NewL(KUidDriveCRepository);
1.2028 +
1.2029 + TBuf<KBufLen> str;
1.2030 + TInt r = repository->Get(KSettingKey, str);
1.2031 + TEST2(r, KErrNone);
1.2032 + TEST(str==KDriveZ);
1.2033 +
1.2034 + delete repository;
1.2035 + }
1.2036 +
1.2037 +/**
1.2038 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1305
1.2039 +@SYMTestCaseDesc Tests for creating new repository on drive C:
1.2040 +@SYMTestPriority High
1.2041 +@SYMTestActions Tests for CRepository::NewL() function
1.2042 +@SYMTestExpectedResults Test must not fail
1.2043 +@SYMREQ REQ0000
1.2044 +*/
1.2045 +LOCAL_C void RepositoryOnDriveC()
1.2046 + {
1.2047 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1305 "));
1.2048 + const TInt KSettingKey = KNonExisitentSetting;
1.2049 + const TInt KInitialValue = 10;
1.2050 +
1.2051 + CRepository* repository = CRepository::NewL(KUidDriveCOnlyRepository);
1.2052 + CleanupStack::PushL(repository);
1.2053 +
1.2054 + TInt val;
1.2055 + TInt r = repository->Get(KSettingKey, val);
1.2056 + TEST2(r, KErrNotFound);
1.2057 +
1.2058 + r = repository->Create(KSettingKey, KInitialValue);
1.2059 + TEST2(r, KErrNone);
1.2060 +
1.2061 + r = repository->Get(KSettingKey, val);
1.2062 + TEST2(r, KErrNone);
1.2063 + TEST(val==KInitialValue);
1.2064 +
1.2065 + CleanupStack::PopAndDestroy(repository);
1.2066 + repository = CRepository::NewL(KUidDriveCOnlyRepository);
1.2067 + CleanupStack::PushL(repository);
1.2068 +
1.2069 + r = repository->Get(KSettingKey, val);
1.2070 + TEST2(r, KErrNone);
1.2071 + TEST(val==KInitialValue);
1.2072 +
1.2073 + r = repository->Set(KSettingKey, KInitialValue+1);
1.2074 + TEST2(r, KErrNone);
1.2075 +
1.2076 + r = repository->Get(KSettingKey, val);
1.2077 + TEST2(r, KErrNone);
1.2078 + TEST(val==KInitialValue+1);
1.2079 +
1.2080 + r = repository->Delete(KSettingKey);
1.2081 + TEST2(r, KErrNone);
1.2082 +
1.2083 + CleanupStack::PopAndDestroy(repository);
1.2084 + repository = CRepository::NewL(KUidDriveCOnlyRepository);
1.2085 + CleanupStack::PushL(repository);
1.2086 +
1.2087 + r = repository->Get(KSettingKey, val);
1.2088 + TEST2(r, KErrNotFound);
1.2089 +
1.2090 + CleanupStack::PopAndDestroy(repository);
1.2091 + }
1.2092 +
1.2093 +/**
1.2094 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1656
1.2095 +@SYMTestCaseDesc Notify-only client optimization test
1.2096 +@SYMTestPriority High
1.2097 +@SYMTestActions Tests for on-demand loading in API calls after in-session
1.2098 + unloading of repositories. Also tests for notification functionality.
1.2099 +@SYMTestExpectedResults Test must not fail
1.2100 +@SYMPREQ PREQ1228
1.2101 +*/
1.2102 +LOCAL_C void NotifyOnlyL()
1.2103 + {
1.2104 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1656 "));
1.2105 + CRepository* repository1;
1.2106 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2107 +
1.2108 + // check that functions work
1.2109 + TInt i;
1.2110 + TInt r = repository1->Get(KInt1, i);
1.2111 + TEST2(r, KErrNone);
1.2112 + TEST(i==1);
1.2113 +
1.2114 + CleanupStack::PopAndDestroy();
1.2115 + // Kill the server to force clearing the cache
1.2116 + KillCentRepServerL();
1.2117 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2118 +
1.2119 + r = repository1->Set(KInt1, i);
1.2120 + TEST2(r, KErrNone);
1.2121 +
1.2122 + CleanupStack::PopAndDestroy();
1.2123 + // Kill the server to force clearing the cache
1.2124 + KillCentRepServerL();
1.2125 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2126 +
1.2127 + const TInt KIntValue = 1234;
1.2128 + r = repository1->Create(KNewInt, KIntValue);
1.2129 + TEST2(r, KErrNone);
1.2130 +
1.2131 + CleanupStack::PopAndDestroy();
1.2132 + // Kill the server to force clearing the cache
1.2133 + KillCentRepServerL();
1.2134 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2135 +
1.2136 + RArray<TUint32> foundIds;
1.2137 + TInt leaveCode = KErrNone;
1.2138 + TRAP(leaveCode, r= repository1->FindEqL(0, 0, KIntValue, foundIds));
1.2139 + if (leaveCode != KErrNone)
1.2140 + r = leaveCode ;
1.2141 + if(OomTesting && r==KErrNoMemory)
1.2142 + {
1.2143 + foundIds.Close();
1.2144 + User::Leave(KErrNoMemory);
1.2145 + }
1.2146 + TEST2(r, KErrNone);
1.2147 + TEST(foundIds.Count()==1);
1.2148 + TEST(foundIds[0]==KNewInt);
1.2149 + foundIds.Reset();
1.2150 +
1.2151 + CleanupStack::PopAndDestroy();
1.2152 + // Kill the server to force clearing the cache
1.2153 + KillCentRepServerL();
1.2154 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2155 +
1.2156 + r = repository1->Delete(KNewInt);
1.2157 + TEST2(r, KErrNone);
1.2158 +
1.2159 + CleanupStack::PopAndDestroy();
1.2160 +
1.2161 + // check that multiple clients work
1.2162 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2163 +
1.2164 + r = repository1->Get(KInt1, i);
1.2165 + TEST2(r, KErrNone);
1.2166 + TEST(i==1);
1.2167 +
1.2168 + CleanupStack::PopAndDestroy();
1.2169 + // Kill the server to force clearing the cache
1.2170 + KillCentRepServerL();
1.2171 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2172 +
1.2173 + CRepository* repository2;
1.2174 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository1));
1.2175 +
1.2176 + r = repository2->Get(KInt1, i);
1.2177 + TEST2(r, KErrNone);
1.2178 + TEST(i==1);
1.2179 +
1.2180 + r = repository1->Get(KInt1, i);
1.2181 + TEST2(r, KErrNone);
1.2182 + TEST(i==1);
1.2183 +
1.2184 + CleanupStack::PopAndDestroy(2);
1.2185 +
1.2186 + // check that notifications work
1.2187 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1));
1.2188 + TRequestStatus status1;
1.2189 + r = repository1->NotifyRequest(KInt1, status1);
1.2190 + TEST2(r, KErrNone);
1.2191 +
1.2192 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository1));
1.2193 + r = repository2->Set(KInt1, 0);
1.2194 + TEST2(r, KErrNone);
1.2195 + User::WaitForAnyRequest();
1.2196 + TEST(status1==KInt1);
1.2197 +
1.2198 + r = repository1->NotifyRequest(KInt1, status1);
1.2199 + TEST2(r, KErrNone);
1.2200 +
1.2201 + CleanupRepositoryCache();
1.2202 +
1.2203 + r = repository2->Set(KInt1, 2);
1.2204 + TEST2(r, KErrNone);
1.2205 + User::WaitForAnyRequest();
1.2206 + TEST(status1==KInt1);
1.2207 +
1.2208 + r = repository1->NotifyRequest(KInt1, status1);
1.2209 + TEST2(r, KErrNone);
1.2210 +
1.2211 + CRepository* repository3;
1.2212 + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository1));
1.2213 + TRequestStatus status3;
1.2214 + r = repository3->NotifyRequest(KInt1, status3);
1.2215 + TEST2(r, KErrNone);
1.2216 +
1.2217 + r = repository2->Set(KInt1, 0);
1.2218 + TEST2(r, KErrNone);
1.2219 + User::WaitForAnyRequest();
1.2220 + TEST(status1==KInt1);
1.2221 + TEST(status3==KInt1);
1.2222 +
1.2223 + r = repository1->NotifyRequest(KInt1, status1);
1.2224 + TEST2(r, KErrNone);
1.2225 + r = repository3->NotifyRequest(KInt1, status3);
1.2226 + TEST2(r, KErrNone);
1.2227 +
1.2228 + CleanupRepositoryCache();
1.2229 +
1.2230 + r = repository2->Set(KInt1, 1);
1.2231 + TEST2(r, KErrNone);
1.2232 + User::WaitForAnyRequest();
1.2233 + TEST(status1==KInt1);
1.2234 + TEST(status3==KInt1);
1.2235 +
1.2236 + CleanupStack::PopAndDestroy(3);
1.2237 + // Kill the server to force clearing the cache
1.2238 + KillCentRepServerL();
1.2239 + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository1));
1.2240 +
1.2241 + r = repository3->Get(KInt1, i);
1.2242 + TEST2(r, KErrNone);
1.2243 + TEST(i==1);
1.2244 +
1.2245 + CleanupStack::PopAndDestroy();
1.2246 + }
1.2247 +
1.2248 +/**
1.2249 +@SYMTestCaseID PDS-CENTRALREPOSITORY-CT-4113
1.2250 +@SYMTestCaseDesc Validates meta data is not lost before a transaction is committed
1.2251 + when deleting a range of settings.
1.2252 +@SYMTestPriority High
1.2253 +@SYMTestActions 1) Start a transaction.
1.2254 + 2) Delete a setting using the delete range function.
1.2255 + 3) Create a new setting (using the deleted key)
1.2256 + 4) Commit the transaction.
1.2257 + 5) Check the metadata of the setting.
1.2258 +@SYMTestExpectedResults When deleting a range of settings in a keyspace, and then
1.2259 + creating a new setting (with a key of a previously deleted setting)
1.2260 + the meta data should not be reset to 0, it should take on the default
1.2261 + metadata, if it exists.
1.2262 +@SYMDEF DEF144530
1.2263 +*/
1.2264 +LOCAL_C void RangeDeleteMetaL()
1.2265 + {
1.2266 + TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-CT-4113 "));
1.2267 +
1.2268 + TUint32 partialKey = 0x0000004;
1.2269 + TUint32 mask = 0xFFFFFFF;
1.2270 + TUint32 meta = 0;
1.2271 + TUint32 expectedMeta = 0x10; // 16
1.2272 + TUint32 keyCount = 0;
1.2273 + TUint32 expectedKeyCount = 1;
1.2274 + TUint32 error;
1.2275 +
1.2276 + CRepository* repository;
1.2277 + User::LeaveIfNull(repository = CRepository::NewL(KUidTestRepository3)); // 00000103.txt
1.2278 +
1.2279 + repository->StartTransaction(CRepository::EReadWriteTransaction);
1.2280 +
1.2281 + // Only want to delete 1 specific key, using the range delete function.
1.2282 + TInt ret = repository->Delete(partialKey, mask, error);
1.2283 + // We don't care about 'error' if 'ret==KErrNone'.
1.2284 + TEST2(ret, KErrNone);
1.2285 +
1.2286 + // Create a new setting that is the same key and type as the deleted one.
1.2287 + ret = repository->Create(partialKey, 200);
1.2288 + TEST2(ret, KErrNone);
1.2289 +
1.2290 + ret = repository->CommitTransaction(keyCount);
1.2291 + TEST2(ret, KErrNone);
1.2292 + // Confirm only 1 setting was updated.
1.2293 + TEST2(keyCount, expectedKeyCount);
1.2294 +
1.2295 + // Check the meta data of the newly created setting. It should be the
1.2296 + // the same as the defaultmeta value in the keyspace.
1.2297 + ret = repository->GetMeta(partialKey, meta);
1.2298 + TEST2(ret, KErrNone);
1.2299 + TEST2(meta, expectedMeta);
1.2300 +
1.2301 + delete repository;
1.2302 + }
1.2303 +
1.2304 +
1.2305 +/**
1.2306 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0494
1.2307 +@SYMTestCaseDesc Tests the various functions on CentralRepository
1.2308 +@SYMTestPriority High
1.2309 +@SYMTestActions Tests the get/set,find,notify,create/delete,
1.2310 + file searching in repository,the repository on drive c only
1.2311 + Tests for multiple clients,for restoring factory settings.
1.2312 +@SYMTestExpectedResults Test must not fail
1.2313 +@SYMREQ REQ0000
1.2314 +*/
1.2315 +LOCAL_C void FuncTestsL()
1.2316 + {
1.2317 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0494 Open/Close repository "));
1.2318 + OpenRepositoryL();
1.2319 +
1.2320 + TheTest.Next(_L("Get/Set .ini"));
1.2321 + GetSetL(KUidTestRepository1);
1.2322 +
1.2323 + TheTest.Next(_L("Get/Set .cre"));
1.2324 + GetSetL(KUidCreTestRepository1);
1.2325 +
1.2326 + TheTest.Next(_L("Find"));
1.2327 + FindL();
1.2328 +
1.2329 + TheTest.Next(_L("Notify"));
1.2330 + NotifyL();
1.2331 +
1.2332 + TheTest.Next(_L("Create/Delete .ini"));
1.2333 + CreateDeleteL(KUidTestRepository1);
1.2334 +
1.2335 + TheTest.Next(_L("Create/Delete .cre"));
1.2336 + CreateDeleteL(KUidCreTestRepository1);
1.2337 +
1.2338 + TheTest.Next(_L("Initialisation file searching"));
1.2339 + IniFileSearching();
1.2340 +
1.2341 + TheTest.Next(_L("Repository on Drive C only"));
1.2342 + RepositoryOnDriveC();
1.2343 +
1.2344 + TheTest.Next(_L("Multiple clients"));
1.2345 + MultiClientL();
1.2346 +
1.2347 + TheTest.Next(_L("Restore factory settings"));
1.2348 + ResetL();
1.2349 +
1.2350 + TheTest.Next(_L("Restore factory settings from binary based rep"));
1.2351 + ResetCreL();
1.2352 +
1.2353 + TheTest.Next(_L("Negative testing for the notification cancelling"));
1.2354 + CancelNotificationsL();
1.2355 +
1.2356 + TheTest.Next(_L("Notify-only client optimizations"));
1.2357 + NotifyOnlyL();
1.2358 +
1.2359 + TheTest.Next(_L("Meta data after a Range Delete in transaction"));
1.2360 + RangeDeleteMetaL();
1.2361 +
1.2362 + TheTest.End();
1.2363 + }
1.2364 +
1.2365 +/**
1.2366 +OomTest
1.2367 +Function to convert a test into an OOM test
1.2368 +
1.2369 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0495
1.2370 +@SYMTestCaseDesc Out of memory test
1.2371 +@SYMTestPriority High
1.2372 +@SYMTestActions Tests for running out of memory
1.2373 +@SYMTestExpectedResults Test must not fail
1.2374 +@SYMREQ REQ0000
1.2375 +*/
1.2376 +LOCAL_C void OomTest(void (*testFuncL)())
1.2377 + {
1.2378 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0495 "));
1.2379 + TInt error;
1.2380 + TInt count = 0;
1.2381 +
1.2382 + do
1.2383 + {
1.2384 + User::__DbgSetAllocFail(RHeap::EUser, RHeap::EFailNext, ++count);
1.2385 + User::__DbgMarkStart(RHeap::EUser);
1.2386 +
1.2387 + // find out the number of open handles
1.2388 + TInt startProcessHandleCount;
1.2389 + TInt startThreadHandleCount;
1.2390 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.2391 +
1.2392 + TRAP(error, (testFuncL)());
1.2393 +
1.2394 + // check that no handles have leaked
1.2395 + TInt endProcessHandleCount;
1.2396 + TInt endThreadHandleCount;
1.2397 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.2398 +
1.2399 + TEST2(endProcessHandleCount, startProcessHandleCount);
1.2400 + TEST2(endThreadHandleCount, startThreadHandleCount);
1.2401 +
1.2402 + User::__DbgMarkEnd(RHeap::EUser, 0);
1.2403 + } while(error == KErrNoMemory);
1.2404 +
1.2405 + _LIT(KTestFailed, "Out of memory test failure on iteration %d\n");
1.2406 + __ASSERT_ALWAYS(error==KErrNone, TheTest.Panic(error, KTestFailed, count));
1.2407 +
1.2408 + User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1);
1.2409 + }
1.2410 +
1.2411 +LOCAL_C void OomTestsL()
1.2412 + {
1.2413 + TheTest.Start(_L("Open/Close repository"));
1.2414 + OomTest(OpenRepositoryL);
1.2415 +
1.2416 + TheTest.Next(_L("GetSet for KUidTestRepository1"));
1.2417 + GetSetL(KUidTestRepository1);
1.2418 + TheTest.Next(_L("GetSet for KUidCreTestRepository1"));
1.2419 + GetSetL(KUidCreTestRepository1);
1.2420 +
1.2421 + TheTest.Next(_L("Find"));
1.2422 + OomTest(FindL);
1.2423 +
1.2424 + TheTest.End();
1.2425 + }
1.2426 +
1.2427 +//This function tests the replacement of RFile with RFileBuf in CIniFileOut class (inifile.h)
1.2428 +//It shows that there is approx. 20% (LUBBOCK) performance boost when using simple "Set"
1.2429 +//operations. It may be even better when using "Commit" functionality.
1.2430 +static void PerformanceTestL()
1.2431 + {
1.2432 + CRepository* repository = CRepository::NewL(KUidDriveCOnlyRepository);
1.2433 + CleanupStack::PushL(repository);
1.2434 + //Test settings IDs
1.2435 + const TUint KIntId = 101;
1.2436 + const TUint KRealId = 102;
1.2437 + const TUint KDes16Id = 103;
1.2438 + const TUint KDes8Id = 104;
1.2439 + //Create test settings
1.2440 + TInt err = repository->Create(KIntId, 1);
1.2441 + TEST2(err, KErrNone);
1.2442 + err = repository->Create(KRealId, 1.1);
1.2443 + TEST2(err, KErrNone);
1.2444 + err = repository->Create(KDes16Id, _L16("DES16"));
1.2445 + TEST2(err, KErrNone);
1.2446 + err = repository->Create(KDes8Id, _L8("DES8"));
1.2447 + TEST2(err, KErrNone);
1.2448 + //Performance test
1.2449 + TBuf16<32> buf16;
1.2450 + TBuf8<32> buf8;
1.2451 + TUint timeStart = User::TickCount();
1.2452 + for(TInt i=0;i<500;++i)
1.2453 + {
1.2454 + buf16.Zero();
1.2455 + buf16.AppendNum(i);
1.2456 + buf8.Zero();
1.2457 + buf8.AppendNum(i);
1.2458 +
1.2459 + TInt err = repository->Set(KIntId, i);
1.2460 + TEST2(err, KErrNone);
1.2461 + err = repository->Set(KRealId, (TReal)i);
1.2462 + TEST2(err, KErrNone);
1.2463 + err = repository->Set(KDes16Id, buf16);
1.2464 + TEST2(err, KErrNone);
1.2465 + err = repository->Set(KDes8Id, buf8);
1.2466 + TEST2(err, KErrNone);
1.2467 + }
1.2468 + TUint timeEnd = User::TickCount();
1.2469 + CleanupStack::PopAndDestroy(repository);
1.2470 + TheTest.Printf(_L("\nPerformanceTestL - %d ticks\n"), timeEnd-timeStart);
1.2471 + }
1.2472 +
1.2473 +/**
1.2474 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0497
1.2475 +@SYMTestCaseDesc CentralRepository functionality test
1.2476 +@SYMTestPriority High
1.2477 +@SYMTestActions Wrapper function calling up test functions
1.2478 +@SYMTestExpectedResults Test must not fail
1.2479 +@SYMREQ REQ0000
1.2480 +*/
1.2481 +LOCAL_C void MainL()
1.2482 + {
1.2483 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0497 Functional tests "));
1.2484 + OomTesting = EFalse;
1.2485 + // Existance of caching functionality invalidates some tests and
1.2486 + // makes them fail. So cleanup cace.
1.2487 + RestoreTestFilesL();
1.2488 + FuncTestsL();
1.2489 +
1.2490 + TheTest.Next(_L("Out-of-memory tests"));
1.2491 + OomTesting = ETrue;
1.2492 + //Reset the KUidTestRepository1 which was modified by the previous test
1.2493 + //and is used in the next test.
1.2494 + ResetTestRepositoryL();
1.2495 + OomTestsL();
1.2496 +
1.2497 + TheTest.Next(_L("Performance test"));
1.2498 + PerformanceTestL();
1.2499 +
1.2500 + TheTest.Next(_L("Clean out C: files"));
1.2501 + CleanupCDriveL();
1.2502 +
1.2503 + TheTest.End();
1.2504 + TheTest.Close();
1.2505 + }
1.2506 +
1.2507 +TInt E32Main()
1.2508 + {
1.2509 + __UHEAP_MARK;
1.2510 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.2511 + if(!cleanup)
1.2512 + return KErrNoMemory;
1.2513 +
1.2514 + TRAPD(err, MainL());
1.2515 + if (err != KErrNone)
1.2516 + User::Panic(_L("Testing failed: "), err);
1.2517 +
1.2518 + delete cleanup;
1.2519 + __UHEAP_MARKEND;
1.2520 +
1.2521 + return 0;
1.2522 + }