1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/centralrepository/test/t_oomcenrepsrv.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1454 @@
1.4 +// Copyright (c) 2005-2009 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 +// t_oomcenrep.cpp
1.18 +//
1.19 +//
1.20 +
1.21 +#include "t_cenrep_helper.h"
1.22 +#include <e32test.h>
1.23 +#include <f32file.h>
1.24 +#include <utf.h>
1.25 +#include "srvsess.h"
1.26 +#include "sessmgr.h"
1.27 +#include "srvres.h"
1.28 +#include "srvreqs.h"
1.29 +#include "cachemgr.h"
1.30 +#include "clientrequest.h"
1.31 +#include "install.h"
1.32 +#include <bautils.h>
1.33 +
1.34 +LOCAL_D RFs TheFs;
1.35 +LOCAL_D RTest TheTest (_L ("t_oomcenrep.exe"));
1.36 +
1.37 +#ifdef __SECURE_DATA__
1.38 +_LIT(KInstallDirFile, "c:\\private\\10202BE9\\persists\\installdir.bin");
1.39 +
1.40 +_LIT(KPersistsFile, "c:\\private\\10202BE9\\persists\\11111111.cre");
1.41 +_LIT(KInstallPersistsFile, "c:\\private\\10202BE9\\persists\\11111110.cre");
1.42 +_LIT(KPersistsFileNoUpgrade, "c:\\private\\10202BE9\\bur\\11111111.crn");
1.43 +_LIT(KPersistsFileUpgraded, "c:\\private\\10202BE9\\bur\\11111111.cru");
1.44 +
1.45 +_LIT(KRomUpgradeRev1File, "z:\\private\\10202BE9\\11111111.txu");
1.46 +_LIT(KRomUpgradeRev2File, "z:\\private\\10202BE9\\11111112.txu");
1.47 +_LIT(KUpgradeFile, "c:\\private\\10202BE9\\11111111.txt");
1.48 +
1.49 +_LIT(KInstallOnlyFile, "z:\\private\\10202BE9\\11111110.cri");
1.50 +_LIT(KInstallOnlyUpgradeFile, "z:\\private\\10202BE9\\11111110.cru");
1.51 +_LIT(KInstallFile, "c:\\private\\10202BE9\\11111110.cre");
1.52 +
1.53 +#else
1.54 +_LIT(KPersistsFiles, "c:\\system\\data\\cenrep\\persists\\*.*");
1.55 +#endif
1.56 +
1.57 +
1.58 +//Test repositories Uid
1.59 +const TUid KTestRepositoryUid={0x11111111};
1.60 +const TUid KCorruptRepositoryUid={0xBADBADBB};
1.61 +
1.62 +static TUid KCurrentTestUid;
1.63 +
1.64 +///////////////////////////////////////////////////////////////////////////////////////
1.65 +//Test macroses and functions
1.66 +LOCAL_C void CheckL(TInt aValue, TInt aLine)
1.67 + {
1.68 + if(!aValue)
1.69 + {
1.70 + RDebug::Print(_L("Error\r\n"));
1.71 + CleanupCDriveL();
1.72 + TheTest(EFalse, aLine);
1.73 + }
1.74 + }
1.75 +LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)
1.76 + {
1.77 + if(aValue != aExpected)
1.78 + {
1.79 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.80 + CleanupCDriveL();
1.81 + TheTest(EFalse, aLine);
1.82 + }
1.83 + }
1.84 +#define TESTL(arg) ::CheckL((arg), __LINE__)
1.85 +#define TEST2L(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)
1.86 +#define TESTKErrNoneL(aValue) ::CheckL(aValue,0,__LINE__);
1.87 +
1.88 +/////////////////////////////////////////////////////////////////////////////////////////
1.89 +class CenrepSrvOOMTest :public CBase
1.90 +{
1.91 +public:
1.92 + void GetL();
1.93 + void FindL();
1.94 + void ResetL();
1.95 + void NotifyL();
1.96 + void SetL();
1.97 + void CreateL();
1.98 + void DeleteL();
1.99 + void MoveL();
1.100 +
1.101 + CenrepSrvOOMTest();
1.102 + ~CenrepSrvOOMTest();
1.103 + static CenrepSrvOOMTest* NewL();
1.104 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.105 + void DoHeapRepositoryContentCheckL();
1.106 +#endif
1.107 +private:
1.108 + void ConstructL();
1.109 +public:
1.110 + CServerRepository* iServerRepo;
1.111 + CSessionNotifier* iSessionNotif;
1.112 +};
1.113 +
1.114 +//////////////////////////////////////////////////////////////////////////////////////////////////
1.115 +class CenrepSwiOOMTest :public CBase
1.116 +{
1.117 +public:
1.118 + void UpgradeROMRev1L(TBool aIsSetup);
1.119 + void UpgradeROMRev2L(TBool aIsSetup);
1.120 + void UninstallROMUpgradeL(TBool aIsSetup);
1.121 +
1.122 + void InstallL(TBool aIsSetup);
1.123 + void UpgradeInstallL(TBool aIsSetup);
1.124 + void UninstallL(TBool aIsSetup);
1.125 +
1.126 + CenrepSwiOOMTest();
1.127 + ~CenrepSwiOOMTest();
1.128 + static CenrepSwiOOMTest* NewL();
1.129 +private:
1.130 + void ConstructL();
1.131 + CCentRepSWIWatcher* iSwiWatcher;
1.132 +public:
1.133 +};
1.134 +//////////////////////////////////////////////////////////////////////////////////////////////////
1.135 +
1.136 +CenrepSrvOOMTest::CenrepSrvOOMTest(){}
1.137 +
1.138 +CenrepSrvOOMTest::~CenrepSrvOOMTest()
1.139 + {
1.140 + if (iServerRepo)
1.141 + {
1.142 + if (iSessionNotif)
1.143 + {
1.144 + iServerRepo->Close();
1.145 + }
1.146 + delete iServerRepo;
1.147 + }
1.148 + if (iSessionNotif)
1.149 + delete iSessionNotif;
1.150 +
1.151 + // Cache must be disabled here. Otherwise, if any idle repositories exists, they will
1.152 + // still be open (have their pointers in the iOpenRepositories list) and the list will leak.
1.153 + TServerResources::iCacheManager->DisableCache();
1.154 + TServerResources::iObserver->CloseiOpenRepositories();
1.155 + }
1.156 +
1.157 +CenrepSrvOOMTest* CenrepSrvOOMTest::NewL()
1.158 + {
1.159 + CenrepSrvOOMTest* self=new (ELeave)CenrepSrvOOMTest;
1.160 + CleanupStack::PushL(self);
1.161 + self->ConstructL();
1.162 + CleanupStack::Pop(self);
1.163 + return self;
1.164 + }
1.165 +
1.166 +void CenrepSrvOOMTest::ConstructL()
1.167 + {
1.168 + iServerRepo=new (ELeave)CServerRepository();
1.169 + iSessionNotif=new (ELeave) CSessionNotifier();
1.170 +
1.171 + iServerRepo->OpenL(KCurrentTestUid,*iSessionNotif);
1.172 + }
1.173 +
1.174 +//////////////////////////////////////////////////////////////////////////////////////////////////
1.175 +
1.176 +CenrepSwiOOMTest::CenrepSwiOOMTest(){}
1.177 +
1.178 +CenrepSwiOOMTest::~CenrepSwiOOMTest()
1.179 + {
1.180 + delete iSwiWatcher;
1.181 + }
1.182 +
1.183 +CenrepSwiOOMTest* CenrepSwiOOMTest::NewL()
1.184 + {
1.185 + CenrepSwiOOMTest* self=new (ELeave)CenrepSwiOOMTest;
1.186 + CleanupStack::PushL(self);
1.187 + self->ConstructL();
1.188 + CleanupStack::Pop(self);
1.189 + return self;
1.190 + }
1.191 +
1.192 +void CenrepSwiOOMTest::ConstructL()
1.193 + {
1.194 + iSwiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);
1.195 + }
1.196 +
1.197 +//Getting various information and security policy from the repository
1.198 +//TInt CServerRepository::Get(TUint32 aId,T& aVal)
1.199 +//TServerSetting* CServerRepository::GetSetting(TUint32 aId)
1.200 +void CenrepSrvOOMTest::GetL()
1.201 + {
1.202 + TInt err=KErrNone;
1.203 + TInt keyInt=0;
1.204 + TServerSetting* srvsetting;
1.205 + //----------Getting the TInt(1-15)-----------------------------
1.206 + for (TInt i=1;i<=15;i++)
1.207 + {
1.208 + err=iServerRepo->Get(i,keyInt);
1.209 + //Remember the policy check is done at the session level
1.210 + TESTKErrNoneL(err);
1.211 + TESTL(i==keyInt);
1.212 + srvsetting=iServerRepo->GetSetting(i);
1.213 + TESTL(srvsetting->Key()==static_cast<TUint32>(i));
1.214 + }
1.215 + //---------Getting the TReal(16-19)---------------------------
1.216 + TReal keyValue;
1.217 + err=iServerRepo->Get(16,keyValue);
1.218 + TESTKErrNoneL(err);
1.219 + TESTL(keyValue==10.1010);
1.220 + srvsetting=iServerRepo->GetSetting(16);
1.221 + TESTL(srvsetting->Key()==16);
1.222 +
1.223 + err=iServerRepo->Get(19,keyValue);
1.224 + TESTKErrNoneL(err);
1.225 + TESTL(keyValue==13.1313);
1.226 +
1.227 + //----------Getting the String(20-23)-----------------------
1.228 + TBuf8<50> keyString;
1.229 + _LIT(KFourteen,"fourteen");
1.230 + err=iServerRepo->Get(20,keyString);
1.231 + TESTKErrNoneL(err);
1.232 + //Even ascii(8 bytes) are stored as 16 bytes!!!
1.233 + TPtr16 str16((TUint16*) keyString.Ptr(),keyString.Length()/2,keyString.Length()/2);
1.234 + TESTL(str16.Compare(KFourteen)==0);
1.235 + srvsetting=iServerRepo->GetSetting(20);
1.236 + TESTL(srvsetting->Key()==20);
1.237 +
1.238 + //---------Getting the String8(0x79)------------------------
1.239 + TBuf8<50> keyString8;
1.240 + _LIT8(KString8,"string8");
1.241 + err=iServerRepo->Get(0x79,keyString8);
1.242 + TESTKErrNoneL(err);
1.243 + TESTL(keyString8.Compare(KString8)==0);
1.244 + srvsetting=iServerRepo->GetSetting(0x79);
1.245 + TESTL(srvsetting->Key()==0x79);
1.246 +
1.247 + //---------Getting the binary(0x82)-------------------------
1.248 + TBuf8<50> keyBinary;
1.249 + _LIT8(KBinary8,"\x12\x34\xAB\xCD");
1.250 + err=iServerRepo->Get(0x82,keyBinary);
1.251 + TESTKErrNoneL(err);
1.252 + //temporarily added to solve coverage problem in WINSCW
1.253 +#ifdef __EPOC32__
1.254 + TESTL(keyBinary.Compare(KBinary8)==0);
1.255 +#endif
1.256 + srvsetting=iServerRepo->GetSetting(0x82);
1.257 + TESTL(srvsetting->Key()==0x82);
1.258 +
1.259 + //----------Getting individual policy-----------------------
1.260 + //Current Exe has caps AllFiles+WriteDeviceData+ReadDeviceData
1.261 + RThread currentThread;
1.262 + TSecurityPolicy secPolicy;
1.263 + //default policy
1.264 + secPolicy=iServerRepo->GetDefaultReadAccessPolicy();
1.265 + TESTL(secPolicy.CheckPolicy(currentThread)==1);
1.266 + secPolicy=iServerRepo->GetDefaultWriteAccessPolicy();
1.267 + TESTL(secPolicy.CheckPolicy(currentThread)==1);
1.268 +
1.269 + //check settings policies
1.270 + //0x2 int 2 1 cap_rd=CommDD cap_wr=WriteDeviceData
1.271 + //0x19 int 25 0 //defined in range policies with cap_rd=NetworkServices
1.272 + secPolicy=iServerRepo->GetReadAccessPolicy(2);
1.273 + TESTL(secPolicy.CheckPolicy(currentThread)==0);
1.274 + secPolicy=iServerRepo->GetWriteAccessPolicy(2);
1.275 + TESTL(secPolicy.CheckPolicy(currentThread)==1);
1.276 + secPolicy=iServerRepo->GetReadAccessPolicy(25);
1.277 + TESTL(secPolicy.CheckPolicy(currentThread)==0);
1.278 +
1.279 + }
1.280 +
1.281 +// now that write operations must be done in transactions, setting up this helper
1.282 +// function to perform single Sets for the purpose of this test.
1.283 +template<class T>
1.284 +static TInt RepositorySingleSetL(CServerRepository& aRep, TUint32 aKey, const T& aValue)
1.285 + {
1.286 + aRep.StartTransaction(EConcurrentReadWriteTransaction);
1.287 + aRep.CleanupCancelTransactionPushL();
1.288 + aRep.TransactionSetL(aKey, aValue);
1.289 + CleanupStack::Pop();
1.290 + TUint32 keyInfo;
1.291 + return User::LeaveIfError(aRep.CommitTransaction(keyInfo));
1.292 + };
1.293 +
1.294 +//Setting OOM testing
1.295 +void CenrepSrvOOMTest::SetL()
1.296 + {
1.297 + TInt ret=KErrNone;
1.298 + TInt intValue=0;
1.299 + TReal realValue=0;
1.300 +
1.301 + //---------------SetL-----------------------------------
1.302 + //Setting an integer key
1.303 + ret = RepositorySingleSetL(*iServerRepo, 0x60, 600);
1.304 + TESTKErrNoneL(ret);
1.305 + ret=iServerRepo->Get(0x60,intValue);
1.306 + TESTL(intValue== 600);
1.307 +
1.308 + //Setting a real key
1.309 + ret = RepositorySingleSetL(*iServerRepo, 0x66, 99.99);
1.310 + TESTKErrNoneL(ret);
1.311 + ret=iServerRepo->Get(0x66,realValue);
1.312 + TESTL(realValue==99.99);
1.313 +
1.314 + //Setting a string key
1.315 + //Even ascii(8 bytes) are stored as 16 bytes!!!
1.316 + _LIT8(KString,"sixhundred");
1.317 + TBuf8<50> stringChangeValue=KString();
1.318 + ret = RepositorySingleSetL(*iServerRepo, 0x69, stringChangeValue);
1.319 + TESTKErrNoneL(ret);
1.320 +
1.321 + TBuf8<50> keyString;
1.322 + ret=iServerRepo->Get(0x69,keyString);
1.323 + TESTKErrNoneL(ret);
1.324 + TESTL(keyString.Compare(KString)==0);
1.325 + }
1.326 +
1.327 +// now that write operations must be done in transactions, setting up this helper
1.328 +// function to perform single Creates for the purpose of this test.
1.329 +template<class T>
1.330 +static TInt RepositorySingleCreateL(CServerRepository& aRep, TUint32 aKey, const T& aValue, TUint32* aMeta)
1.331 + {
1.332 + aRep.StartTransaction(EConcurrentReadWriteTransaction);
1.333 + aRep.CleanupCancelTransactionPushL();
1.334 + aRep.TransactionCreateL(aKey, aValue, aMeta);
1.335 + CleanupStack::Pop();
1.336 + TUint32 keyInfo;
1.337 + return User::LeaveIfError(aRep.CommitTransaction(keyInfo));
1.338 + };
1.339 +
1.340 +void CenrepSrvOOMTest::CreateL()
1.341 + {
1.342 + TInt ret=KErrNone;
1.343 + TInt intValue=0;
1.344 + TReal realValue=0;
1.345 +
1.346 + //--------------CreateL-----------------------------------
1.347 + //Creating an integer key
1.348 + TInt intRetValue;
1.349 + intValue=9000;
1.350 + RepositorySingleCreateL(*iServerRepo, 0x90, intValue, NULL);
1.351 + TESTKErrNoneL(ret);
1.352 + ret=iServerRepo->Get(0x90,intRetValue);
1.353 + TESTKErrNoneL(ret);
1.354 + TESTL(intRetValue==intValue);
1.355 +
1.356 + //Creating a real key
1.357 + TReal realRetValue;
1.358 + realValue=33.3333;
1.359 + RepositorySingleCreateL(*iServerRepo, 0x92, realValue, NULL);
1.360 + TESTKErrNoneL(ret);
1.361 + ret=iServerRepo->Get(0x92,realRetValue);
1.362 + TESTKErrNoneL(ret);
1.363 + TESTL(realValue==realRetValue);
1.364 +
1.365 + //Creating a string key
1.366 + _LIT8(KStringValue,"creatingkey");
1.367 + TBuf8<50> stringCreateValue=KStringValue();
1.368 + RepositorySingleCreateL(*iServerRepo, 0x93, stringCreateValue, NULL);
1.369 + TESTKErrNoneL(ret);
1.370 + }
1.371 +
1.372 +// now that write operations must be done in transactions, setting up this helper
1.373 +// function to perform single Creates for the purpose of this test.
1.374 +static TInt RepositorySingleDeleteL(CServerRepository& aRep, TUint32 aKey)
1.375 + {
1.376 + aRep.StartTransaction(EConcurrentReadWriteTransaction);
1.377 + aRep.CleanupCancelTransactionPushL();
1.378 + aRep.TransactionDeleteL(aKey);
1.379 + CleanupStack::Pop();
1.380 + TUint32 keyInfo;
1.381 + return User::LeaveIfError(aRep.CommitTransaction(keyInfo));
1.382 + };
1.383 +
1.384 +void CenrepSrvOOMTest::DeleteL()
1.385 + {
1.386 + TInt ret=KErrNone;
1.387 + //--------------Delete-----------------------------------
1.388 + //Find the settings 0x10A-0x10C to ensure it is still there
1.389 + RSettingPointerArray matchingArray;
1.390 + TUint32 partialId=0x100;
1.391 + TUint32 idMask=0xFFFFFFF0;
1.392 + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);
1.393 + if (ret==KErrNoMemory)
1.394 + {
1.395 + matchingArray.Close();
1.396 + User::LeaveNoMemory();
1.397 + }
1.398 +
1.399 + TESTKErrNoneL(ret);
1.400 + TESTL(matchingArray.Count()==3);
1.401 + matchingArray.Close();
1.402 +
1.403 + //Deleting settings 0x10A to 0x10C
1.404 + for (TInt i=0x10A;i<=0x10C;i++)
1.405 + {
1.406 + RepositorySingleDeleteL(*iServerRepo, i);
1.407 + TESTKErrNoneL(ret);
1.408 + }
1.409 + //After deleting try to find the persistent settings again
1.410 + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);
1.411 + if (ret==KErrNoMemory)
1.412 + {
1.413 + matchingArray.Close();
1.414 + User::LeaveNoMemory();
1.415 + }
1.416 + TESTKErrNoneL(ret);
1.417 + TESTL(matchingArray.Count()==0);
1.418 + matchingArray.Close();
1.419 +
1.420 + //-------------DeleteRange---------------------------------
1.421 + //Deleting settings 0x1 to 0xF
1.422 + TClientRequest dummyrequest;
1.423 + TUint32 errId=0;
1.424 + partialId=0;
1.425 + idMask=0xFFFFFFF0;
1.426 + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);
1.427 + if (ret==KErrNoMemory)
1.428 + {
1.429 + matchingArray.Close();
1.430 + User::LeaveNoMemory();
1.431 + }
1.432 + TESTKErrNoneL(ret) ;
1.433 + TESTL(matchingArray.Count()==15);
1.434 + matchingArray.Close();
1.435 +
1.436 + //Deleting settings using the DeleteRange
1.437 + dummyrequest.SetParam(0,partialId);
1.438 + dummyrequest.SetParam(1,idMask);
1.439 + dummyrequest.SetPolicyCheck(ETrue);
1.440 +
1.441 + // write operation must take place in a transaction
1.442 + iServerRepo->StartTransaction(EConcurrentReadWriteTransaction);
1.443 + iServerRepo->CleanupCancelTransactionPushL();
1.444 + iServerRepo->TransactionDeleteRangeL(dummyrequest,errId);
1.445 + CleanupStack::Pop();
1.446 + TUint32 keyInfo;
1.447 + User::LeaveIfError(iServerRepo->CommitTransaction(keyInfo));
1.448 +
1.449 + //Now try to find the key being deleted
1.450 + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray);
1.451 + if (ret==KErrNoMemory)
1.452 + {
1.453 + matchingArray.Close();
1.454 + User::LeaveNoMemory();
1.455 + }
1.456 + TESTKErrNoneL(ret);
1.457 + TESTL(matchingArray.Count()==0);
1.458 + matchingArray.Close();
1.459 + }
1.460 +
1.461 +//Setting existing key value then follow by commit
1.462 +void CenrepSrvOOMTest::MoveL()
1.463 + {
1.464 + RSettingPointerArray matchingArray;
1.465 + TUint32 idMask=0xFFFFFFF0;
1.466 +
1.467 + /*---------------MoveL-------------------------------------
1.468 + TUint32 sourcePartialId = aMessage.Int0();
1.469 + TUint32 targetPartialId = aMessage.Int1();
1.470 + TUint32 idMask = aMessage.Int2();
1.471 + */
1.472 + TClientRequest dummyrequest;
1.473 + TUint32 errId=0;
1.474 + TUint32 sourcePartialId=0x110;
1.475 + TUint32 targetPartialId=0x120;
1.476 + idMask=0xFFFFFFF0;
1.477 +
1.478 + TKeyFilter srcKeyIdentifier = {sourcePartialId, idMask};
1.479 + TPckg<TKeyFilter> pSrcIdentifier(srcKeyIdentifier);
1.480 + TKeyFilter tgtKeyIdentifier = {targetPartialId, idMask};
1.481 + TPckg<TKeyFilter> pTgtIdentifier(tgtKeyIdentifier);
1.482 +
1.483 + //First check to ensure the target key before move does not exist
1.484 + User::LeaveIfError(iServerRepo->FindSettings(targetPartialId,idMask,matchingArray));
1.485 + TESTL(matchingArray.Count()==0);
1.486 + matchingArray.Close();
1.487 +
1.488 + //moving from 0x110(0x11B,0x11C,0x11E) to 0x120
1.489 + dummyrequest.SetParam(0, &pSrcIdentifier);
1.490 + dummyrequest.SetParam(1, &pTgtIdentifier);
1.491 + dummyrequest.SetPolicyCheck(ETrue);
1.492 +
1.493 + // write operation must take place in a transaction
1.494 + iServerRepo->StartTransaction(EConcurrentReadWriteTransaction);
1.495 + iServerRepo->CleanupCancelTransactionPushL();
1.496 + iServerRepo->TransactionMoveL(dummyrequest,errId);
1.497 + CleanupStack::Pop();
1.498 + TUint32 keyInfo;
1.499 + User::LeaveIfError(iServerRepo->CommitTransaction(keyInfo));
1.500 +
1.501 + //Now try to find the key being moved
1.502 + User::LeaveIfError(iServerRepo->FindSettings(targetPartialId,idMask,matchingArray));
1.503 + TESTL(matchingArray.Count()==3);
1.504 + matchingArray.Close();
1.505 + }
1.506 +
1.507 +//Finding keys from the settings
1.508 +//TInt FindSettings(TUint32 aPartialId,TUint32 aIdMask,RSettingPointerArray& aMatches)
1.509 +//Guarantees the heap free in aMatches if this function fail
1.510 +void CenrepSrvOOMTest::FindL()
1.511 + {
1.512 + TInt ret=KErrNone;
1.513 + RSettingPointerArray foundIdArray;
1.514 + TUint32 partialId=0;
1.515 + TUint32 idMask=0;
1.516 + //-----------Finding settings array using partial id & mask------
1.517 +
1.518 + //------------------Real type---------------------------------
1.519 + //0x42,0x44,0x45,0x48
1.520 + partialId=0x40;
1.521 + idMask=0xFFFFFFF0;
1.522 + User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray));
1.523 + TESTKErrNoneL(ret);
1.524 + TESTL(foundIdArray.Count()==4);
1.525 + foundIdArray.Close();
1.526 +
1.527 + //-----------------String type-------------------------------
1.528 + //0x51,0x54,0x5B
1.529 + partialId=0x50;
1.530 + idMask=0xFFFFFFF0;
1.531 + User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray));
1.532 + TESTKErrNoneL(ret);
1.533 + TESTL(foundIdArray.Count()==3);
1.534 + foundIdArray.Close();
1.535 +
1.536 + //--------------------Int type----------------------------------------------------
1.537 + partialId=0x30;
1.538 + idMask=0xFFFFFFF0;
1.539 + //This should return only 0x30,0x34,0x35,0x39,0x3B( 5 items)
1.540 + User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray));
1.541 + TESTKErrNoneL(ret);
1.542 + TESTL(foundIdArray.Count()==5);
1.543 +
1.544 + //----------------Find comparison using EEqual & ENotEqual------------------------
1.545 + TInt searchValue=100;
1.546 + TClientRequest dummyrequest;
1.547 + RArray<TUint32> idArray;
1.548 + //Set the policycheck to always pass
1.549 + dummyrequest.SetPolicyCheck(ETrue);
1.550 + //Comparison using Equal
1.551 + TRAP(ret,iServerRepo->FindCompareL(foundIdArray,searchValue,EEqual,idArray));
1.552 + if (ret==KErrNoMemory)
1.553 + {
1.554 + //do not need to reset idArray as it is done inside the function itself when it returns not KErrNone
1.555 + foundIdArray.Close();
1.556 + User::LeaveNoMemory();
1.557 + }
1.558 + TESTL(idArray.Count()==2);
1.559 + TESTL((idArray[0]==0x30 && idArray[1]==0x34) || (idArray[0]==0x34 && idArray[1]==0x30));
1.560 + idArray.Close();
1.561 + //Comparison using ENotEqual
1.562 + TRAP(ret,iServerRepo->FindCompareL(foundIdArray,searchValue,ENotEqual,idArray));
1.563 + if (ret==KErrNoMemory)
1.564 + {
1.565 + //do not need to reset idArray as it is done inside the function itself when it returns not KErrNone
1.566 + foundIdArray.Close();
1.567 + User::LeaveNoMemory();
1.568 + }
1.569 + TESTL(idArray.Count()==3);
1.570 + idArray.Close();
1.571 + foundIdArray.Close();
1.572 +
1.573 + }
1.574 +
1.575 +//Resetting settings
1.576 +void CenrepSrvOOMTest::ResetL()
1.577 + {
1.578 + TInt ret=KErrNone;
1.579 + TInt retValue=0;
1.580 + TReal realValue=0;
1.581 +
1.582 + //-------------Single key reset----------------------------
1.583 +
1.584 + ret = RepositorySingleSetL(*iServerRepo, 1, 500);
1.585 + TESTKErrNoneL(ret);
1.586 + ret=iServerRepo->Get(1,retValue);
1.587 + TESTL(retValue==500);
1.588 +
1.589 + //Resetting individual settings
1.590 + ret=iServerRepo->ResetL(1);
1.591 + TESTKErrNoneL(ret);
1.592 +
1.593 + //Check for value once being reset
1.594 + ret=iServerRepo->Get(1,retValue);
1.595 + TESTL(retValue==1);
1.596 +
1.597 + //------------All keys reset------------------------------
1.598 + ret = RepositorySingleSetL(*iServerRepo, 17, 3.1343424);
1.599 + TESTKErrNoneL(ret);
1.600 +
1.601 + //Reset all settings from Rom
1.602 + User::LeaveIfError(iServerRepo->ResetAllL());
1.603 + TESTKErrNoneL(ret);
1.604 +
1.605 + //Check for value once all being reset
1.606 +
1.607 + ret=iServerRepo->Get(17,realValue);
1.608 + TESTL(realValue==11.1111);
1.609 + }
1.610 +
1.611 +void CenrepSrvOOMTest::NotifyL()
1.612 + {
1.613 + TInt err=KErrNone;
1.614 +
1.615 + //addding individual requests
1.616 + for (TInt i=0;i<10;i++)
1.617 + {
1.618 + TClientRequest dummyRequest;
1.619 + User::LeaveIfError(iSessionNotif->AddRequest(i,dummyRequest));
1.620 + }
1.621 +
1.622 + //adding group requests
1.623 + for (TInt i=0;i<10;i++)
1.624 + {
1.625 + TClientRequest dummyRequest;
1.626 + TUint32 partialId=100*i;
1.627 + TUint32 idMask=0xFFFFFFF0;
1.628 + User::LeaveIfError(iSessionNotif->AddRequest(partialId,idMask,dummyRequest));
1.629 + }
1.630 +
1.631 + //cancelling individual requests
1.632 + User::LeaveIfError(iSessionNotif->CancelRequest(5));
1.633 + //Check to ensure that it has been deleted so calling cancel again will return KErrNotFound
1.634 + err=iSessionNotif->CancelRequest(5);
1.635 + TESTL(err==KErrNotFound);
1.636 +
1.637 + //cancelling group requests
1.638 + User::LeaveIfError(iSessionNotif->CancelRequest(500,0xFFFFFFF0));
1.639 + err=iSessionNotif->CancelRequest(500,0xFFFFFF0);
1.640 + TESTL(err==KErrNotFound);
1.641 +
1.642 + //Finally cancel ALL requests
1.643 + iSessionNotif->CancelAllRequests();
1.644 +
1.645 + }
1.646 +
1.647 +//Deletes the CServerRepository object properly
1.648 +LOCAL_C void ReleaseRepository(TAny* aServerRepository)
1.649 + {
1.650 + CServerRepository* serverRepository = static_cast<CServerRepository*>(aServerRepository);
1.651 +
1.652 + TServerResources::iCacheManager->DisableCache();
1.653 + TServerResources::iObserver->CloseiOpenRepositories();
1.654 + delete serverRepository;
1.655 + TServerResources::iCacheManager->EnableCache();
1.656 + }
1.657 +
1.658 +//Opening a repository and closing the repository
1.659 +LOCAL_C void CreateDeleteL(TBool /*aOOMMode*/)
1.660 +{
1.661 + CServerRepository* serverRepo=new (ELeave)CServerRepository();
1.662 + TCleanupItem cleanupItem(&ReleaseRepository, serverRepo);
1.663 + CleanupStack::PushL(cleanupItem);
1.664 +
1.665 + CSessionNotifier* sessNotif=new (ELeave)CSessionNotifier();
1.666 + CleanupStack::PushL(sessNotif);
1.667 +
1.668 +// test access to a valid repository
1.669 + serverRepo->OpenL(KCurrentTestUid,*sessNotif);
1.670 + serverRepo->Close();
1.671 +
1.672 + CleanupStack::PopAndDestroy(sessNotif);
1.673 + CleanupStack::PopAndDestroy(1);
1.674 +}
1.675 +
1.676 +LOCAL_C void CreateDeleteCorruptL(TBool /*aOOMMode*/)
1.677 +{
1.678 + CServerRepository* serverRepo=new (ELeave)CServerRepository();
1.679 + TCleanupItem cleanupItem(&ReleaseRepository, serverRepo);
1.680 + CleanupStack::PushL(cleanupItem);
1.681 +
1.682 + CSessionNotifier* sessNotif=new (ELeave)CSessionNotifier();
1.683 + CleanupStack::PushL(sessNotif);
1.684 +
1.685 +// test access to a corrupt repository
1.686 + // trap KErrCorrupt
1.687 + TRAPD(err, serverRepo->OpenL(KCorruptRepositoryUid,*sessNotif));
1.688 + // leave if not KErrCorrupt
1.689 + User::LeaveIfError((err == KErrCorrupt) ? KErrNone : err);
1.690 + serverRepo->Close();
1.691 +
1.692 + CleanupStack::PopAndDestroy(sessNotif);
1.693 + CleanupStack::PopAndDestroy(1);
1.694 +}
1.695 +
1.696 +void CenrepSwiOOMTest::UpgradeROMRev1L(TBool aIsSetup)
1.697 + {
1.698 + if(aIsSetup)
1.699 + {
1.700 + RFs fs;
1.701 + User::LeaveIfError(fs.Connect());
1.702 + CleanupClosePushL(fs);
1.703 + CFileMan* fm = CFileMan::NewL(fs);
1.704 + CleanupStack::PushL(fm);
1.705 +
1.706 + // Copy rev 1 file into install dir & Reset read-only bit
1.707 + User::LeaveIfError(fm->Copy(KRomUpgradeRev1File, KUpgradeFile));
1.708 + User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));
1.709 + CleanupStack::PopAndDestroy(2); // fs and fm
1.710 + }
1.711 + else
1.712 + {
1.713 + iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);
1.714 + }
1.715 + }
1.716 +
1.717 +LOCAL_C void ModifyTimeStampL(RFs &fs, TDesC *fileName, TTime aTime)
1.718 + {
1.719 + // Reset read-only bit
1.720 + User::LeaveIfError(fs.SetAtt(*fileName, 0, KEntryAttReadOnly));
1.721 + TTimeIntervalHours interval(1);
1.722 + TTime newTime=aTime+interval;
1.723 + User::LeaveIfError(fs.SetModified(*fileName, newTime));
1.724 + }
1.725 +
1.726 +
1.727 +void CenrepSwiOOMTest::UpgradeROMRev2L(TBool aIsSetup)
1.728 + {
1.729 + if(aIsSetup)
1.730 + {
1.731 + // Set up rev 1
1.732 + UpgradeROMRev1L(ETrue);
1.733 + UpgradeROMRev1L(EFalse);
1.734 +
1.735 + RFs fs;
1.736 + User::LeaveIfError(fs.Connect());
1.737 + CleanupClosePushL(fs);
1.738 + CFileMan* fm = CFileMan::NewL(fs);
1.739 + CleanupStack::PushL(fm);
1.740 +
1.741 + // Get modification time
1.742 + TTime time;
1.743 + TBuf<50> fileName(KUpgradeFile);
1.744 + fs.Modified(fileName, time);
1.745 +
1.746 + // Copy rev2 file into install dir & Reset read-only bit
1.747 + User::LeaveIfError(fm->Copy(KRomUpgradeRev2File, KUpgradeFile));
1.748 + User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));
1.749 + // Modify timestamp to cause upgrade
1.750 + ModifyTimeStampL(fs,&fileName, time);
1.751 +
1.752 + CleanupStack::PopAndDestroy(2); // fs and fm
1.753 + }
1.754 + else
1.755 + {
1.756 + iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);
1.757 + }
1.758 +
1.759 + }
1.760 +
1.761 +void CenrepSwiOOMTest::UninstallROMUpgradeL(TBool aIsSetup)
1.762 + {
1.763 + if(aIsSetup)
1.764 + {
1.765 + // Install rev 2
1.766 + UpgradeROMRev2L(ETrue);
1.767 + UpgradeROMRev2L(EFalse);
1.768 +
1.769 + RFs fs;
1.770 + User::LeaveIfError(fs.Connect());
1.771 + CleanupClosePushL(fs);
1.772 + CFileMan* fm = CFileMan::NewL(fs);
1.773 + CleanupStack::PushL(fm);
1.774 +
1.775 + // Delete file from install dir
1.776 + User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));
1.777 + TInt err=fs.Delete(KUpgradeFile);
1.778 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.779 + User::Leave(err);
1.780 +
1.781 + CleanupStack::PopAndDestroy(2); // fs and fm
1.782 + }
1.783 + else
1.784 + {
1.785 + iSwiWatcher->HandleSWIEventL(ESASwisUninstall | ESASwisStatusSuccess);
1.786 + }
1.787 + }
1.788 +
1.789 +void CenrepSwiOOMTest::InstallL(TBool aIsSetup)
1.790 + {
1.791 + if(aIsSetup)
1.792 + {
1.793 + RFs fs;
1.794 + User::LeaveIfError(fs.Connect());
1.795 + CleanupClosePushL(fs);
1.796 + CFileMan* fm = CFileMan::NewL(fs);
1.797 + CleanupStack::PushL(fm);
1.798 +
1.799 + // Copy rev 1 file into install dir & Reset read-only bit
1.800 + User::LeaveIfError(fm->Copy(KInstallOnlyFile, KInstallFile));
1.801 + User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));
1.802 +
1.803 + CleanupStack::PopAndDestroy(2); // fs and fm
1.804 + }
1.805 + else
1.806 + {
1.807 + iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);
1.808 + }
1.809 + }
1.810 +
1.811 +void CenrepSwiOOMTest::UpgradeInstallL(TBool aIsSetup)
1.812 + {
1.813 + if(aIsSetup)
1.814 + {
1.815 + // Install file
1.816 + InstallL(ETrue);
1.817 + InstallL(EFalse);
1.818 +
1.819 + RFs fs;
1.820 + User::LeaveIfError(fs.Connect());
1.821 + CleanupClosePushL(fs);
1.822 + CFileMan* fm = CFileMan::NewL(fs);
1.823 + CleanupStack::PushL(fm);
1.824 +
1.825 + // Get modification time
1.826 + TTime time;
1.827 + TBuf<50> fileName(KInstallFile);
1.828 + fs.Modified(fileName, time);
1.829 +
1.830 + // Copy upgrade file into install dir & Reset read-only bit
1.831 + User::LeaveIfError(fm->Copy(KInstallOnlyUpgradeFile, KInstallFile));
1.832 + User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));
1.833 + // Modify timestamp to cause upgrade
1.834 + ModifyTimeStampL(fs,&fileName, time);
1.835 +
1.836 + CleanupStack::PopAndDestroy(2); // fs and fm
1.837 + }
1.838 + else
1.839 + {
1.840 + iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess);
1.841 + }
1.842 + }
1.843 +
1.844 +void CenrepSwiOOMTest::UninstallL(TBool aIsSetup)
1.845 + {
1.846 + if(aIsSetup)
1.847 + {
1.848 + // Install upgrade
1.849 + UpgradeInstallL(ETrue);
1.850 + UpgradeInstallL(EFalse);
1.851 +
1.852 + RFs fs;
1.853 + User::LeaveIfError(fs.Connect());
1.854 + CleanupClosePushL(fs);
1.855 + CFileMan* fm = CFileMan::NewL(fs);
1.856 + CleanupStack::PushL(fm);
1.857 +
1.858 + // Delete file from install dir
1.859 + User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));
1.860 + TInt err=fs.Delete(KInstallFile);
1.861 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.862 + User::Leave(err);
1.863 +
1.864 + // Create a cre persists file, doesn't matter what's in it, it should be deleted
1.865 + User::LeaveIfError(fm->Copy(KPersistsFileUpgraded, KInstallPersistsFile));
1.866 + User::LeaveIfError(fm->Attribs(KInstallPersistsFile,0,KEntryAttReadOnly,TTime(0)));
1.867 +
1.868 + CleanupStack::PopAndDestroy(2); // fs and fm
1.869 + }
1.870 + else
1.871 + {
1.872 + iSwiWatcher->HandleSWIEventL(ESASwisUninstall | ESASwisStatusSuccess);
1.873 + }
1.874 + }
1.875 +
1.876 +LOCAL_C void StartupUpgradeL(TBool aIsSetup)
1.877 +{
1.878 + if(aIsSetup)
1.879 + {
1.880 + // Set up files for test
1.881 + RFs fs;
1.882 + User::LeaveIfError(fs.Connect());
1.883 + CleanupClosePushL(fs);
1.884 + CFileMan* fm = CFileMan::NewL(fs);
1.885 + CleanupStack::PushL(fm);
1.886 +
1.887 + // Clean out files
1.888 + TInt err=fs.Delete(KInstallDirFile);
1.889 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.890 + User::Leave(err);
1.891 +
1.892 + // Cause directory listing with no files to be written
1.893 + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);
1.894 + delete swiWatcher;
1.895 +
1.896 + User::LeaveIfError(fm->Copy(KPersistsFileNoUpgrade, KPersistsFile));
1.897 + User::LeaveIfError(fm->Attribs(KPersistsFile,0,KEntryAttReadOnly,TTime(0)));
1.898 +
1.899 + User::LeaveIfError(fm->Copy(KRomUpgradeRev1File, KUpgradeFile));
1.900 + User::LeaveIfError(fm->Attribs(KUpgradeFile,0,KEntryAttReadOnly,TTime(0)));
1.901 +
1.902 + CleanupStack::PopAndDestroy(2); // fs and fm
1.903 + }
1.904 + else
1.905 + {
1.906 + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);
1.907 + delete swiWatcher;
1.908 + }
1.909 +}
1.910 +
1.911 +LOCAL_C void StartupDowngradeL(TBool aIsSetup)
1.912 +{
1.913 + if(aIsSetup)
1.914 + {
1.915 + StartupUpgradeL(ETrue);
1.916 + StartupUpgradeL(EFalse);
1.917 +
1.918 + // Set up files for test
1.919 + RFs fs;
1.920 + User::LeaveIfError(fs.Connect());
1.921 + CleanupClosePushL(fs);
1.922 + TInt err=fs.Delete(KUpgradeFile);
1.923 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.924 + User::Leave(err);
1.925 +
1.926 + CleanupStack::PopAndDestroy(); // fs
1.927 + }
1.928 + else
1.929 + {
1.930 + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);
1.931 + delete swiWatcher;
1.932 + }
1.933 +}
1.934 +
1.935 +LOCAL_C void StartupUninstallL(TBool aIsSetup)
1.936 +{
1.937 + if(aIsSetup)
1.938 + {
1.939 + RFs fs;
1.940 + User::LeaveIfError(fs.Connect());
1.941 + CleanupClosePushL(fs);
1.942 + CFileMan* fm = CFileMan::NewL(fs);
1.943 + CleanupStack::PushL(fm);
1.944 +
1.945 + // Copy rev 1 file into install dir & Reset read-only bit
1.946 + User::LeaveIfError(fm->Copy(KInstallOnlyFile, KInstallFile));
1.947 + User::LeaveIfError(fm->Attribs(KInstallFile,0,KEntryAttReadOnly,TTime(0)));
1.948 +
1.949 + // Cause directory listing to be written and file to be installed
1.950 + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);
1.951 + delete swiWatcher;
1.952 +
1.953 + // Create a persists file that will be deleted
1.954 + User::LeaveIfError(fm->Copy(KPersistsFileUpgraded, KInstallPersistsFile));
1.955 + User::LeaveIfError(fm->Attribs(KInstallPersistsFile,0,KEntryAttReadOnly,TTime(0)));
1.956 +
1.957 + TInt err=fs.Delete(KInstallFile);
1.958 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.959 + User::Leave(err);
1.960 +
1.961 + CleanupStack::PopAndDestroy(2); // fs and fm
1.962 + }
1.963 + else
1.964 + {
1.965 + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs);
1.966 + delete swiWatcher;
1.967 + }
1.968 +}
1.969 +
1.970 +// Type definition for pointer to function
1.971 +// Used for functions that can't use CenrepSrvOOMTest::ConstructL
1.972 +typedef void (*FuncPtrL) (TBool);
1.973 +/**
1.974 +Wrapper function to call all OOM test functions
1.975 +@param testFuncL pointer to OOM test function
1.976 +@param aTestDesc test function name
1.977 +*/
1.978 +LOCAL_C void DoOOMNoServReposL( FuncPtrL atestFuncL, const TDesC& aTestDesc, TBool aOOMMode)
1.979 + {
1.980 + TheTest.Next(aTestDesc);
1.981 +
1.982 + TInt err;
1.983 + TInt tryCount = 0;
1.984 + do
1.985 + {
1.986 + __UHEAP_MARK;
1.987 +
1.988 + //Initializing the server resources
1.989 + TServerResources::InitialiseL ();
1.990 + //Clear any files in the persist directory
1.991 + CleanupCDriveL();
1.992 +
1.993 + // find out the number of open handles
1.994 + TInt startProcessHandleCount;
1.995 + TInt startThreadHandleCount;
1.996 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.997 +
1.998 + (*atestFuncL)(ETrue);
1.999 +
1.1000 + if (aOOMMode)
1.1001 + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
1.1002 +
1.1003 + TRAP(err, (*atestFuncL)(EFalse));
1.1004 + if (err!=KErrNoMemory)
1.1005 + TESTKErrNoneL(err);
1.1006 +
1.1007 + if (aOOMMode)
1.1008 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.1009 +
1.1010 + // check that no handles have leaked
1.1011 + TInt endProcessHandleCount;
1.1012 + TInt endThreadHandleCount;
1.1013 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1014 + TEST2L(startProcessHandleCount, endProcessHandleCount);
1.1015 + TEST2L(startThreadHandleCount, endThreadHandleCount);
1.1016 +
1.1017 + //Freeing the server resources
1.1018 + TServerResources::Close();
1.1019 +
1.1020 + __UHEAP_MARKEND;
1.1021 + } while(err == KErrNoMemory);
1.1022 +
1.1023 + TESTKErrNoneL(err);
1.1024 + if (aOOMMode)
1.1025 + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
1.1026 + }
1.1027 +
1.1028 +// Type definition for pointer to member function.
1.1029 +// Used in calling the CRegistryDataTest member function for testing.
1.1030 +typedef void (CenrepSrvOOMTest::*ClassFuncPtrL) (void);
1.1031 +/**
1.1032 +Wrapper function to call all OOM test functions
1.1033 +@param testFuncL pointer to OOM test function
1.1034 +@param aTestDesc test function name
1.1035 +@param aOOMMode to enable/disable the OOM environment
1.1036 +*/
1.1037 +LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc,TBool aOOMMode)
1.1038 + {
1.1039 + TheTest.Next(aTestDesc);
1.1040 +
1.1041 + TInt err=KErrNone;
1.1042 + TInt tryCount = 0;
1.1043 + do
1.1044 + {
1.1045 + __UHEAP_MARK;
1.1046 +
1.1047 + //Initializing the server resources
1.1048 + TServerResources::InitialiseL ();
1.1049 +
1.1050 + //Clear any files in the persist directory
1.1051 + CleanupCDriveL();
1.1052 +
1.1053 + CenrepSrvOOMTest* theTest=CenrepSrvOOMTest::NewL();
1.1054 + CleanupStack::PushL(theTest);
1.1055 +
1.1056 + TInt startProcessHandleCount;
1.1057 + TInt startThreadHandleCount;
1.1058 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.1059 +
1.1060 + if (aOOMMode)
1.1061 + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
1.1062 +
1.1063 + TRAP(err, (theTest->*testFuncL)());
1.1064 +
1.1065 + if (aOOMMode)
1.1066 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.1067 +
1.1068 + if (err!=KErrNoMemory)
1.1069 + TESTKErrNoneL(err);
1.1070 +
1.1071 + CleanupStack::PopAndDestroy(theTest);
1.1072 +
1.1073 + // check that no handles have leaked
1.1074 + TInt endProcessHandleCount;
1.1075 + TInt endThreadHandleCount;
1.1076 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1077 +
1.1078 + TEST2L(startProcessHandleCount, endProcessHandleCount);
1.1079 + TEST2L(startThreadHandleCount, endThreadHandleCount);
1.1080 +
1.1081 + //Freeing the server resources
1.1082 + TServerResources::Close();
1.1083 + __UHEAP_MARKEND;
1.1084 + } while(err == KErrNoMemory);
1.1085 +
1.1086 + TESTKErrNoneL(err);
1.1087 + if (aOOMMode)
1.1088 + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
1.1089 + }
1.1090 +
1.1091 +// Type definition for pointer to member function.
1.1092 +// Used in calling the CRegistryDataTest member function for testing.
1.1093 +typedef void (CenrepSwiOOMTest::*ClassSwiFuncPtrL) (TBool);
1.1094 +/**
1.1095 +Wrapper function to call all OOM test functions
1.1096 +@param testFuncL pointer to OOM test function
1.1097 +@param aTestDesc test function name
1.1098 +@param aOOMMode to enable/disable the OOM environment
1.1099 +*/
1.1100 +LOCAL_C void DoOOMSwiTestL(ClassSwiFuncPtrL aTestFuncL, const TDesC& aTestDesc,TBool aOOMMode)
1.1101 + {
1.1102 + TheTest.Next(aTestDesc);
1.1103 +
1.1104 + TInt err=KErrNone;
1.1105 + TInt tryCount = 0;
1.1106 + do
1.1107 + {
1.1108 + __UHEAP_MARK;
1.1109 +
1.1110 + //Initializing the server resources
1.1111 + TServerResources::InitialiseL ();
1.1112 + //Clear any files in the persist directory
1.1113 + CleanupCDriveL();
1.1114 +
1.1115 + TInt startProcessHandleCount;
1.1116 + TInt startThreadHandleCount;
1.1117 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.1118 +
1.1119 + CenrepSwiOOMTest* theTest=CenrepSwiOOMTest::NewL();
1.1120 + CleanupStack::PushL(theTest);
1.1121 +
1.1122 + // Set up test
1.1123 + (theTest->*aTestFuncL)(ETrue);
1.1124 +
1.1125 + if (aOOMMode)
1.1126 + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
1.1127 +
1.1128 + TRAP(err, (theTest->*aTestFuncL)(EFalse));
1.1129 +
1.1130 + if (aOOMMode)
1.1131 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.1132 +
1.1133 + if (err!=KErrNoMemory)
1.1134 + TESTKErrNoneL(err);
1.1135 +
1.1136 + CleanupStack::PopAndDestroy(theTest);
1.1137 +
1.1138 + // check that no handles have leaked
1.1139 + TInt endProcessHandleCount;
1.1140 + TInt endThreadHandleCount;
1.1141 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1142 +
1.1143 + TEST2L(startProcessHandleCount, endProcessHandleCount);
1.1144 + TEST2L(startThreadHandleCount, endThreadHandleCount);
1.1145 +
1.1146 + //Freeing the server resources
1.1147 + TServerResources::Close();
1.1148 + __UHEAP_MARKEND;
1.1149 + } while(err == KErrNoMemory);
1.1150 +
1.1151 + TESTKErrNoneL(err);
1.1152 + if (aOOMMode)
1.1153 + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
1.1154 + }
1.1155 +
1.1156 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.1157 +void CenrepSrvOOMTest::DoHeapRepositoryContentCheckL()
1.1158 + {
1.1159 + CServerRepository* srv=iServerRepo;
1.1160 + //check setting and its meta
1.1161 + TServerSetting* setting=NULL;
1.1162 +
1.1163 + setting=srv->GetSetting(1);
1.1164 + TESTL(setting->iKey==1);
1.1165 + TESTL(setting->iMeta==0x80000010);
1.1166 + //points to global default policy here
1.1167 + TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);
1.1168 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1169 + TESTL(setting->iAccessPolicy->KeyMask()==1);
1.1170 +
1.1171 + setting=srv->GetSetting(2);
1.1172 + TESTL(setting->iKey==2);
1.1173 + TESTL(setting->iMeta==0xA0000010);
1.1174 + //points to global default policy here
1.1175 + TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);
1.1176 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1177 + TESTL(setting->iAccessPolicy->KeyMask()==1);
1.1178 +
1.1179 + setting=srv->GetSetting(3);
1.1180 + TESTL(setting->iKey==3);
1.1181 + TESTL(setting->iMeta==0x800000FF);
1.1182 + //points to global default policy here
1.1183 + TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);
1.1184 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1185 + TESTL(setting->iAccessPolicy->KeyMask()==1);
1.1186 +
1.1187 + setting=srv->GetSetting(4);
1.1188 + TESTL(setting->iKey==4);
1.1189 + TESTL(setting->iMeta==0x80000010);
1.1190 + TESTL(setting->iAccessPolicy->LowKey()==4);
1.1191 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1192 + TESTL(setting->iAccessPolicy->KeyMask()==0);
1.1193 +
1.1194 + setting=srv->GetSetting(5);
1.1195 + TESTL(setting->iKey==5);
1.1196 + TESTL(setting->iMeta==0xC0000063);
1.1197 + //points to global default policy here
1.1198 + TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);
1.1199 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1200 + TESTL(setting->iAccessPolicy->KeyMask()==1);
1.1201 +
1.1202 + setting=srv->GetSetting(6);
1.1203 + TESTL(setting->iKey==6);
1.1204 + TESTL(setting->iMeta==0x90000010);
1.1205 + TESTL(setting->iAccessPolicy->LowKey()==6);
1.1206 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1207 + TESTL(setting->iAccessPolicy->KeyMask()==0);
1.1208 +
1.1209 + setting=srv->GetSetting(7);
1.1210 + TESTL(setting->iKey==7);
1.1211 + TESTL(setting->iMeta==0x80000010);
1.1212 + TESTL(setting->iAccessPolicy->LowKey()==7);
1.1213 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1214 + TESTL(setting->iAccessPolicy->KeyMask()==0);
1.1215 +
1.1216 + setting=srv->GetSetting(9);
1.1217 + TESTL(setting->iKey==9);
1.1218 + TESTL(setting->iMeta==0x80000010);
1.1219 + TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);
1.1220 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1221 + TESTL(setting->iAccessPolicy->KeyMask()==1);
1.1222 +
1.1223 + setting=srv->GetSetting(10);
1.1224 + TESTL(setting->iKey==10);
1.1225 + TESTL(setting->iMeta==0x80000010);
1.1226 + TESTL(setting->iAccessPolicy->LowKey()==10);
1.1227 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1228 + TESTL(setting->iAccessPolicy->KeyMask()==0);
1.1229 +
1.1230 + setting=srv->GetSetting(300);
1.1231 + TESTL(setting->iKey==300);
1.1232 + TESTL(setting->iMeta==0x900003E7);
1.1233 + TESTL(setting->iAccessPolicy->LowKey()==KUnspecifiedKey);
1.1234 + TESTL(setting->iAccessPolicy->HighKey()==1);
1.1235 + TESTL(setting->iAccessPolicy->KeyMask()==1);
1.1236 + }
1.1237 +
1.1238 +LOCAL_C void DoAdditionalCheckingL()
1.1239 + {
1.1240 + TServerResources::InitialiseL ();
1.1241 +
1.1242 + CenrepSrvOOMTest* test=CenrepSrvOOMTest::NewL();
1.1243 + CleanupStack::PushL(test);
1.1244 + test->DoHeapRepositoryContentCheckL();
1.1245 +
1.1246 + CleanupStack::PopAndDestroy();
1.1247 +
1.1248 + TServerResources::Close();
1.1249 + }
1.1250 +
1.1251 +/**
1.1252 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4050
1.1253 +@SYMTestCaseDesc Verifying that CRE generated will have the latest CRE version which is currently 2
1.1254 +@SYMTestPriority High
1.1255 +@SYMTestActions Validating that CRE files generated with post PREQ2112 code will always contain version 2.
1.1256 + The unit test will load a txt repository and then modify some settings so that it gets persisted
1.1257 + in the persists directory. The test then read the cre files to verify that the version persisted
1.1258 + is the latest which is 2.
1.1259 +@SYMTestExpectedResults The correct file version is returned.
1.1260 +@SYMREQ REQ11282
1.1261 +*/
1.1262 +LOCAL_C void DoPersistedVersionCheckingL()
1.1263 + {
1.1264 + TheTest.Next (_L (" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4050 Verifying CRE generated will always be version 2 "));
1.1265 + TServerResources::InitialiseL ();
1.1266 +
1.1267 + const TUid KTestUid={0x88880000};
1.1268 + KCurrentTestUid=KTestUid;
1.1269 +
1.1270 + CenrepSrvOOMTest* test=CenrepSrvOOMTest::NewL();
1.1271 + CleanupStack::PushL(test);
1.1272 +
1.1273 + //persist immediately
1.1274 + test->iServerRepo->CommitChangesL();
1.1275 +
1.1276 + //now check the version of the CRE file
1.1277 + CHeapRepository* heap=CHeapRepository::NewL(KTestUid);
1.1278 + CleanupStack::PushL(heap);
1.1279 + TUint8 creVersion;
1.1280 + heap->CreateRepositoryFromCreFileL(TServerResources::iFs,_L("c:\\private\\10202be9\\persists\\88880000.cre"),creVersion);
1.1281 + TESTL(creVersion==KPersistFormatSupportsIndMetaIndicator);
1.1282 +
1.1283 + CleanupStack::PopAndDestroy(2,test);
1.1284 + TServerResources::Close();
1.1285 + }
1.1286 +/**
1.1287 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4051
1.1288 +@SYMTestCaseDesc Server side OOM loading of a multiple repository files
1.1289 +@SYMTestPriority High
1.1290 +@SYMTestActions Create the server class CServerRepository and used it to load the multi ROFS keyspace.
1.1291 + Test are repeated for the following keyspace combination such as TXT/TXT, CRE/TXT or TXT/CRE and CRE/CRE.
1.1292 + Test will also verify the resulting merged settings which includes checking
1.1293 + individual metadata bits and security policy bits
1.1294 +@SYMTestExpectedResults Server loading of the multi rofs keypsace should not fail and leak memory under OOM condition.
1.1295 +@SYMREQ REQ11282
1.1296 +*/
1.1297 +LOCAL_C void DoOOMMultiRofsTestL()
1.1298 + {
1.1299 + TheTest.Next (_L (" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4051 CENREPSRV MultiROFS OOM Test "));
1.1300 +
1.1301 + const TUid KMultiRofsRepositoryUid1={0xFFFF0000};
1.1302 + const TUid KMultiRofsRepositoryUid2={0xEEEE0000};
1.1303 + const TUid KMultiRofsRepositoryUid3={0xDDDD0000};
1.1304 + const TUid KMultiRofsRepositoryUid4={0xCCCC0000};
1.1305 +
1.1306 + //First Testuid=KMultiRofsRepositoryUid
1.1307 + //Testing the OOM of multi rofs processing
1.1308 + KCurrentTestUid=KMultiRofsRepositoryUid1;
1.1309 + DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);
1.1310 + DoAdditionalCheckingL();
1.1311 + KCurrentTestUid=KMultiRofsRepositoryUid2;
1.1312 + DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);
1.1313 + DoAdditionalCheckingL();
1.1314 + KCurrentTestUid=KMultiRofsRepositoryUid3;
1.1315 + DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);
1.1316 + DoAdditionalCheckingL();
1.1317 + KCurrentTestUid=KMultiRofsRepositoryUid4;
1.1318 + DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Multi ROFS Test"),ETrue);
1.1319 + DoAdditionalCheckingL();
1.1320 + }
1.1321 +#endif
1.1322 +
1.1323 +LOCAL_C void DoOOMTestsL()
1.1324 + {
1.1325 + TheTest.Next (_L (" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-LEGACY-T_OOMCENREP-0001 Starting CENREPSRV OOM Test "));
1.1326 + RFs fs;
1.1327 + User::LeaveIfError(fs.Connect());
1.1328 + CleanupClosePushL(fs);
1.1329 + CFileMan* fm = CFileMan::NewL(fs);
1.1330 + CleanupStack::PushL(fm);
1.1331 +
1.1332 + //Clear any files in the persist directory
1.1333 + CleanupCDriveL();
1.1334 +
1.1335 + //First Testuid=KTestRepositoryUid
1.1336 + KCurrentTestUid=KTestRepositoryUid;
1.1337 +
1.1338 + DoOOMTestL(&CenrepSrvOOMTest::GetL,_L("Get Basic Test"),EFalse);
1.1339 + DoOOMTestL(&CenrepSrvOOMTest::FindL,_L("FindL Basic Test"),EFalse);
1.1340 + DoOOMTestL(&CenrepSrvOOMTest::NotifyL,_L("NotifyL Basic Test"),EFalse);
1.1341 + DoOOMTestL(&CenrepSrvOOMTest::ResetL,_L("ResetL Basic Test"),EFalse);
1.1342 + // Save file without timestamp
1.1343 + User::LeaveIfError(fm->Copy(KPersistsFile, KPersistsFileNoUpgrade));
1.1344 + DoOOMTestL(&CenrepSrvOOMTest::SetL,_L("SetL Basic Test"),EFalse);
1.1345 + DoOOMTestL(&CenrepSrvOOMTest::CreateL,_L("CreateL Basic Test"),EFalse);
1.1346 + DoOOMTestL(&CenrepSrvOOMTest::DeleteL,_L("DeleteL Basic Test"),EFalse);
1.1347 + DoOOMTestL(&CenrepSrvOOMTest::MoveL,_L("MoveL Basic Test"),EFalse);
1.1348 +
1.1349 + //Clear any files in the persist directory
1.1350 + CleanupCDriveL();
1.1351 +
1.1352 + // Simulate response to SWI rom-upgrade and downgrade events
1.1353 + DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev1L,_L("SwiUpgradeROMRev1L Basic Test"),EFalse);
1.1354 + // Save file with timestamp
1.1355 + User::LeaveIfError(fm->Copy(KPersistsFile, KPersistsFileUpgraded));
1.1356 + DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev2L,_L("SwiUpgradeROMRev2L Basic Test"),EFalse);
1.1357 + DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallROMUpgradeL,_L("SwiUninstallROMUpgradeL Basic Test"),EFalse);
1.1358 +
1.1359 + // Simulate response to SWI new rep install/uninstall event events
1.1360 + DoOOMSwiTestL(&CenrepSwiOOMTest::InstallL,_L("SwiInstallL Basic Test"),EFalse);
1.1361 + DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeInstallL,_L("SwiUpgradeInstallL Basic Test"),EFalse);
1.1362 + DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallL,_L("SwiUninstallL Basic Test"),EFalse);
1.1363 +
1.1364 + // Simulate SWI events before server startup
1.1365 + DoOOMNoServReposL(&StartupUpgradeL, _L("Startup Upgrade Basic Test"), EFalse);
1.1366 + DoOOMNoServReposL(&StartupDowngradeL, _L("Startup Downgrade Basic Test"), EFalse);
1.1367 + DoOOMNoServReposL(&StartupUninstallL,_L("Startup Uninstall Basic Test"), EFalse);
1.1368 +
1.1369 + //OOM Test aOOMMode=ETrue
1.1370 + DoOOMNoServReposL(&CreateDeleteL, _L("Create Delete OOM Test"),ETrue);
1.1371 + DoOOMNoServReposL(&CreateDeleteCorruptL, _L("Create Delete Corrupt OOM Test"),ETrue);
1.1372 + DoOOMTestL(&CenrepSrvOOMTest::GetL,_L("Get OOM Test"),ETrue);
1.1373 + DoOOMTestL(&CenrepSrvOOMTest::FindL,_L("FindL OOM Test"),ETrue);
1.1374 + DoOOMTestL(&CenrepSrvOOMTest::NotifyL,_L("NotifyL OOM Test"),ETrue);
1.1375 + DoOOMTestL(&CenrepSrvOOMTest::ResetL,_L("ResetL OOM Test"),ETrue);
1.1376 + DoOOMTestL(&CenrepSrvOOMTest::SetL,_L("SetL OOM Test"),ETrue);
1.1377 + DoOOMTestL(&CenrepSrvOOMTest::CreateL,_L("CreateL OOM Test"),ETrue);
1.1378 + DoOOMTestL(&CenrepSrvOOMTest::DeleteL,_L("DeleteL OOM Test"),ETrue);
1.1379 + DoOOMTestL(&CenrepSrvOOMTest::MoveL,_L("MoveL OOM Test"),ETrue);
1.1380 +
1.1381 + //Clear any files in the persist directory
1.1382 + CleanupCDriveL();
1.1383 +
1.1384 + DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev1L,_L("SwiUpgradeROMRev1L OOM Test"),ETrue);
1.1385 + DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeROMRev2L,_L("SwiUpgradeROMRev2L OOM Test"),ETrue);
1.1386 + DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallROMUpgradeL,_L("SwiUninstallROMUpgradeL OOM Test"),ETrue);
1.1387 +
1.1388 + DoOOMSwiTestL(&CenrepSwiOOMTest::InstallL,_L("SwiInstallL OOM Test"),ETrue);
1.1389 + DoOOMSwiTestL(&CenrepSwiOOMTest::UpgradeInstallL,_L("SwiUpgradeInstallL OOM Test"),ETrue);
1.1390 + DoOOMSwiTestL(&CenrepSwiOOMTest::UninstallL,_L("SwiUninstallL OOM Test"),ETrue);
1.1391 +
1.1392 + DoOOMNoServReposL(&StartupUpgradeL, _L("Startup Upgrade OOM Test"), ETrue);
1.1393 + DoOOMNoServReposL(&StartupDowngradeL, _L("Startup Downgrade OOM Test"), ETrue);
1.1394 + DoOOMNoServReposL(&StartupUninstallL, _L("Startup Uninstall OOM Test"), ETrue);
1.1395 +
1.1396 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.1397 + DoPersistedVersionCheckingL();
1.1398 + DoOOMMultiRofsTestL();
1.1399 +#endif
1.1400 +
1.1401 + // Delete files from bur dir
1.1402 + User::LeaveIfError(fm->Attribs(KPersistsFileNoUpgrade,0,KEntryAttReadOnly,TTime(0)));
1.1403 + TInt err=fs.Delete(KPersistsFileNoUpgrade);
1.1404 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.1405 + User::Leave(err);
1.1406 +
1.1407 + User::LeaveIfError(fm->Attribs(KPersistsFileUpgraded,0,KEntryAttReadOnly,TTime(0)));
1.1408 + err=fs.Delete(KPersistsFileUpgraded);
1.1409 + if((err!=KErrNone)&&(err!=KErrNotFound))
1.1410 + User::Leave(err);
1.1411 +
1.1412 +
1.1413 + //Clear any files in the persist directory
1.1414 + CleanupCDriveL();
1.1415 +
1.1416 + CleanupStack::PopAndDestroy (2); // fs and fm
1.1417 + }
1.1418 +
1.1419 +
1.1420 +LOCAL_C void MainL()
1.1421 + {
1.1422 + TheTest.Title ();
1.1423 + TheTest.Start (_L("OOM Cenrepserv Test"));
1.1424 +
1.1425 + CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;
1.1426 + CActiveScheduler::Install(scheduler);
1.1427 +
1.1428 + DoOOMTestsL();
1.1429 +
1.1430 + //Clear any files in the persist directory
1.1431 + CleanupCDriveL();
1.1432 +
1.1433 + TheFs.Close ();
1.1434 +
1.1435 + delete scheduler;
1.1436 +
1.1437 + TheTest.End ();
1.1438 + TheTest.Close ();
1.1439 + }
1.1440 +
1.1441 +TInt E32Main ()
1.1442 + {
1.1443 +
1.1444 + __UHEAP_MARK;
1.1445 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1446 + if(!cleanup)
1.1447 + return KErrNoMemory;
1.1448 +
1.1449 + TRAPD(err, MainL());
1.1450 + if (err != KErrNone)
1.1451 + User::Panic(_L("Testing failed: "), err);
1.1452 +
1.1453 + delete cleanup;
1.1454 + __UHEAP_MARKEND;
1.1455 +
1.1456 + return KErrNone;
1.1457 + }